/*

 * Copyright (c) 2008, 2011, 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.

 */

import sun.dyn.util.VerifyType;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import sun.dyn.empty.Empty;

import sun.dyn.util.ValueConversions;

import sun.dyn.util.Wrapper;

import sun.misc.Unsafe;

/**

 * @author jrose

 */

    /// Factory methods to create method handles:

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

        // Trigger preceding sequence.

    }

    /** 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 IllegalAccessException if the given method cannot be accessed by the lookup class

     */

                            boolean doDispatch, Class<?> lookupClass) throws IllegalAccessException {

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

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

        if (!method.isVarargs())

            return mh;

        else

            return mh.asVarargsCollector(mtype.parameterType(mtype.parameterCount()-1));

    }

        MethodType rawConType = rawConstructor.type();

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

        MethodHandle allocator

        assert(allocator.type()

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

        return allocator;

    }

    static final class AllocateObject<C> extends BoundMethodHandle {

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

            this.allocateClass = allocateClass;

            this.rawConstructor = rawConstructor;

        }

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

                if (gcon == null)  return null;

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

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

            } else {

                MethodHandle invoke = VARARGS_INVOKE;

                MethodType conType = CON_TYPES[nargs];

                if (gcon == null)  return null;

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

            }

        }

        @Override

        public String toString() {

            return addTypeString(allocateClass.getSimpleName(), this);

        }

        @SuppressWarnings("unchecked")

        private C allocate() throws InstantiationException {

            return (C) unsafe.allocateInstance(allocateClass);

        }

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

            C obj = allocate();

            rawConstructor.invokeExact((Object)obj, av);

            return obj;

        }

        private C invoke_L0() throws Throwable {

            C obj = allocate();

            rawConstructor.invokeExact((Object)obj);

            return obj;

        }

        private C invoke_L1(Object a0) throws Throwable {

            C obj = allocate();

            rawConstructor.invokeExact((Object)obj, a0);

            return obj;

        }

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

            C obj = allocate();

            rawConstructor.invokeExact((Object)obj, a0, a1);

            return obj;

        }

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

            C obj = allocate();

            rawConstructor.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.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.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.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.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.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 (ReflectiveOperationException 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 (ReflectiveOperationException ex) {

                throw uncaughtException(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);

        }

    }

                             Class<?> lookupClass) {

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

        return mh;

    }

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

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

        final Object base;  // for static refs only

        final long offset;

        final String name;

            this.name = field.getName();

            this.base = staticBase(field);

        }

        public String toString() { return addTypeString(name, this); }

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

                throw uncaughtException(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);

            } catch (ReflectiveOperationException ex) {

                throw uncaughtException(ex);

            }

            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]; }

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

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

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

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

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

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

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

        static <V> V getElementL(Class<V[]> aclass, V[] a, int i) { return aclass.cast(a)[i]; }

        static <V> void setElementL(Class<V[]> aclass, V[] a, int i, V x) { aclass.cast(a)[i] = x; }

        static String aname(Class<?> aclass, boolean isSetter) {

            Class<?> vclass = aclass.getComponentType();

            if (vclass == null)  throw new IllegalArgumentException();

            return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(vclass);

        }

        static MethodType atype(Class<?> aclass, boolean isSetter) {

            Class<?> vclass = aclass.getComponentType();

            if (!isSetter)

                return MethodType.methodType(vclass, aclass, int.class);

            else

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

        }

        static MethodHandle ahandle(Class<?> aclass, boolean isSetter) {

            Class<?> vclass = aclass.getComponentType();

            String name = FieldAccessor.aname(aclass, isSetter);

            Class<?> caclass = null;

            if (!vclass.isPrimitive() && vclass != Object.class) {

                caclass = aclass;

                aclass = Object[].class;

                vclass = Object.class;

            }

            MethodType type = FieldAccessor.atype(aclass, isSetter);

            if (caclass != null)

                type = type.insertParameterTypes(0, Class.class);

            MethodHandle mh;

            try {

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

            } catch (ReflectiveOperationException ex) {

                throw uncaughtException(ex);

            }

            if (caclass != null) {

                MethodType strongType = FieldAccessor.atype(caclass, isSetter);

                mh = MethodHandles.insertArguments(mh, 0, caclass);

                mh = MethodHandles.convertArguments(mh, strongType);

            }

            return mh;

        }

    }

    /** Bind a predetermined first argument to the given direct method handle.

     * Callable only from MethodHandles.

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

     * @param target Any direct method handle.

     * @param receiver Receiver (or first static method argument) to pre-bind.

     * @return a BoundMethodHandle for the given DirectMethodHandle, or null if it does not exist

     */

        if (target instanceof AdapterMethodHandle &&

            ((AdapterMethodHandle)target).conversionOp() == MethodHandleNatives.Constants.OP_RETYPE_ONLY

            ) {

            Object info = MethodHandleNatives.getTargetInfo(target);

            if (info instanceof DirectMethodHandle) {

                DirectMethodHandle dmh = (DirectMethodHandle) info;

                if (receiver == null ||

                    dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {

                    MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);

                    MethodType newType = target.type().dropParameterTypes(0, 1);

                }

            }

        }

        if (target instanceof DirectMethodHandle)

            return new BoundMethodHandle((DirectMethodHandle)target, receiver, 0);

        return null;   // let caller try something else

    }

    /** Bind a predetermined argument to the given arbitrary method handle.

     * Callable only from MethodHandles.

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

     * @param target Any method handle.

     * @param receiver Argument (which can be a boxed primitive) to pre-bind.

     * @return a suitable BoundMethodHandle

     */

        return new BoundMethodHandle(target, receiver, argnum);

    }

                                                MethodType newType,

                                                MethodType oldType,

                                                int[] permutationOrNull) {

        assert(oldType.parameterCount() == target.type().parameterCount());

        if (permutationOrNull != null) {