/*

 * Copyright (c) 2008, 2010, 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 sun.dyn;

import java.dyn.MethodHandles.Lookup;

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);

        if (IMPL_LOOKUP_INIT != null)

            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,

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

        MethodType mtype = method.getMethodType();

        if (!method.isStatic()) {

            // 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);

        }

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

        if (!mh.isValid())

            throw newNoAccessException(method, lookupClass);

        assert(mh.type() == mtype);

        return mh;

    }

    public static

    MethodHandle makeAllocator(Access token, MethodHandle rawConstructor) {

        Access.check(token);

        MethodType rawConType = rawConstructor.type();

        // Wrap the raw (unsafe) constructor with the allocation of a suitable object.

        MethodHandle allocator

            = AllocateObject.make(token, rawConType.parameterType(0), rawConstructor);

        assert(allocator.type()

               .equals(rawConType.dropParameterTypes(0, 1).changeReturnType(rawConType.parameterType(0))));

        return allocator;

    }

    static final class AllocateObject<C> extends JavaMethodHandle {

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

        private final Class<C> allocateClass;

        private final MethodHandle rawConstructor;

        private AllocateObject(MethodHandle invoker,

                               Class<C> allocateClass, MethodHandle rawConstructor) {

            super(invoker);

            this.allocateClass = allocateClass;

            this.rawConstructor = rawConstructor;

        }

        static MethodHandle make(Access token,

                                 Class<?> allocateClass, MethodHandle rawConstructor) {

            Access.check(token);

            MethodType rawConType = rawConstructor.type();

            assert(rawConType.parameterType(0) == allocateClass);

            MethodType newType = rawConType.dropParameterTypes(0, 1).changeReturnType(allocateClass);

            int nargs = rawConType.parameterCount() - 1;

            if (nargs < INVOKES.length) {

                MethodHandle invoke = INVOKES[nargs];

                MethodType conType = CON_TYPES[nargs];

                MethodHandle gcon = convertArguments(token, rawConstructor, conType, rawConType, null);

                if (gcon == null)  return null;

                MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);

                assert(galloc.type() == newType.generic());

                return convertArguments(token, galloc, newType, galloc.type(), null);

            } else {

                MethodHandle invoke = VARARGS_INVOKE;

                MethodType conType = CON_TYPES[nargs];

                MethodHandle gcon = spreadArguments(token, rawConstructor, conType, 1);

                if (gcon == null)  return null;

                MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);

                return collectArguments(token, galloc, newType, 1, null);

            }

        }

        @Override

        public String toString() {

            return allocateClass.getSimpleName();

        }

        @SuppressWarnings("unchecked")

        private C allocate() throws InstantiationException {

            return (C) unsafe.allocateInstance(allocateClass);

        }

        private C invoke_V(Object... av) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, av);

            return obj;

        }

        private C invoke_L0() throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj);

            return obj;

        }

        private C invoke_L1(Object a0) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0);

            return obj;

        }

        private C invoke_L2(Object a0, Object a1) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1);

            return obj;

        }

        private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2);

            return obj;

        }

        private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3);

            return obj;

        }

        private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4);

            return obj;

        }

        private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);

            return obj;

        }

        private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);

            return obj;

        }

        private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {

            C obj = allocate();

            rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);

            return obj;

        }

        static MethodHandle[] makeInvokes() {

            ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();

            MethodHandles.Lookup lookup = IMPL_LOOKUP;

            for (;;) {

                int nargs = invokes.size();

                String name = "invoke_L"+nargs;

                MethodHandle invoke = null;

                try {

                    invoke = lookup.findVirtual(AllocateObject.class, name, MethodType.genericMethodType(nargs));

                } catch (NoAccessException ex) {

                }

                if (invoke == null)  break;

                invokes.add(invoke);

            }

            assert(invokes.size() == 9);  // current number of methods

            return invokes.toArray(new MethodHandle[0]);

        };

        static final MethodHandle[] INVOKES = makeInvokes();

        // For testing use this:

        //static final MethodHandle[] INVOKES = Arrays.copyOf(makeInvokes(), 2);

        static final MethodHandle VARARGS_INVOKE;

        static {

            try {

                VARARGS_INVOKE = IMPL_LOOKUP.findVirtual(AllocateObject.class, "invoke_V", MethodType.genericMethodType(0, true));

            } catch (NoAccessException ex) {

            }

        }

        // Corresponding generic constructor types:

        static final MethodType[] CON_TYPES = new MethodType[INVOKES.length];

        static {

            for (int i = 0; i < INVOKES.length; i++)

                CON_TYPES[i] = makeConType(INVOKES[i]);

        }

        static final MethodType VARARGS_CON_TYPE = makeConType(VARARGS_INVOKE);

        static MethodType makeConType(MethodHandle invoke) {

            MethodType invType = invoke.type();

            return invType.changeParameterType(0, Object.class).changeReturnType(void.class);

        }

    }

    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) {

            }

        }

        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);

            }

            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[]>();

        // FIXME: Cache on the classes themselves, not here.

        static boolean doCache(Class<?> elemClass) {

            if (elemClass.isPrimitive())  return true;

            ClassLoader cl = elemClass.getClassLoader();

            return cl == null || cl == ClassLoader.getSystemClassLoader();

        }

        static int getElementI(int[] a, int i) { return a[i]; }

        static void setElementI(int[] a, int i, int x) { a[i] = x; }

        static long getElementJ(long[] a, int i) { return a[i]; }

        static void setElementJ(long[] a, int i, long x) { a[i] = x; }

        static float getElementF(float[] a, int i) { return a[i]; }

        static void setElementF(float[] a, int i, float x) { a[i] = x; }

        static double getElementD(double[] a, int i) { return a[i]; }

        static void setElementD(double[] a, int i, double x) { a[i] = x; }

        static boolean getElementZ(boolean[] a, int i) { return a[i]; }

        static void setElementZ(boolean[] a, int i, boolean x) { a[i] = x; }

        static byte getElementB(byte[] a, int i) { return a[i]; }