/*

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.dyn;

import java.dyn.JavaMethodHandle;

import java.dyn.MethodHandle;

import java.dyn.MethodHandles;

import java.dyn.MethodHandles.Lookup;

import java.dyn.MethodType;

import java.util.logging.Level;

import java.util.logging.Logger;

import sun.dyn.util.VerifyType;

import java.dyn.NoAccessException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import sun.dyn.empty.Empty;

import sun.dyn.util.ValueConversions;

import sun.dyn.util.Wrapper;

import sun.misc.Unsafe;

import static sun.dyn.MemberName.newIllegalArgumentException;

import static sun.dyn.MemberName.newNoAccessException;

/**

 * Base class for method handles, containing JVM-specific fields and logic.

 * TO DO:  It should not be a base class.

 * @author jrose

 */

public abstract class MethodHandleImpl {

    // Fields which really belong in MethodHandle:

    private byte       vmentry;    // adapter stub or method entry point

    //private int      vmslots;    // optionally, hoist type.form.vmslots

    protected Object   vmtarget;   // VM-specific, class-specific target value

    //MethodType       type;       // defined in MethodHandle

    // TO DO:  vmtarget should be invisible to Java, since the JVM puts internal

    // managed pointers into it.  Making it visible exposes it to debuggers,

    // which can cause errors when they treat the pointer as an Object.

    // These two dummy fields are present to force 'I' and 'J' signatures

    // into this class's constant pool, so they can be transferred

    // to vmentry when this class is loaded.

    static final int  INT_FIELD = 0;

    static final long LONG_FIELD = 0;

    /** Access methods for the internals of MethodHandle, supplied to

     *  MethodHandleImpl as a trusted agent.

     */

    static public interface MethodHandleFriend {

        void initType(MethodHandle mh, MethodType type);

    }

    public static void setMethodHandleFriend(Access token, MethodHandleFriend am) {

        Access.check(token);

        if (METHOD_HANDLE_FRIEND != null)

            throw new InternalError();  // just once

        METHOD_HANDLE_FRIEND = am;

    }

    static private MethodHandleFriend METHOD_HANDLE_FRIEND;

    // NOT public

    static void initType(MethodHandle mh, MethodType type) {

        METHOD_HANDLE_FRIEND.initType(mh, type);

    }

    // type is defined in java.dyn.MethodHandle, which is platform-independent

    // vmentry (a void* field) is used *only* by by the JVM.

    // The JVM adjusts its type to int or long depending on system wordsize.

    // Since it is statically typed as neither int nor long, it is impossible

    // to use this field from Java bytecode.  (Please don't try to, either.)

    // The vmentry is an assembly-language stub which is jumped to

    // immediately after the method type is verified.

    // For a direct MH, this stub loads the vmtarget's entry point

    // and jumps to it.

    /**

     * VM-based method handles must have a security token.

     * This security token can only be obtained by trusted code.

     * Do not create method handles directly; use factory methods.

     */

    public MethodHandleImpl(Access token) {

        Access.check(token);

    }

    /** Initialize the method type form to participate in JVM calls.

     *  This is done once for each erased type.

     */

    public static void init(Access token, MethodType self) {

        Access.check(token);

        if (MethodHandleNatives.JVM_SUPPORT)

            MethodHandleNatives.init(self);

    }

    /// Factory methods to create method handles:

    private static final MemberName.Factory LOOKUP = MemberName.Factory.INSTANCE;

    static private Lookup IMPL_LOOKUP_INIT;

    public static void initLookup(Access token, Lookup lookup) {

        Access.check(token);

            throw new InternalError();

        IMPL_LOOKUP_INIT = lookup;

    }

    public static Lookup getLookup(Access token) {

        Access.check(token);

        return IMPL_LOOKUP;

    }

    static {

        // Force initialization of Lookup, so it calls us back as initLookup:

        MethodHandles.publicLookup();

        if (IMPL_LOOKUP_INIT == null)

            throw new InternalError();

    }

    public static void initStatics() {

        // Trigger preceding sequence.

    }

    /** Shared secret with MethodHandles.Lookup, a copy of Lookup.IMPL_LOOKUP. */

    static final Lookup IMPL_LOOKUP = IMPL_LOOKUP_INIT;

    /** Look up a given method.

     * Callable only from java.dyn and related packages.

     * <p>

     * The resulting method handle type will be of the given type,

     * with a receiver type {@code rcvc} prepended if the member is not static.

     * <p>

     * Access checks are made as of the given lookup class.

     * In particular, if the method is protected and {@code defc} is in a

     * different package from the lookup class, then {@code rcvc} must be

     * the lookup class or a subclass.

     * @param token Proof that the lookup class has access to this package.

     * @param member Resolved method or constructor to call.

     * @param name Name of the desired method.

     * @param rcvc Receiver type of desired non-static method (else null)

     * @param doDispatch whether the method handle will test the receiver type

     * @param lookupClass access-check relative to this class

     * @return a direct handle to the matching method

     * @throws NoAccessException if the given method cannot be accessed by the lookup class

     */

    public static

    MethodHandle findMethod(Access token, MemberName method,

            boolean doDispatch, Class<?> lookupClass) {

        Access.check(token);  // only trusted calls

        MethodType mtype = method.getMethodType();

        MethodType rtype = mtype;

            // adjust the advertised receiver type to be exactly the one requested

            // (in the case of invokespecial, this will be the calling class)

            Class<?> recvType = method.getDeclaringClass();

            mtype = mtype.insertParameterTypes(0, recvType);

            // FIXME: JVM has trouble building MH.invoke sites for

            // classes off the boot class path

            rtype = mtype;

                rtype = rtype.changeParameterType(0, Object.class);

        }

        DirectMethodHandle mh = new DirectMethodHandle(mtype, method, doDispatch, lookupClass);

        if (!mh.isValid())

            throw newNoAccessException(method, lookupClass);

    }

    public static

    MethodHandle accessField(Access token,

                             MemberName member, boolean isSetter,

                             Class<?> lookupClass) {

        Access.check(token);

        // Use sun. misc.Unsafe to dig up the dirt on the field.

        MethodHandle mh = new FieldAccessor(token, member, isSetter);

        return mh;

    }

    public static

    MethodHandle accessArrayElement(Access token,

                                    Class<?> arrayClass, boolean isSetter) {

        Access.check(token);

        if (!arrayClass.isArray())

            throw newIllegalArgumentException("not an array: "+arrayClass);

        Class<?> elemClass = arrayClass.getComponentType();

        MethodHandle[] mhs = FieldAccessor.ARRAY_CACHE.get(elemClass);

        if (mhs == null) {

            if (!FieldAccessor.doCache(elemClass))

                return FieldAccessor.ahandle(arrayClass, isSetter);

            mhs = new MethodHandle[] {

                FieldAccessor.ahandle(arrayClass, false),

                FieldAccessor.ahandle(arrayClass, true)

            };

            if (mhs[0].type().parameterType(0) == Class.class) {

                mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);

                mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);

            }

            synchronized (FieldAccessor.ARRAY_CACHE) {}  // memory barrier

            FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);

        }

        return mhs[isSetter ? 1 : 0];

    }

    static final class FieldAccessor<C,V> extends JavaMethodHandle {

        private static final Unsafe unsafe = Unsafe.getUnsafe();

        final Object base;  // for static refs only

        final long offset;

        final String name;

        public FieldAccessor(Access token, MemberName field, boolean isSetter) {

            super(fhandle(field.getDeclaringClass(), field.getFieldType(), isSetter, field.isStatic()));

            this.offset = (long) field.getVMIndex(token);

            this.name = field.getName();

            this.base = staticBase(field);

        }

        public String toString() { return name; }

        int getFieldI(C obj) { return unsafe.getInt(obj, offset); }

        void setFieldI(C obj, int x) { unsafe.putInt(obj, offset, x); }

        long getFieldJ(C obj) { return unsafe.getLong(obj, offset); }

        void setFieldJ(C obj, long x) { unsafe.putLong(obj, offset, x); }

        float getFieldF(C obj) { return unsafe.getFloat(obj, offset); }

        void setFieldF(C obj, float x) { unsafe.putFloat(obj, offset, x); }

        double getFieldD(C obj) { return unsafe.getDouble(obj, offset); }

        void setFieldD(C obj, double x) { unsafe.putDouble(obj, offset, x); }

        boolean getFieldZ(C obj) { return unsafe.getBoolean(obj, offset); }

        void setFieldZ(C obj, boolean x) { unsafe.putBoolean(obj, offset, x); }

        byte getFieldB(C obj) { return unsafe.getByte(obj, offset); }

        void setFieldB(C obj, byte x) { unsafe.putByte(obj, offset, x); }

        short getFieldS(C obj) { return unsafe.getShort(obj, offset); }

        void setFieldS(C obj, short x) { unsafe.putShort(obj, offset, x); }

        char getFieldC(C obj) { return unsafe.getChar(obj, offset); }

        void setFieldC(C obj, char x) { unsafe.putChar(obj, offset, x); }

        @SuppressWarnings("unchecked")

        V getFieldL(C obj) { return (V) unsafe.getObject(obj, offset); }

        @SuppressWarnings("unchecked")

        void setFieldL(C obj, V x) { unsafe.putObject(obj, offset, x); }

        // cast (V) is OK here, since we wrap convertArguments around the MH.

        static Object staticBase(MemberName field) {

            if (!field.isStatic())  return null;

            Class c = field.getDeclaringClass();

            java.lang.reflect.Field f;

            try {

                // FIXME:  Should not have to create 'f' to get this value.

                f = c.getDeclaredField(field.getName());

                return unsafe.staticFieldBase(f);

            } catch (Exception ee) {

                Error e = new InternalError();

                e.initCause(ee);

                throw e;

            }

        }

        int getStaticI() { return unsafe.getInt(base, offset); }

        void setStaticI(int x) { unsafe.putInt(base, offset, x); }

        long getStaticJ() { return unsafe.getLong(base, offset); }

        void setStaticJ(long x) { unsafe.putLong(base, offset, x); }

        float getStaticF() { return unsafe.getFloat(base, offset); }

        void setStaticF(float x) { unsafe.putFloat(base, offset, x); }

        double getStaticD() { return unsafe.getDouble(base, offset); }

        void setStaticD(double x) { unsafe.putDouble(base, offset, x); }

        boolean getStaticZ() { return unsafe.getBoolean(base, offset); }

        void setStaticZ(boolean x) { unsafe.putBoolean(base, offset, x); }

        byte getStaticB() { return unsafe.getByte(base, offset); }

        void setStaticB(byte x) { unsafe.putByte(base, offset, x); }

        short getStaticS() { return unsafe.getShort(base, offset); }

        void setStaticS(short x) { unsafe.putShort(base, offset, x); }

        char getStaticC() { return unsafe.getChar(base, offset); }

        void setStaticC(char x) { unsafe.putChar(base, offset, x); }

        V getStaticL() { return (V) unsafe.getObject(base, offset); }

        void setStaticL(V x) { unsafe.putObject(base, offset, x); }

        static String fname(Class<?> vclass, boolean isSetter, boolean isStatic) {

            String stem;

            if (!isStatic)

                stem = (!isSetter ? "getField" : "setField");

            else

                stem = (!isSetter ? "getStatic" : "setStatic");

            return stem + Wrapper.basicTypeChar(vclass);

        }

        static MethodType ftype(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {

            MethodType type;

            if (!isStatic) {

                if (!isSetter)

                    return MethodType.methodType(vclass, cclass);

                else

                    return MethodType.methodType(void.class, cclass, vclass);

            } else {

                if (!isSetter)

                    return MethodType.methodType(vclass);

                else

                    return MethodType.methodType(void.class, vclass);

            }

        }

        static MethodHandle fhandle(Class<?> cclass, Class<?> vclass, boolean isSetter, boolean isStatic) {

            String name = FieldAccessor.fname(vclass, isSetter, isStatic);

            if (cclass.isPrimitive())  throw newIllegalArgumentException("primitive "+cclass);

            Class<?> ecclass = Object.class;  //erase this type

            Class<?> evclass = vclass;

            if (!evclass.isPrimitive())  evclass = Object.class;

            MethodType type = FieldAccessor.ftype(ecclass, evclass, isSetter, isStatic);

            MethodHandle mh;

            try {

                mh = IMPL_LOOKUP.findVirtual(FieldAccessor.class, name, type);

            } catch (NoAccessException ee) {

                Error e = new InternalError("name,type="+name+type);

                e.initCause(ee);

                throw e;

            }

            if (evclass != vclass || (!isStatic && ecclass != cclass)) {

                MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);

                strongType = strongType.insertParameterTypes(0, FieldAccessor.class);

                mh = MethodHandles.convertArguments(mh, strongType);

            }

            return mh;

        }

        /// Support for array element access

        static final HashMap<Class<?>, MethodHandle[]> ARRAY_CACHE =

                new HashMap<Class<?>, MethodHandle[]>();