/*
* 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.codegen;
import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_OPTIMISTIC;
import java.util.Arrays;
import java.util.EnumSet;
import jdk.nashorn.internal.codegen.types.Type;
import jdk.nashorn.internal.ir.Symbol;
import jdk.nashorn.internal.runtime.ScriptObject;
/**
* A scope call or get operation that can be shared by several callsites. This generates a static
* method that wraps the invokedynamic instructions to get or call scope variables.
* The rationale for this is that initial linking of invokedynamic callsites is expensive,
* so by sharing them we can reduce startup overhead and allow very large scripts to run that otherwise wouldn't.
*
* <p>Static methods generated by this class expect two parameters in addition to the parameters of the
* function call: The current scope object and the depth of the target scope relative to the scope argument
* for when this is known at compile-time (fast-scope access).</p>
*
* <p>The second argument may be -1 for non-fast-scope symbols, in which case the scope chain is checked
* for each call. This may cause callsite invalidation when the shared method is used from different
* scopes, but such sharing of non-fast scope calls may still be necessary for very large scripts.</p>
*
* <p>Scope calls must not be shared between normal callsites and callsites contained in a <tt>with</tt>
* statement as this condition is not handled by current guards and will cause a runtime error.</p>
*/
class SharedScopeCall {
/** Threshold for using shared scope calls with fast scope access. */
public static final int FAST_SCOPE_CALL_THRESHOLD = 4;
/** Threshold for using shared scope calls with slow scope access. */
public static final int SLOW_SCOPE_CALL_THRESHOLD = 500;
/** Threshold for using shared scope gets with fast scope access. */
public static final int FAST_SCOPE_GET_THRESHOLD = 200;
final Type valueType;
final Symbol symbol;
final Type returnType;
final Type[] paramTypes;
final int flags;
final boolean isCall;
private CompileUnit compileUnit;
private String methodName;
private String staticSignature;
/**
* Constructor.
*
* @param symbol the symbol
* @param valueType the type of the value
* @param returnType the return type
* @param paramTypes the function parameter types
* @param flags the callsite flags
*/
SharedScopeCall(final Symbol symbol, final Type valueType, final Type returnType, final Type[] paramTypes, final int flags) {
this.symbol = symbol;
this.valueType = valueType;
this.returnType = returnType;
this.paramTypes = paramTypes;
assert (flags & CALLSITE_OPTIMISTIC) == 0;
this.flags = flags;
// If paramTypes is not null this is a call, otherwise it's just a get.
this.isCall = paramTypes != null;
}
@Override
public int hashCode() {
return symbol.hashCode() ^ returnType.hashCode() ^ Arrays.hashCode(paramTypes) ^ flags;
}
@Override
public boolean equals(final Object obj) {
if (obj instanceof SharedScopeCall) {
final SharedScopeCall c = (SharedScopeCall) obj;
return symbol.equals(c.symbol)
&& flags == c.flags
&& returnType.equals(c.returnType)
&& Arrays.equals(paramTypes, c.paramTypes);
}
return false;
}
/**
* Set the compile unit and method name.
* @param compileUnit the compile unit
* @param methodName the method name
*/
protected void setClassAndName(final CompileUnit compileUnit, final String methodName) {
this.compileUnit = compileUnit;
this.methodName = methodName;
}
/**
* Generate the invoke instruction for this shared scope call.
* @param method the method emitter
* @return the method emitter
*/
public MethodEmitter generateInvoke(final MethodEmitter method) {
return method.invokestatic(compileUnit.getUnitClassName(), methodName, getStaticSignature());
}
/**
* Generate the method that implements the scope get or call.
*/
protected void generateScopeCall() {
final ClassEmitter classEmitter = compileUnit.getClassEmitter();
final EnumSet<ClassEmitter.Flag> methodFlags = EnumSet.of(ClassEmitter.Flag.STATIC);
// This method expects two fixed parameters in addition to any parameters that may be
// passed on to the function: A ScriptObject representing the caller's current scope object,
// and an int specifying the distance to the target scope containing the symbol we want to
// access, or -1 if this is not known at compile time (e.g. because of a "with" or "eval").
final MethodEmitter method = classEmitter.method(methodFlags, methodName, getStaticSignature());
method.begin();
// Load correct scope by calling getProto() on the scope argument as often as specified
// by the second argument.
final Label parentLoopStart = new Label("parent_loop_start");
final Label parentLoopDone = new Label("parent_loop_done");
method.load(Type.OBJECT, 0);
method.label(parentLoopStart);
method.load(Type.INT, 1);
method.iinc(1, -1);
method.ifle(parentLoopDone);
method.invoke(ScriptObject.GET_PROTO);
method._goto(parentLoopStart);
method.label(parentLoopDone);
assert !isCall || valueType.isObject(); // Callables are always objects
// If flags are optimistic, but we're doing a call, remove optimistic flags from the getter, as they obviously
// only apply to the call.
method.dynamicGet(valueType, symbol.getName(), isCall ? CodeGenerator.nonOptimisticFlags(flags) : flags, isCall, false);
// If this is a get we're done, otherwise call the value as function.
if (isCall) {
method.convert(Type.OBJECT);
// ScriptFunction will see CALLSITE_SCOPE and will bind scope accordingly.
method.loadUndefined(Type.OBJECT);
int slot = 2;
for (final Type type : paramTypes) {
method.load(type, slot);
slot += type.getSlots();
}
// Shared scope calls disabled in optimistic world. TODO is this right?
method.dynamicCall(returnType, 2 + paramTypes.length, flags, symbol.getName());
}
method._return(returnType);
method.end();
}
private String getStaticSignature() {
if (staticSignature == null) {
if (paramTypes == null) {
staticSignature = Type.getMethodDescriptor(returnType, Type.typeFor(ScriptObject.class), Type.INT);
} else {
final Type[] params = new Type[paramTypes.length + 2];
params[0] = Type.typeFor(ScriptObject.class);
params[1] = Type.INT;
System.arraycopy(paramTypes, 0, params, 2, paramTypes.length);
staticSignature = Type.getMethodDescriptor(returnType, params);
}
}
return staticSignature;
}
@Override
public String toString() {
return methodName + " " + staticSignature;
}
}