jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/runtime/ScriptFunctionData.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/ScriptFunctionData.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/ScriptFunctionData.java

Thu, 24 May 2018 16:39:31 +0800

author: aoqi
date: Thu, 24 May 2018 16:39:31 +0800
changeset 1959: 61ffdd1b89f2
parent 1647: fa7dce1af94e
parent 1490: d85f981c8cf8
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jdk.nashorn.internal.runtime;
 import static jdk.nashorn.internal.lookup.Lookup.MH;
 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 import jdk.nashorn.internal.runtime.linker.LinkerCallSite;
 /**
  * A container for data needed to instantiate a specific {@link ScriptFunction} at runtime.
  * Instances of this class are created during codegen and stored in script classes'
  * constants array to reduce function instantiation overhead during runtime.
  */
 public abstract class ScriptFunctionData implements Serializable {
     static final int MAX_ARITY = LinkerCallSite.ARGLIMIT;
     static {
         // Assert it fits in a byte, as that's what we store it in. It's just a size optimization though, so if needed
         // "byte arity" field can be widened.
         assert MAX_ARITY < 256;
     }
     /** Name of the function or "" for anonymous functions */
     protected final String name;
     /**
      * A list of code versions of a function sorted in ascending order of generic descriptors.
      */
     protected transient LinkedList<CompiledFunction> code = new LinkedList<>();
     /** Function flags */
     protected int flags;
     // Parameter arity of the function, corresponding to "f.length". E.g. "function f(a, b, c) { ... }" arity is 3, and
     // some built-in ECMAScript functions have their arity declared by the specification. Note that regardless of this
     // value, the function might still be capable of receiving variable number of arguments, see isVariableArity.
     private int arity;
     /**
      * A pair of method handles used for generic invoker and constructor. Field is volatile as it can be initialized by
      * multiple threads concurrently, but we still tolerate a race condition in it as all values stored into it are
      * idempotent.
      */
     private volatile transient GenericInvokers genericInvokers;
     private static final MethodHandle BIND_VAR_ARGS = findOwnMH("bindVarArgs", Object[].class, Object[].class, Object[].class);
     /** Is this a strict mode function? */
     public static final int IS_STRICT            = 1 << 0;
     /** Is this a built-in function? */
     public static final int IS_BUILTIN           = 1 << 1;
     /** Is this a constructor function? */
     public static final int IS_CONSTRUCTOR       = 1 << 2;
     /** Does this function expect a callee argument? */
     public static final int NEEDS_CALLEE         = 1 << 3;
     /** Does this function make use of the this-object argument? */
     public static final int USES_THIS            = 1 << 4;
     /** Is this a variable arity function? */
     public static final int IS_VARIABLE_ARITY    = 1 << 5;
     /** Is this a object literal property getter or setter? */
     public static final int IS_PROPERTY_ACCESSOR = 1 << 6;
     /** Flag for strict or built-in functions */
     public static final int IS_STRICT_OR_BUILTIN = IS_STRICT | IS_BUILTIN;
     /** Flag for built-in constructors */
     public static final int IS_BUILTIN_CONSTRUCTOR = IS_BUILTIN | IS_CONSTRUCTOR;
     private static final long serialVersionUID = 4252901245508769114L;
     /**
      * Constructor
      *
      * @param name  script function name
      * @param arity arity
      * @param flags the function flags
      */
     ScriptFunctionData(final String name, final int arity, final int flags) {
         this.name  = name;
         this.flags = flags;
         setArity(arity);
     }
     final int getArity() {
         return arity;
     }
     final boolean isVariableArity() {
         return (flags & IS_VARIABLE_ARITY) != 0;
     }
     final boolean isPropertyAccessor() {
         return (flags & IS_PROPERTY_ACCESSOR) != 0;
     }
     /**
      * Used from e.g. Native*$Constructors as an explicit call. TODO - make arity immutable and final
      * @param arity new arity
      */
     void setArity(final int arity) {
         if(arity < 0 || arity > MAX_ARITY) {
             throw new IllegalArgumentException(String.valueOf(arity));
         }
         this.arity = arity;
     }
     CompiledFunction bind(final CompiledFunction originalInv, final ScriptFunction fn, final Object self, final Object[] args) {
         final MethodHandle boundInvoker = bindInvokeHandle(originalInv.createComposableInvoker(), fn, self, args);
         if (isConstructor()) {
             return new CompiledFunction(boundInvoker, bindConstructHandle(originalInv.createComposableConstructor(), fn, args), null);
         }
         return new CompiledFunction(boundInvoker);
     }
     /**
      * Is this a ScriptFunction generated with strict semantics?
      * @return true if strict, false otherwise
      */
     public final boolean isStrict() {
         return (flags & IS_STRICT) != 0;
     }
     /**
      * Return the complete internal function name for this
      * data, not anonymous or similar. May be identical
      * @return internal function name
      */
     protected String getFunctionName() {
         return getName();
     }
     final boolean isBuiltin() {
         return (flags & IS_BUILTIN) != 0;
     }
     final boolean isConstructor() {
         return (flags & IS_CONSTRUCTOR) != 0;
     }
     abstract boolean needsCallee();
     /**
      * Returns true if this is a non-strict, non-built-in function that requires non-primitive this argument
      * according to ECMA 10.4.3.
      * @return true if this argument must be an object
      */
     final boolean needsWrappedThis() {
         return (flags & USES_THIS) != 0 && (flags & IS_STRICT_OR_BUILTIN) == 0;
     }
     String toSource() {
         return "function " + (name == null ? "" : name) + "() { [native code] }";
     }
     String getName() {
         return name;
     }
     /**
      * Get this function as a String containing its source code. If no source code
      * exists in this ScriptFunction, its contents will be displayed as {@code [native code]}
      *
      * @return string representation of this function
      */
     @Override
     public String toString() {
         return name.isEmpty() ? "<anonymous>" : name;
     }
     /**
      * Verbose description of data
      * @return verbose description
      */
     public String toStringVerbose() {
         final StringBuilder sb = new StringBuilder();
         sb.append("name='").
                 append(name.isEmpty() ? "<anonymous>" : name).
                 append("' ").
                 append(code.size()).
                 append(" invokers=").
                 append(code);
         return sb.toString();
     }
     /**
      * Pick the best invoker, i.e. the one version of this method with as narrow and specific
      * types as possible. If the call site arguments are objects, but boxed primitives we can
      * also try to get a primitive version of the method and do an unboxing filter, but then
      * we need to insert a guard that checks the argument is really always a boxed primitive
      * and not suddenly a "real" object
      *
      * @param callSiteType callsite type
      * @return compiled function object representing the best invoker.
      */
     final CompiledFunction getBestInvoker(final MethodType callSiteType, final ScriptObject runtimeScope) {
         return getBestInvoker(callSiteType, runtimeScope, CompiledFunction.NO_FUNCTIONS);
     }
     final CompiledFunction getBestInvoker(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {
         final CompiledFunction cf = getBest(callSiteType, runtimeScope, forbidden);
         assert cf != null;
         return cf;
     }
     final CompiledFunction getBestConstructor(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {
         if (!isConstructor()) {
             throw typeError("not.a.constructor", toSource());
         }
         // Constructor call sites don't have a "this", but getBest is meant to operate on "callee, this, ..." style
         final CompiledFunction cf = getBest(callSiteType.insertParameterTypes(1, Object.class), runtimeScope, forbidden);
         return cf;
     }
     /**
      * If we can have lazy code generation, this is a hook to ensure that the code has been compiled.
      * This does not guarantee the code been installed in this {@code ScriptFunctionData} instance
      */
     protected void ensureCompiled() {
         //empty
     }
     /**
      * Return a generic Object/Object invoker for this method. It will ensure code
      * is generated, get the most generic of all versions of this function and adapt it
      * to Objects.
      *
      * @param runtimeScope the runtime scope. It can be used to evaluate types of scoped variables to guide the
      * optimistic compilation, should the call to this method trigger code compilation. Can be null if current runtime
      * scope is not known, but that might cause compilation of code that will need more deoptimization passes.
      * @return generic invoker of this script function
      */
     final MethodHandle getGenericInvoker(final ScriptObject runtimeScope) {
         // This method has race conditions both on genericsInvoker and genericsInvoker.invoker, but even if invoked
         // concurrently, they'll create idempotent results, so it doesn't matter. We could alternatively implement this
         // using java.util.concurrent.AtomicReferenceFieldUpdater, but it's hardly worth it.
         final GenericInvokers lgenericInvokers = ensureGenericInvokers();
         MethodHandle invoker = lgenericInvokers.invoker;
         if(invoker == null) {
             lgenericInvokers.invoker = invoker = createGenericInvoker(runtimeScope);
         }
         return invoker;
     }
     private MethodHandle createGenericInvoker(final ScriptObject runtimeScope) {
         return makeGenericMethod(getGeneric(runtimeScope).createComposableInvoker());
     }
     final MethodHandle getGenericConstructor(final ScriptObject runtimeScope) {
         // This method has race conditions both on genericsInvoker and genericsInvoker.constructor, but even if invoked
         // concurrently, they'll create idempotent results, so it doesn't matter. We could alternatively implement this
         // using java.util.concurrent.AtomicReferenceFieldUpdater, but it's hardly worth it.
         final GenericInvokers lgenericInvokers = ensureGenericInvokers();
         MethodHandle constructor = lgenericInvokers.constructor;
         if(constructor == null) {
             lgenericInvokers.constructor = constructor = createGenericConstructor(runtimeScope);
         }
         return constructor;
     }
     private MethodHandle createGenericConstructor(final ScriptObject runtimeScope) {
         return makeGenericMethod(getGeneric(runtimeScope).createComposableConstructor());
     }
     private GenericInvokers ensureGenericInvokers() {
         GenericInvokers lgenericInvokers = genericInvokers;
         if(lgenericInvokers == null) {
             genericInvokers = lgenericInvokers = new GenericInvokers();
         }
         return lgenericInvokers;
     }
     private static MethodType widen(final MethodType cftype) {
         final Class<?>[] paramTypes = new Class<?>[cftype.parameterCount()];
         for (int i = 0; i < cftype.parameterCount(); i++) {
             paramTypes[i] = cftype.parameterType(i).isPrimitive() ? cftype.parameterType(i) : Object.class;
         }
         return MH.type(cftype.returnType(), paramTypes);
     }
     /**
      * Used to find an apply to call version that fits this callsite.
      * We cannot just, as in the normal matcher case, return e.g. (Object, Object, int)
      * for (Object, Object, int, int, int) or we will destroy the semantics and get
      * a function that, when padded with undefined values, behaves differently
      * @param type actual call site type
      * @return apply to call that perfectly fits this callsite or null if none found
      */
     CompiledFunction lookupExactApplyToCall(final MethodType type) {
         for (final CompiledFunction cf : code) {
             if (!cf.isApplyToCall()) {
                 continue;
             }
             final MethodType cftype = cf.type();
             if (cftype.parameterCount() != type.parameterCount()) {
                 continue;
             }
             if (widen(cftype).equals(widen(type))) {
                 return cf;
             }
         }
         return null;
     }
     CompiledFunction pickFunction(final MethodType callSiteType, final boolean canPickVarArg) {
         for (final CompiledFunction candidate : code) {
             if (candidate.matchesCallSite(callSiteType, canPickVarArg)) {
                 return candidate;
             }
         }
         return null;
     }
     /**
      * Returns the best function for the specified call site type.
      * @param callSiteType The call site type. Call site types are expected to have the form
      * {@code (callee, this[, args...])}.
      * @param runtimeScope the runtime scope. It can be used to evaluate types of scoped variables to guide the
      * optimistic compilation, should the call to this method trigger code compilation. Can be null if current runtime
      * scope is not known, but that might cause compilation of code that will need more deoptimization passes.
      * @param linkLogicOkay is a CompiledFunction with a LinkLogic acceptable?
      * @return the best function for the specified call site type.
      */
     abstract CompiledFunction getBest(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden, final boolean linkLogicOkay);
     /**
      * Returns the best function for the specified call site type.
      * @param callSiteType The call site type. Call site types are expected to have the form
      * {@code (callee, this[, args...])}.
      * @param runtimeScope the runtime scope. It can be used to evaluate types of scoped variables to guide the
      * optimistic compilation, should the call to this method trigger code compilation. Can be null if current runtime
      * scope is not known, but that might cause compilation of code that will need more deoptimization passes.
      * @return the best function for the specified call site type.
      */
     final CompiledFunction getBest(final MethodType callSiteType, final ScriptObject runtimeScope, final Collection<CompiledFunction> forbidden) {
         return getBest(callSiteType, runtimeScope, forbidden, true);
     }
     boolean isValidCallSite(final MethodType callSiteType) {
         return callSiteType.parameterCount() >= 2  && // Must have at least (callee, this)
                callSiteType.parameterType(0).isAssignableFrom(ScriptFunction.class); // Callee must be assignable from script function
     }
     CompiledFunction getGeneric(final ScriptObject runtimeScope) {
         return getBest(getGenericType(), runtimeScope, CompiledFunction.NO_FUNCTIONS, false);
     }
     /**
      * Get a method type for a generic invoker.
      * @return the method type for the generic invoker
      */
     abstract MethodType getGenericType();
     /**
      * Allocates an object using this function's allocator.
      *
      * @param map the property map for the allocated object.
      * @return the object allocated using this function's allocator, or null if the function doesn't have an allocator.
      */
     ScriptObject allocate(final PropertyMap map) {
         return null;
     }
     /**
      * Get the property map to use for objects allocated by this function.
      *
      * @param prototype the prototype of the allocated object
      * @return the property map for allocated objects.
      */
     PropertyMap getAllocatorMap(final ScriptObject prototype) {
         return null;
     }
     /**
      * This method is used to create the immutable portion of a bound function.
      * See {@link ScriptFunction#createBound(Object, Object[])}
      *
      * @param fn the original function being bound
      * @param self this reference to bind. Can be null.
      * @param args additional arguments to bind. Can be null.
      */
     ScriptFunctionData makeBoundFunctionData(final ScriptFunction fn, final Object self, final Object[] args) {
         final Object[] allArgs = args == null ? ScriptRuntime.EMPTY_ARRAY : args;
         final int length = args == null ? 0 : args.length;
         // Clear the callee and this flags
         final int boundFlags = flags & ~NEEDS_CALLEE & ~USES_THIS;
         final List<CompiledFunction> boundList = new LinkedList<>();
         final ScriptObject runtimeScope = fn.getScope();
         final CompiledFunction bindTarget = new CompiledFunction(getGenericInvoker(runtimeScope), getGenericConstructor(runtimeScope), null);
         boundList.add(bind(bindTarget, fn, self, allArgs));
         return new FinalScriptFunctionData(name, Math.max(0, getArity() - length), boundList, boundFlags);
     }
     /**
      * Convert this argument for non-strict functions according to ES 10.4.3
      *
      * @param thiz the this argument
      *
      * @return the converted this object
      */
     private Object convertThisObject(final Object thiz) {
         return needsWrappedThis() ? wrapThis(thiz) : thiz;
     }
     static Object wrapThis(final Object thiz) {
         if (!(thiz instanceof ScriptObject)) {
             if (JSType.nullOrUndefined(thiz)) {
                 return Context.getGlobal();
             }
             if (isPrimitiveThis(thiz)) {
                 return Context.getGlobal().wrapAsObject(thiz);
             }
         }
         return thiz;
     }
     static boolean isPrimitiveThis(final Object obj) {
         return JSType.isString(obj) || obj instanceof Number || obj instanceof Boolean;
     }
     /**
      * Creates an invoker method handle for a bound function.
      *
      * @param targetFn the function being bound
      * @param originalInvoker an original invoker method handle for the function. This can be its generic invoker or
      * any of its specializations.
      * @param self the "this" value being bound
      * @param args additional arguments being bound
      *
      * @return a bound invoker method handle that will bind the self value and the specified arguments. The resulting
      * invoker never needs a callee; if the original invoker needed it, it will be bound to {@code fn}. The resulting
      * invoker still takes an initial {@code this} parameter, but it is always dropped and the bound {@code self} passed
      * to the original invoker on invocation.
      */
     private MethodHandle bindInvokeHandle(final MethodHandle originalInvoker, final ScriptFunction targetFn, final Object self, final Object[] args) {
         // Is the target already bound? If it is, we won't bother binding either callee or self as they're already bound
         // in the target and will be ignored anyway.
         final boolean isTargetBound = targetFn.isBoundFunction();
         final boolean needsCallee = needsCallee(originalInvoker);
         assert needsCallee == needsCallee() : "callee contract violation 2";
         assert !(isTargetBound && needsCallee); // already bound functions don't need a callee
         final Object boundSelf = isTargetBound ? null : convertThisObject(self);
         final MethodHandle boundInvoker;
         if (isVarArg(originalInvoker)) {
             // First, bind callee and this without arguments
             final MethodHandle noArgBoundInvoker;
             if (isTargetBound) {
                 // Don't bind either callee or this
                 noArgBoundInvoker = originalInvoker;
             } else if (needsCallee) {
                 // Bind callee and this
                 noArgBoundInvoker = MH.insertArguments(originalInvoker, 0, targetFn, boundSelf);
             } else {
                 // Only bind this
                 noArgBoundInvoker = MH.bindTo(originalInvoker, boundSelf);
             }
             // Now bind arguments
             if (args.length > 0) {
                 boundInvoker = varArgBinder(noArgBoundInvoker, args);
             } else {
                 boundInvoker = noArgBoundInvoker;
             }
         } else {
             // If target is already bound, insert additional bound arguments after "this" argument, at position 1.
             final int argInsertPos = isTargetBound ? 1 : 0;
             final Object[] boundArgs = new Object[Math.min(originalInvoker.type().parameterCount() - argInsertPos, args.length + (isTargetBound ? 0 : needsCallee  ? 2 : 1))];
             int next = 0;
             if (!isTargetBound) {
                 if (needsCallee) {
                     boundArgs[next++] = targetFn;
                 }
                 boundArgs[next++] = boundSelf;
             }
             // If more bound args were specified than the function can take, we'll just drop those.
             System.arraycopy(args, 0, boundArgs, next, boundArgs.length - next);
             // If target is already bound, insert additional bound arguments after "this" argument, at position 1;
             // "this" will get dropped anyway by the target invoker. We previously asserted that already bound functions
             // don't take a callee parameter, so we can know that the signature is (this[, args...]) therefore args
             // start at position 1. If the function is not bound, we start inserting arguments at position 0.
             boundInvoker = MH.insertArguments(originalInvoker, argInsertPos, boundArgs);
         }
         if (isTargetBound) {
             return boundInvoker;
         }
         // If the target is not already bound, add a dropArguments that'll throw away the passed this
         return MH.dropArguments(boundInvoker, 0, Object.class);
     }
     /**
      * Creates a constructor method handle for a bound function using the passed constructor handle.
      *
      * @param originalConstructor the constructor handle to bind. It must be a composed constructor.
      * @param fn the function being bound
      * @param args arguments being bound
      *
      * @return a bound constructor method handle that will bind the specified arguments. The resulting constructor never
      * needs a callee; if the original constructor needed it, it will be bound to {@code fn}. The resulting constructor
      * still takes an initial {@code this} parameter and passes it to the underlying original constructor. Finally, if
      * this script function data object has no constructor handle, null is returned.
      */
     private static MethodHandle bindConstructHandle(final MethodHandle originalConstructor, final ScriptFunction fn, final Object[] args) {
         assert originalConstructor != null;
         // If target function is already bound, don't bother binding the callee.
         final MethodHandle calleeBoundConstructor = fn.isBoundFunction() ? originalConstructor :
             MH.dropArguments(MH.bindTo(originalConstructor, fn), 0, ScriptFunction.class);
         if (args.length == 0) {
             return calleeBoundConstructor;
         }
         if (isVarArg(calleeBoundConstructor)) {
             return varArgBinder(calleeBoundConstructor, args);
         }
         final Object[] boundArgs;
         final int maxArgCount = calleeBoundConstructor.type().parameterCount() - 1;
         if (args.length <= maxArgCount) {
             boundArgs = args;
         } else {
             boundArgs = new Object[maxArgCount];
             System.arraycopy(args, 0, boundArgs, 0, maxArgCount);
         }
         return MH.insertArguments(calleeBoundConstructor, 1, boundArgs);
     }
     /**
      * Takes a method handle, and returns a potentially different method handle that can be used in
      * {@code ScriptFunction#invoke(Object, Object...)} or {code ScriptFunction#construct(Object, Object...)}.
      * The returned method handle will be sure to return {@code Object}, and will have all its parameters turned into
      * {@code Object} as well, except for the following ones:
      * <ul>
      *   <li>a last parameter of type {@code Object[]} which is used for vararg functions,</li>
      *   <li>the first argument, which is forced to be {@link ScriptFunction}, in case the function receives itself
      *   (callee) as an argument.</li>
      * </ul>
      *
      * @param mh the original method handle
      *
      * @return the new handle, conforming to the rules above.
      */
     private static MethodHandle makeGenericMethod(final MethodHandle mh) {
         final MethodType type = mh.type();
         final MethodType newType = makeGenericType(type);
         return type.equals(newType) ? mh : mh.asType(newType);
     }
     private static MethodType makeGenericType(final MethodType type) {
         MethodType newType = type.generic();
         if (isVarArg(type)) {
             newType = newType.changeParameterType(type.parameterCount() - 1, Object[].class);
         }
         if (needsCallee(type)) {
             newType = newType.changeParameterType(0, ScriptFunction.class);
         }
         return newType;
     }
     /**
      * Execute this script function.
      *
      * @param self  Target object.
      * @param arguments  Call arguments.
      * @return ScriptFunction result.
      *
      * @throws Throwable if there is an exception/error with the invocation or thrown from it
      */
     Object invoke(final ScriptFunction fn, final Object self, final Object... arguments) throws Throwable {
         final MethodHandle mh      = getGenericInvoker(fn.getScope());
         final Object       selfObj = convertThisObject(self);
         final Object[]     args    = arguments == null ? ScriptRuntime.EMPTY_ARRAY : arguments;
         DebuggerSupport.notifyInvoke(mh);
         if (isVarArg(mh)) {
             if (needsCallee(mh)) {
                 return mh.invokeExact(fn, selfObj, args);
             }
             return mh.invokeExact(selfObj, args);
         }
         final int paramCount = mh.type().parameterCount();
         if (needsCallee(mh)) {
             switch (paramCount) {
             case 2:
                 return mh.invokeExact(fn, selfObj);
             case 3:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0));
             case 4:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0), getArg(args, 1));
             case 5:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2));
             case 6:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3));
             case 7:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4));
             case 8:
                 return mh.invokeExact(fn, selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4), getArg(args, 5));
             default:
                 return mh.invokeWithArguments(withArguments(fn, selfObj, paramCount, args));
             }
         }
         switch (paramCount) {
         case 1:
             return mh.invokeExact(selfObj);
         case 2:
             return mh.invokeExact(selfObj, getArg(args, 0));
         case 3:
             return mh.invokeExact(selfObj, getArg(args, 0), getArg(args, 1));
         case 4:
             return mh.invokeExact(selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2));
         case 5:
             return mh.invokeExact(selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3));
         case 6:
             return mh.invokeExact(selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4));
         case 7:
             return mh.invokeExact(selfObj, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4), getArg(args, 5));
         default:
             return mh.invokeWithArguments(withArguments(null, selfObj, paramCount, args));
         }
     }
     Object construct(final ScriptFunction fn, final Object... arguments) throws Throwable {
         final MethodHandle mh   = getGenericConstructor(fn.getScope());
         final Object[]     args = arguments == null ? ScriptRuntime.EMPTY_ARRAY : arguments;
         DebuggerSupport.notifyInvoke(mh);
         if (isVarArg(mh)) {
             if (needsCallee(mh)) {
                 return mh.invokeExact(fn, args);
             }
             return mh.invokeExact(args);
         }
         final int paramCount = mh.type().parameterCount();
         if (needsCallee(mh)) {
             switch (paramCount) {
             case 1:
                 return mh.invokeExact(fn);
             case 2:
                 return mh.invokeExact(fn, getArg(args, 0));
             case 3:
                 return mh.invokeExact(fn, getArg(args, 0), getArg(args, 1));
             case 4:
                 return mh.invokeExact(fn, getArg(args, 0), getArg(args, 1), getArg(args, 2));
             case 5:
                 return mh.invokeExact(fn, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3));
             case 6:
                 return mh.invokeExact(fn, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4));
             case 7:
                 return mh.invokeExact(fn, getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4), getArg(args, 5));
             default:
                 return mh.invokeWithArguments(withArguments(fn, paramCount, args));
             }
         }
         switch (paramCount) {
         case 0:
             return mh.invokeExact();
         case 1:
             return mh.invokeExact(getArg(args, 0));
         case 2:
             return mh.invokeExact(getArg(args, 0), getArg(args, 1));
         case 3:
             return mh.invokeExact(getArg(args, 0), getArg(args, 1), getArg(args, 2));
         case 4:
             return mh.invokeExact(getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3));
         case 5:
             return mh.invokeExact(getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4));
         case 6:
             return mh.invokeExact(getArg(args, 0), getArg(args, 1), getArg(args, 2), getArg(args, 3), getArg(args, 4), getArg(args, 5));
         default:
             return mh.invokeWithArguments(withArguments(null, paramCount, args));
         }
     }
     private static Object getArg(final Object[] args, final int i) {
         return i < args.length ? args[i] : UNDEFINED;
     }
     private static Object[] withArguments(final ScriptFunction fn, final int argCount, final Object[] args) {
         final Object[] finalArgs = new Object[argCount];
         int nextArg = 0;
         if (fn != null) {
             //needs callee
             finalArgs[nextArg++] = fn;
         }
         // Don't add more args that there is argCount in the handle (including self and callee).
         for (int i = 0; i < args.length && nextArg < argCount;) {
             finalArgs[nextArg++] = args[i++];
         }
         // If we have fewer args than argCount, pad with undefined.
         while (nextArg < argCount) {
             finalArgs[nextArg++] = UNDEFINED;
         }
         return finalArgs;
     }
     private static Object[] withArguments(final ScriptFunction fn, final Object self, final int argCount, final Object[] args) {
         final Object[] finalArgs = new Object[argCount];
         int nextArg = 0;
         if (fn != null) {
             //needs callee
             finalArgs[nextArg++] = fn;
         }
         finalArgs[nextArg++] = self;
         // Don't add more args that there is argCount in the handle (including self and callee).
         for (int i = 0; i < args.length && nextArg < argCount;) {
             finalArgs[nextArg++] = args[i++];
         }
         // If we have fewer args than argCount, pad with undefined.
         while (nextArg < argCount) {
             finalArgs[nextArg++] = UNDEFINED;
         }
         return finalArgs;
     }
     /**
      * Takes a variable-arity method and binds a variable number of arguments in it. The returned method will filter the
      * vararg array and pass a different array that prepends the bound arguments in front of the arguments passed on
      * invocation
      *
      * @param mh the handle
      * @param args the bound arguments
      *
      * @return the bound method handle
      */
     private static MethodHandle varArgBinder(final MethodHandle mh, final Object[] args) {
         assert args != null;
         assert args.length > 0;
         return MH.filterArguments(mh, mh.type().parameterCount() - 1, MH.bindTo(BIND_VAR_ARGS, args));
     }
     /**
      * Heuristic to figure out if the method handle has a callee argument. If it's type is
      * {@code (ScriptFunction, ...)}, then we'll assume it has a callee argument. We need this as
      * the constructor above is not passed this information, and can't just blindly assume it's false
      * (notably, it's being invoked for creation of new scripts, and scripts have scopes, therefore
      * they also always receive a callee).
      *
      * @param mh the examined method handle
      *
      * @return true if the method handle expects a callee, false otherwise
      */
     protected static boolean needsCallee(final MethodHandle mh) {
         return needsCallee(mh.type());
     }
     static boolean needsCallee(final MethodType type) {
         final int length = type.parameterCount();
         if (length == 0) {
             return false;
         }
         final Class<?> param0 = type.parameterType(0);
         return param0 == ScriptFunction.class || param0 == boolean.class && length > 1 && type.parameterType(1) == ScriptFunction.class;
     }
     /**
      * Check if a javascript function methodhandle is a vararg handle
      *
      * @param mh method handle to check
      *
      * @return true if vararg
      */
     protected static boolean isVarArg(final MethodHandle mh) {
         return isVarArg(mh.type());
     }
     static boolean isVarArg(final MethodType type) {
         return type.parameterType(type.parameterCount() - 1).isArray();
     }
     /**
      * Is this ScriptFunction declared in a dynamic context
      * @return true if in dynamic context, false if not or irrelevant
      */
     public boolean inDynamicContext() {
         return false;
     }
     @SuppressWarnings("unused")
     private static Object[] bindVarArgs(final Object[] array1, final Object[] array2) {
         if (array2 == null) {
             // Must clone it, as we can't allow the receiving method to alter the array
             return array1.clone();
         }
         final int l2 = array2.length;
         if (l2 == 0) {
             return array1.clone();
         }
         final int l1 = array1.length;
         final Object[] concat = new Object[l1 + l2];
         System.arraycopy(array1, 0, concat, 0, l1);
         System.arraycopy(array2, 0, concat, l1, l2);
         return concat;
     }
     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
         return MH.findStatic(MethodHandles.lookup(), ScriptFunctionData.class, name, MH.type(rtype, types));
     }
     /**
      * This class is used to hold the generic invoker and generic constructor pair. It is structured in this way since
      * most functions will never use them, so this way ScriptFunctionData only pays storage cost for one null reference
      * to the GenericInvokers object, instead of two null references for the two method handles.
      */
     private static final class GenericInvokers {
         volatile MethodHandle invoker;
         volatile MethodHandle constructor;
     }
     private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         code = new LinkedList<>();
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/internal/runtime/ScriptFunctionData.java@61ffdd1b89f2 (annotated)

src/jdk/nashorn/internal/runtime/ScriptFunctionData.java