/*

 * 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._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;

    }

}