37  * A scope call or get operation that can be shared by several callsites. This generates a static

    40  * A scope call or get operation that can be shared by several call sites. This generates a static

    39  * The rationale for this is that initial linking of invokedynamic callsites is expensive,

    42  * The reason for this is to reduce memory footprint and initial linking overhead of huge scripts.

    40  * so by sharing them we can reduce startup overhead and allow very large scripts to run that otherwise wouldn't.

    43  *

    41  *

    44  * <p>Static methods generated by this class expect three parameters in addition to the parameters of the

    42  * <p>Static methods generated by this class expect two parameters in addition to the parameters of the

    45  * function call: The current scope object, the depth of the target scope relative to the scope argument,

    43  * function call: The current scope object and the depth of the target scope relative to the scope argument

    46  * and the program point in case the target operation is optimistic.</p>

    44  * for when this is known at compile-time (fast-scope access).</p>

    47  *

    45  *

    48  * <p>Optimistic operations are called with program point <code>0</code>. If an <code>UnwarrentedOptimismException</code>

    46  * <p>The second argument may be -1 for non-fast-scope symbols, in which case the scope chain is checked

    49  * is thrown, it is caught by the shared call method and rethrown with the program point of the invoking call site.</p>

    47  * for each call. This may cause callsite invalidation when the shared method is used from different

    50  *

    48  * scopes, but such sharing of non-fast scope calls may still be necessary for very large scripts.</p>

    51  * <p>Shared scope calls are not used if the scope contains a <code>with</code> statement or a call to

    49  *

    52  * <code>eval</code>.</p>

    50  * <p>Scope calls must not be shared between normal callsites and callsites contained in a <tt>with</tt>

    51  * statement as this condition is not handled by current guards and will cause a runtime error.</p>

    55     /** Threshold for using shared scope calls with fast scope access. */

    56     /**

    56     public static final int FAST_SCOPE_CALL_THRESHOLD = 4;

    57      * Threshold for using shared scope function calls.

    57     /** Threshold for using shared scope calls with slow scope access. */

    58      */

    58     public static final int SLOW_SCOPE_CALL_THRESHOLD = 500;

    59     public static final int SHARED_CALL_THRESHOLD =

    59     /** Threshold for using shared scope gets with fast scope access. */

    60             Options.getIntProperty("nashorn.shared.scope.call.threshold", 5);

    60     public static final int FAST_SCOPE_GET_THRESHOLD  = 200;

    61     /**

    61 

    62      * Threshold for using shared scope variable getter. This is higher than for calls as lower values

    62     final Type valueType;

    63      * degrade performance on many scripts.

    63     final Symbol symbol;

    64      */

    64     final Type returnType;

    65     public static final int SHARED_GET_THRESHOLD  =

    65     final Type[] paramTypes;

    66             Options.getIntProperty("nashorn.shared.scope.get.threshold", 100);

    66     final int flags;

    67 

    67     final boolean isCall;

    68     private static final CompilerConstants.Call REPLACE_PROGRAM_POINT = virtualCallNoLookup(

    69                     UnwarrantedOptimismException.class, "replaceProgramPoint",

    70                     UnwarrantedOptimismException.class, int.class);

    71 

    72     /** Number of fixed parameters */

    73     private static final int FIXED_PARAM_COUNT = 3;

    74 

    75     private final Type valueType;

    76     private final Symbol symbol;

    77     private final Type returnType;

    78     private final Type[] paramTypes;

    79     private final int flags;

    80     private final boolean isCall;

    81     private final boolean isOptimistic;

    80      */

    94      * @param isOptimistic whether target call is optimistic and we need to handle UnwarrentedOptimismException

    81     SharedScopeCall(final Symbol symbol, final Type valueType, final Type returnType, final Type[] paramTypes, final int flags) {

    95      */

    96     SharedScopeCall(final Symbol symbol, final Type valueType, final Type returnType, final Type[] paramTypes,

    97                     final int flags, final boolean isOptimistic) {

    88         // If paramTypes is not null this is a call, otherwise it's just a get.

   103         this.isCall = paramTypes != null; // If paramTypes is not null this is a call, otherwise it's just a get.

    89         this.isCall = paramTypes != null;

   104         this.isOptimistic = isOptimistic;

    94         return symbol.hashCode() ^ returnType.hashCode() ^ Arrays.hashCode(paramTypes) ^ flags;

   109         return symbol.hashCode() ^ returnType.hashCode() ^ Arrays.hashCode(paramTypes) ^ flags ^ Boolean.hashCode(isOptimistic);

   104                     && Arrays.equals(paramTypes, c.paramTypes);

   119                     && Arrays.equals(paramTypes, c.paramTypes)

   120                     && isOptimistic == c.isOptimistic;

   122      * @return the method emitter

   138      */

   123      */

   139     public void generateInvoke(final MethodEmitter method) {

   124     public MethodEmitter generateInvoke(final MethodEmitter method) {

   140         method.invokestatic(compileUnit.getUnitClassName(), methodName, getStaticSignature());

   125         return method.invokestatic(compileUnit.getUnitClassName(), methodName, getStaticSignature());

   143         // Load correct scope by calling getProto() on the scope argument as often as specified

   158         // Load correct scope by calling getProto(int) on the scope argument with the supplied depth argument

   144         // by the second argument.

   145         final Label parentLoopStart = new Label("parent_loop_start");

   146         final Label parentLoopDone  = new Label("parent_loop_done");

   150         method.iinc(1, -1);

   161         method.invoke(ScriptObject.GET_PROTO_DEPTH);

   151         method.ifle(parentLoopDone);

   162 

   152         method.invoke(ScriptObject.GET_PROTO);

   163         assert !isCall || valueType.isObject(); // Callables are always loaded as object

   153         method._goto(parentLoopStart);

   164 

   154         method.label(parentLoopDone);

   165         // Labels for catch of UnsupportedOptimismException

   155 

   166         final Label beginTry;

   156         assert !isCall || valueType.isObject(); // Callables are always objects

   167         final Label endTry;

   157         // If flags are optimistic, but we're doing a call, remove optimistic flags from the getter, as they obviously

   168         final Label catchLabel;

   158         // only apply to the call.

   169 

   159         method.dynamicGet(valueType, symbol.getName(), isCall ? CodeGenerator.nonOptimisticFlags(flags) : flags, isCall, false);

   170         if(isOptimistic) {

   171             beginTry = new Label("begin_try");

   172             endTry = new Label("end_try");

   173             catchLabel = new Label("catch_label");

   174             method.label(beginTry);

   175             method._try(beginTry, endTry, catchLabel, UnwarrantedOptimismException.class, false);

   176         } else {

   177             beginTry = endTry = catchLabel = null;

   178         }

   179 

   180         // If this is an optimistic get we set the optimistic flag but don't set the program point,

   181         // which implies a program point of 0. If optimism fails we'll replace it with the actual

   182         // program point which caller supplied as third argument.

   183         final int getFlags = isOptimistic && !isCall ? flags | CALLSITE_OPTIMISTIC : flags;

   184         method.dynamicGet(valueType, symbol.getName(), getFlags, isCall, false);

   166             int slot = 2;

   191             int slot = FIXED_PARAM_COUNT;

   171             // Shared scope calls disabled in optimistic world. TODO is this right?

   196 

   172             method.dynamicCall(returnType, 2 + paramTypes.length, flags, symbol.getName());

   197             // Same as above, set optimistic flag but leave program point as 0.

   198             final int callFlags = isOptimistic ? flags | CALLSITE_OPTIMISTIC : flags;

   199 

   200             method.dynamicCall(returnType, 2 + paramTypes.length, callFlags, symbol.getName());

   201 

   202         }

   203 

   204         if (isOptimistic) {

   205             method.label(endTry);

   182                 staticSignature = Type.getMethodDescriptor(returnType, Type.typeFor(ScriptObject.class), Type.INT);

   224                 staticSignature = Type.getMethodDescriptor(returnType, Type.typeFor(ScriptObject.class), Type.INT, Type.INT);

   184                 final Type[] params = new Type[paramTypes.length + 2];

   226                 final Type[] params = new Type[paramTypes.length + FIXED_PARAM_COUNT];

   187                 System.arraycopy(paramTypes, 0, params, 2, paramTypes.length);

   229                 params[2] = Type.INT;

   230                 System.arraycopy(paramTypes, 0, params, FIXED_PARAM_COUNT, paramTypes.length);