NativeInvokerBytecodeGenerator.cs

Go to the documentation of this file.

/*
 * Copyright (c) 2012, 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.
 */
 
// [IKVM] Based on original from OpenJDK, but heavily modified to directly generate a DynamicMethod,
// instead of Java bytecode.
// Copyright (C) 2015 Jeroen Frijters
 
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
 
using IKVM.Attributes;
 
using java.lang.invoke;
 
#if !FIRST_PASS
using BasicType = global::java.lang.invoke.LambdaForm.BasicType;
using Class = global::java.lang.Class;
using Name = global::java.lang.invoke.LambdaForm.Name;
using Opcodes = jdk.@internal.org.objectweb.asm.Opcodes;
using VerifyType = global::sun.invoke.util.VerifyType;
using Wrapper = global::sun.invoke.util.Wrapper;
#endif
 
namespace IKVM.Runtime.Util.Java.Lang.Invoke
{
 
    sealed class NativeInvokerBytecodeGenerator
    {
 
#if FIRST_PASS
 
        public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType)
        {
            return null;
        }
 
#else
 
        readonly RuntimeContext context;
        readonly java.lang.invoke.LambdaForm lambdaForm;
        readonly java.lang.invoke.MethodType invokerType;
        readonly Type delegateType;
        readonly DynamicMethod dm;
        readonly CodeEmitter ilgen;
        readonly int packedArgPos;
        readonly Type packedArgType;
        readonly CodeEmitterLocal[] locals;
        readonly List<object> constants = new List<object>();
 
        private enum Bailout
        {
            NotBasicType,
            UnsupportedIntrinsic,
            UnsupportedArrayType,
            UnsupportedRefKind,
            UnsupportedConstant,
            NotStaticallyInvocable,
            PreconditionViolated,
        }
 
        private sealed class BailoutException : Exception
        {
 
            internal BailoutException(Bailout reason, object data)
                : base("BAILOUT " + reason + ": " + data)
            {
 
            }
 
        }
 
        NativeInvokerBytecodeGenerator(RuntimeContext context, java.lang.invoke.LambdaForm lambdaForm, global::java.lang.invoke.MethodType invokerType)
        {
            this.context = context ?? throw new ArgumentNullException(nameof(context));
            this.lambdaForm = lambdaForm;
            this.invokerType = invokerType;
 
            if (invokerType != invokerType.basicType())
                throw new BailoutException(Bailout.NotBasicType, invokerType);
 
            this.delegateType = context.MethodHandleUtil.GetMemberWrapperDelegateType(invokerType);
            var mi = context.MethodHandleUtil.GetDelegateInvokeMethod(delegateType);
            var paramTypes = MethodHandleUtil.GetParameterTypes(typeof(object[]), mi);
 
            // HACK the code we generate is not verifiable (known issue: locals aren't typed correctly), so we stick the DynamicMethod into mscorlib (a security critical assembly)
            this.dm = new DynamicMethod(lambdaForm.debugName, mi.ReturnType, paramTypes, typeof(object).Module, true);
            this.ilgen = context.CodeEmitterFactory.Create(this.dm);
            if (invokerType.parameterCount() > MethodHandleUtil.MaxArity)
            {
                this.packedArgType = paramTypes[paramTypes.Length - 1];
                this.packedArgPos = paramTypes.Length - 1;
            }
            else
            {
                this.packedArgPos = Int32.MaxValue;
            }
 
            locals = new CodeEmitterLocal[lambdaForm.names.Length];
            for (int i = lambdaForm._arity(); i < lambdaForm.names.Length; i++)
            {
                Name name = lambdaForm.names[i];
                if (name.index() != i)
                {
                    throw new BailoutException(Bailout.PreconditionViolated, "name.index() != i");
                }
                switch (name.typeChar())
                {
                    case 'L':
                        locals[i] = ilgen.DeclareLocal(context.Types.Object);
                        break;
                    case 'I':
                        locals[i] = ilgen.DeclareLocal(context.Types.Int32);
                        break;
                    case 'J':
                        locals[i] = ilgen.DeclareLocal(context.Types.Int64);
                        break;
                    case 'F':
                        locals[i] = ilgen.DeclareLocal(context.Types.Single);
                        break;
                    case 'D':
                        locals[i] = ilgen.DeclareLocal(context.Types.Double);
                        break;
                    case 'V':
                        break;
                    default:
                        throw new BailoutException(Bailout.PreconditionViolated, "Unsupported typeChar(): " + name.typeChar());
                }
            }
        }
 
        /*
         * Low-level emit helpers.
         */
        private void emitConst(object con)
        {
            if (con == null)
            {
                ilgen.Emit(OpCodes.Ldnull);
            }
            else if (con is string)
            {
                ilgen.Emit(OpCodes.Ldstr, (string)con);
            }
            else if (con is java.lang.Integer)
            {
                ilgen.EmitLdc_I4(((java.lang.Integer)con).intValue());
            }
            else if (con is java.lang.Long)
            {
                ilgen.EmitLdc_I8(((java.lang.Long)con).longValue());
            }
            else if (con is java.lang.Float)
            {
                ilgen.EmitLdc_R4(((java.lang.Float)con).floatValue());
            }
            else if (con is java.lang.Double)
            {
                ilgen.EmitLdc_R8(((java.lang.Double)con).doubleValue());
            }
            else if (con is java.lang.Boolean)
            {
                ilgen.EmitLdc_I4(((java.lang.Boolean)con).booleanValue() ? 1 : 0);
            }
            else
            {
                throw new BailoutException(Bailout.UnsupportedConstant, con);
            }
        }
 
        private void emitIconstInsn(int i)
        {
            ilgen.EmitLdc_I4(i);
        }
 
        /*
         * NOTE: These load/store methods use the localsMap to find the correct index!
         */
        private void emitLoadInsn(BasicType type, int index)
        {
            // [IKVM] we don't need the localsMap (it is used to correct for long/double taking two slots)
            if (locals[index] == null)
            {
                context.MethodHandleUtil.LoadPackedArg(ilgen, index, 1, packedArgPos, packedArgType);
            }
            else
            {
                ilgen.Emit(OpCodes.Ldloc, locals[index]);
            }
        }
 
        private void emitStoreInsn(BasicType type, int index)
        {
            ilgen.Emit(OpCodes.Stloc, locals[index]);
        }
 
        private void emitAstoreInsn(int index)
        {
            emitStoreInsn(BasicType.L_TYPE, index);
        }
 
        private byte arrayTypeCode(Wrapper elementType)
        {
            switch (elementType.name())
            {
                case "BOOLEAN": return Opcodes.T_BOOLEAN;
                case "BYTE": return Opcodes.T_BYTE;
                case "CHAR": return Opcodes.T_CHAR;
                case "SHORT": return Opcodes.T_SHORT;
                case "INT": return Opcodes.T_INT;
                case "LONG": return Opcodes.T_LONG;
                case "FLOAT": return Opcodes.T_FLOAT;
                case "DOUBLE": return Opcodes.T_DOUBLE;
                case "OBJECT": return 0; // in place of Opcodes.T_OBJECT
                default: throw new BailoutException(Bailout.PreconditionViolated, "elemendType = " + elementType);
            }
        }
 
        private OpCode arrayInsnOpcode(byte tcode)
        {
            switch (tcode)
            {
                case Opcodes.T_BOOLEAN:
                case Opcodes.T_BYTE:
                    return OpCodes.Stelem_I1;
                case Opcodes.T_CHAR:
                case Opcodes.T_SHORT:
                    return OpCodes.Stelem_I2;
                case Opcodes.T_INT:
                    return OpCodes.Stelem_I4;
                case Opcodes.T_LONG:
                    return OpCodes.Stelem_I8;
                case Opcodes.T_FLOAT:
                    return OpCodes.Stelem_R4;
                case Opcodes.T_DOUBLE:
                    return OpCodes.Stelem_R8;
                case 0:
                    return OpCodes.Stelem_Ref;
                default:
                    throw new BailoutException(Bailout.PreconditionViolated, "tcode = " + tcode);
            }
        }
 
        private void emitImplicitConversion(BasicType ptype, Class pclass, object arg)
        {
            //assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
            if (pclass == ptype.basicTypeClass() && ptype != BasicType.L_TYPE)
                return;   // nothing to do
            switch (ptype.name())
            {
                case "L_TYPE":
                    if (VerifyType.isNullConversion(context.JavaBase.TypeOfJavaLangObject.ClassObject, pclass, false))
                    {
                        //if (PROFILE_LEVEL > 0)
                        //    emitReferenceCast(Object.class, arg);
                        return;
                    }
                    emitReferenceCast(pclass, arg);
                    return;
                case "I_TYPE":
                    if (!VerifyType.isNullConversion(java.lang.Integer.TYPE, pclass, false))
                        emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
                    return;
            }
            throw new BailoutException(Bailout.PreconditionViolated, "bad implicit conversion: tc=" + ptype + ": " + pclass);
        }
 
        private void assertStaticType(Class cls, Name n)
        {
            // [IKVM] not implemented
        }
 
        void emitReferenceCast(Class cls, object arg)
        {
            // [IKVM] handle the type system hole that is caused by arrays being both derived from cli.System.Array and directly from java.lang.Object
            if (cls != context.JavaBase.TypeOfCliSystemObject.ClassObject)
            {
                RuntimeJavaType.FromClass(cls).EmitCheckcast(ilgen);
            }
        }
 
        sealed class AnonymousClass : RuntimeJavaType
        {
 
            public AnonymousClass(RuntimeContext context) :
                base(context, TypeFlags.Anonymous, Modifiers.Super | Modifiers.Final, "java.lang.invoke.LambdaForm$MH")
            {
 
            }
 
            internal override RuntimeClassLoader ClassLoader => Context.ClassLoaderFactory.GetBootstrapClassLoader();
 
            internal override Type TypeAsTBD
            {
                get { throw new InvalidOperationException(); }
            }
 
            internal override RuntimeJavaType BaseTypeWrapper
            {
                get { return Context.JavaBase.TypeOfJavaLangObject; }
            }
        }
 
        public static global::java.lang.invoke.MemberName generateCustomizedCode(java.lang.invoke.LambdaForm form, java.lang.invoke.MethodType invokerType)
        {
            try
            {
                java.lang.invoke.MemberName memberName = new java.lang.invoke.MemberName();
                memberName._clazz(JVM.Context.GetOrCreateSingleton(() => new AnonymousClass(JVM.Context)).ClassObject);
                memberName._name(form.debugName);
                memberName._type(invokerType);
                memberName._flags(MethodHandleNatives.Constants.MN_IS_METHOD | MethodHandleNatives.Constants.ACC_STATIC | (MethodHandleNatives.Constants.REF_invokeStatic << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT));
                memberName.vmtarget = new NativeInvokerBytecodeGenerator(JVM.Context, form, invokerType).generateCustomizedCodeBytes();
                return memberName;
            }
#if DEBUG
            catch (BailoutException x)
            {
                Console.WriteLine(x.Message);
                Console.WriteLine("generateCustomizedCode: " + form + ", " + invokerType);
            }
#else
        catch (BailoutException)
        {
        }
#endif
            return InvokerBytecodeGenerator.generateCustomizedCode(form, invokerType);
        }
 
        private Delegate generateCustomizedCodeBytes()
        {
            // iterate over the form's names, generating bytecode instructions for each
            // start iterating at the first name following the arguments
            Name onStack = null;
            for (int i = lambdaForm._arity(); i < lambdaForm.names.Length; i++)
            {
                Name name = lambdaForm.names[i];
 
                emitStoreResult(onStack);
                onStack = name;  // unless otherwise modified below
                java.lang.invoke.MethodHandleImpl.Intrinsic intr = name.function.intrinsicName();
                switch (intr.name())
                {
                    case "SELECT_ALTERNATIVE":
                        //assert isSelectAlternative(i);
                        onStack = emitSelectAlternative(name, lambdaForm.names[i + 1]);
                        i++;  // skip MH.invokeBasic of the selectAlternative result
                        continue;
                    case "GUARD_WITH_CATCH":
                        //assert isGuardWithCatch(i);
                        onStack = emitGuardWithCatch(i);
                        i = i + 2; // Jump to the end of GWC idiom
                        continue;
                    case "NEW_ARRAY":
                        Class rtype = name.function.methodType().returnType();
                        if (InvokerBytecodeGenerator.isStaticallyNameable(rtype))
                        {
                            emitNewArray(name);
                            continue;
                        }
                        break;
                    case "ARRAY_LOAD":
                        emitArrayLoad(name);
                        continue;
                    case "IDENTITY":
                        //assert(name.arguments.length == 1);
                        emitPushArguments(name);
                        continue;
                    case "NONE":
                        // no intrinsic associated
                        break;
                    // [IKVM] ARRAY_STORE and ZERO appear to be unused
                    default:
                        throw new BailoutException(Bailout.UnsupportedIntrinsic, "Unknown intrinsic: " + intr);
                }
 
                java.lang.invoke.MemberName member = name.function._member();
                if (isStaticallyInvocable(member))
                {
                    emitStaticInvoke(member, name);
                }
                else
                {
                    emitInvoke(name);
                }
            }
 
            // return statement
            emitReturn(onStack);
 
            ilgen.DoEmit();
            return dm.CreateDelegate(delegateType, constants.ToArray());
        }
 
        void emitArrayLoad(Name name)
        {
            OpCode arrayOpcode = OpCodes.Ldelem_Ref;
            Class elementType = name.function.methodType().parameterType(0).getComponentType();
            emitPushArguments(name);
            if (elementType.isPrimitive())
            {
                Wrapper w = Wrapper.forPrimitiveType(elementType);
                arrayOpcode = arrayLoadOpcode(arrayTypeCode(w));
            }
            ilgen.Emit(arrayOpcode);
        }
 
        void emitInvoke(Name name)
        {
            //assert(!isLinkerMethodInvoke(name));  // should use the static path for these
            if (true)
            {
                // push receiver
                java.lang.invoke.MethodHandle target = name.function._resolvedHandle();
                //assert(target != null) : name.exprString();
                //mv.visitLdcInsn(constantPlaceholder(target));
                EmitConstant(target);
                emitReferenceCast(context.JavaBase.TypeOfJavaLangInvokeMethodHandle.ClassObject, target);
            }
            else
            {
                // load receiver
                //emitAloadInsn(0);
                //emitReferenceCast(MethodHandle.class, null);
                //mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", LF_SIG);
                //mv.visitFieldInsn(Opcodes.GETFIELD, LF, "names", LFN_SIG);
                // TODO more to come
            }
 
            // push arguments
            emitPushArguments(name);
 
            // invocation
            java.lang.invoke.MethodType type = name.function.methodType();
            //mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString(), false);
            EmitInvokeBasic(type.basicType());
        }
 
        bool isStaticallyInvocable(java.lang.invoke.MemberName member)
        {
            if (member == null) return false;
            if (member.isConstructor()) return false;
            Class cls = member.getDeclaringClass();
            if (cls.isArray() || cls.isPrimitive())
                return false;  // FIXME
 
            /*
            if (cls.isAnonymousClass() || cls.isLocalClass())
                return false;  // inner class of some sort
            if (cls.getClassLoader() != MethodHandle.class.getClassLoader())
                return false;  // not on BCP
            if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
                return false;
            MethodType mtype = member.getMethodOrFieldType();
            if (!isStaticallyNameable(mtype.returnType()))
                return false;
            for (Class<?> ptype : mtype.parameterArray())
                if (!isStaticallyNameable(ptype))
                    return false;
            if (!member.isPrivate() && VerifyAccess.isSamePackage(MethodHandle.class, cls))
                return true;   // in java.lang.invoke package
            if (member.isPublic() && isStaticallyNameable(cls))
                return true;
            */
 
            if (member.isMethod())
            {
                // [IKVM] If we can't call the method directly, invoke it via the invokeBasic infrastructure.
                return IsMethodHandleLinkTo(member)
                    || IsMethodHandleInvokeBasic(member)
                    || IsStaticallyInvocable(GetMethodWrapper(member));
            }
 
            if (member.isField())
            {
                // [IKVM] If we can't access the field directly, use the invokeBasic infrastructure.
                return IsStaticallyInvocable(GetFieldWrapper(member));
            }
 
            return false;
        }
 
        /*
        static boolean isStaticallyNameable(Class<?> cls) {
            if (cls == Object.class)
                return true;
            while (cls.isArray())
                cls = cls.getComponentType();
            if (cls.isPrimitive())
                return true;  // int[].class, for example
            if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
                return false;
            // could use VerifyAccess.isClassAccessible but the following is a safe approximation
            if (cls.getClassLoader() != Object.class.getClassLoader())
                return false;
            if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
                return true;
            if (!Modifier.isPublic(cls.getModifiers()))
                return false;
            for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
                if (VerifyAccess.isSamePackage(pkgcls, cls))
                    return true;
            }
            return false;
        }
        */
 
        void emitStaticInvoke(Name name)
        {
            emitStaticInvoke(name.function._member(), name);
        }
 
        void emitStaticInvoke(java.lang.invoke.MemberName member, Name name)
        {
            // push arguments
            emitPushArguments(name);
 
            // invocation
            if (member.isMethod())
            {
                if (IsMethodHandleLinkTo(member))
                {
                    java.lang.invoke.MethodType mt = member.getMethodType();
                    RuntimeJavaType[] args = new RuntimeJavaType[mt.parameterCount()];
                    for (int j = 0; j < args.Length; j++)
                    {
                        args[j] = RuntimeJavaType.FromClass(mt.parameterType(j));
                        args[j].Finish();
                    }
                    RuntimeJavaType ret = RuntimeJavaType.FromClass(mt.returnType());
                    ret.Finish();
                    Compiler.MethodHandleMethodWrapper.EmitLinkToCall(context, ilgen, args, ret);
                    ret.EmitConvSignatureTypeToStackType(ilgen);
                }
                else if (IsMethodHandleInvokeBasic(member))
                {
                    EmitInvokeBasic(member.getMethodType());
                }
                else
                {
                    switch (member.getReferenceKind())
                    {
                        case MethodHandleNatives.Constants.REF_invokeInterface:
                        case MethodHandleNatives.Constants.REF_invokeSpecial:
                        case MethodHandleNatives.Constants.REF_invokeStatic:
                        case MethodHandleNatives.Constants.REF_invokeVirtual:
                            break;
                        default:
                            throw new BailoutException(Bailout.UnsupportedRefKind, member);
                    }
                    RuntimeJavaMethod mw = GetMethodWrapper(member);
                    if (!IsStaticallyInvocable(mw))
                    {
                        throw new BailoutException(Bailout.NotStaticallyInvocable, member);
                    }
                    mw.Link();
                    mw.DeclaringType.Finish();
                    mw.ResolveMethod();
                    if (mw.HasCallerID)
                    {
                        EmitConstant(DynamicCallerIDProvider.Instance);
                        ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.DynamicCallerID);
                    }
                    if (mw.IsStatic || member.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeSpecial)
                    {
                        mw.EmitCall(ilgen);
                    }
                    else
                    {
                        mw.EmitCallvirt(ilgen);
                    }
                    mw.ReturnType.EmitConvSignatureTypeToStackType(ilgen);
                }
            }
            else if (member.isField())
            {
                RuntimeJavaField fw = GetFieldWrapper(member);
                if (!IsStaticallyInvocable(fw))
                {
                    throw new BailoutException(Bailout.NotStaticallyInvocable, member);
                }
                fw.Link();
                fw.DeclaringType.Finish();
                fw.ResolveField();
                switch (member.getReferenceKind())
                {
                    case MethodHandleNatives.Constants.REF_getField:
                    case MethodHandleNatives.Constants.REF_getStatic:
                        fw.EmitGet(ilgen);
                        fw.FieldTypeWrapper.EmitConvSignatureTypeToStackType(ilgen);
                        break;
                    case MethodHandleNatives.Constants.REF_putField:
                    case MethodHandleNatives.Constants.REF_putStatic:
                        fw.EmitSet(ilgen);
                        break;
                    default:
                        throw new BailoutException(Bailout.UnsupportedRefKind, member);
                }
            }
            else
            {
                throw new BailoutException(Bailout.NotStaticallyInvocable, member);
            }
        }
 
        void emitNewArray(Name name)
        {
            Class rtype = name.function.methodType().returnType();
            if (name.arguments.Length == 0)
            {
                // The array will be a constant.
                object emptyArray;
                try
                {
                    emptyArray = name.function._resolvedHandle().invoke();
                }
                catch (Exception ex)
                {
                    throw new java.lang.InternalError(ex);
                }
                //assert(java.lang.reflect.Array.getLength(emptyArray) == 0);
                //assert(emptyArray.getClass() == rtype);  // exact typing
                //mv.visitLdcInsn(constantPlaceholder(emptyArray));
                EmitConstant(emptyArray);
                emitReferenceCast(rtype, emptyArray);
                return;
            }
            Class arrayElementType = rtype.getComponentType();
            //assert(arrayElementType != null);
            emitIconstInsn(name.arguments.Length);
            OpCode xas = OpCodes.Stelem_Ref;
            if (!arrayElementType.isPrimitive())
            {
                RuntimeJavaType tw = RuntimeJavaType.FromClass(arrayElementType);
                if (tw.IsUnloadable || tw.IsGhost || tw.IsGhostArray || tw.IsNonPrimitiveValueType)
                {
                    throw new BailoutException(Bailout.UnsupportedArrayType, tw);
                }
                ilgen.Emit(OpCodes.Newarr, tw.TypeAsArrayType);
            }
            else
            {
                byte tc = arrayTypeCode(Wrapper.forPrimitiveType(arrayElementType));
                xas = arrayInsnOpcode(tc);
                //mv.visitIntInsn(Opcodes.NEWARRAY, tc);
                ilgen.Emit(OpCodes.Newarr, RuntimeJavaType.FromClass(arrayElementType).TypeAsArrayType);
            }
            // store arguments
            for (int i = 0; i < name.arguments.Length; i++)
            {
                //mv.visitInsn(Opcodes.DUP);
                ilgen.Emit(OpCodes.Dup);
                emitIconstInsn(i);
                emitPushArgument(name, i);
                //mv.visitInsn(xas);
                ilgen.Emit(xas);
            }
            // the array is left on the stack
            assertStaticType(rtype, name);
        }
 
        private Name emitSelectAlternative(Name selectAlternativeName, Name invokeBasicName)
        {
            //assert isStaticallyInvocable(invokeBasicName);
 
            Name receiver = (Name)invokeBasicName.arguments[0];
 
            CodeEmitterLabel L_fallback = ilgen.DefineLabel();
            CodeEmitterLabel L_done = ilgen.DefineLabel();
 
            // load test result
            emitPushArgument(selectAlternativeName, 0);
 
            // if_icmpne L_fallback
            ilgen.EmitBrfalse(L_fallback);
 
            // invoke selectAlternativeName.arguments[1]
            //Class<?>[] preForkClasses = localClasses.clone();
            emitPushArgument(selectAlternativeName, 1);  // get 2nd argument of selectAlternative
            emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
            emitStaticInvoke(invokeBasicName);
 
            // goto L_done
            ilgen.EmitBr(L_done);
 
            // L_fallback:
            ilgen.MarkLabel(L_fallback);
 
            // invoke selectAlternativeName.arguments[2]
            //System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
            emitPushArgument(selectAlternativeName, 2);  // get 3rd argument of selectAlternative
            emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
            emitStaticInvoke(invokeBasicName);
 
            // L_done:
            ilgen.MarkLabel(L_done);
            // for now do not bother to merge typestate; just reset to the dominator state
            //System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
 
            return invokeBasicName;  // return what's on stack
        }
 
        private Name emitGuardWithCatch(int pos)
        {
            Name args = lambdaForm.names[pos];
            Name invoker = lambdaForm.names[pos + 1];
            Name result = lambdaForm.names[pos + 2];
 
            CodeEmitterLabel L_handler = ilgen.DefineLabel();
            CodeEmitterLabel L_done = ilgen.DefineLabel();
 
            Class returnType = result.function._resolvedHandle().type().returnType();
            java.lang.invoke.MethodType type = args.function._resolvedHandle().type()
                                  .dropParameterTypes(0, 1)
                                  .changeReturnType(returnType);
 
            // Normal case
            ilgen.BeginExceptionBlock();
            // load target
            emitPushArgument(invoker, 0);
            emitPushArguments(args, 1); // skip 1st argument: method handle
            EmitInvokeBasic(type.basicType());
            CodeEmitterLocal returnValue = null;
            if (returnType != java.lang.Void.TYPE)
            {
                returnValue = ilgen.DeclareLocal(RuntimeJavaType.FromClass(returnType).TypeAsLocalOrStackType);
                ilgen.Emit(OpCodes.Stloc, returnValue);
            }
            ilgen.EmitLeave(L_done);
 
            // Exceptional case
            ilgen.BeginCatchBlock(typeof(Exception));
 
            // [IKVM] map the exception and store it in a local and exit the handler
            ilgen.EmitLdc_I4(0);
            ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.MapException.MakeGenericMethod(typeof(Exception)));
            CodeEmitterLocal exception = ilgen.DeclareLocal(typeof(Exception));
            ilgen.Emit(OpCodes.Stloc, exception);
            ilgen.EmitLeave(L_handler);
            ilgen.EndExceptionBlock();
 
            // Check exception's type
            ilgen.MarkLabel(L_handler);
            // load exception class
            emitPushArgument(invoker, 1);
            ilgen.Emit(OpCodes.Ldloc, exception);
            context.JavaBase.TypeOfJavaLangClass.GetMethod("isInstance", "(Ljava.lang.Object;)Z", false).EmitCall(ilgen);
            CodeEmitterLabel L_rethrow = ilgen.DefineLabel();
            ilgen.EmitBrfalse(L_rethrow);
 
            // Invoke catcher
            // load catcher
            emitPushArgument(invoker, 2);
            ilgen.Emit(OpCodes.Ldloc, exception);
            emitPushArguments(args, 1); // skip 1st argument: method handle
            MethodType catcherType = type.insertParameterTypes(0, context.JavaBase.TypeOfjavaLangThrowable.ClassObject);
            EmitInvokeBasic(catcherType.basicType());
            if (returnValue != null)
            {
                ilgen.Emit(OpCodes.Stloc, returnValue);
            }
            ilgen.EmitBr(L_done);
 
            ilgen.MarkLabel(L_rethrow);
            ilgen.Emit(OpCodes.Ldloc, exception);
            ilgen.Emit(OpCodes.Call, context.CompilerFactory.UnmapExceptionMethod);
            ilgen.Emit(OpCodes.Throw);
 
            ilgen.MarkLabel(L_done);
            if (returnValue != null)
            {
                ilgen.Emit(OpCodes.Ldloc, returnValue);
            }
 
            return result;
        }
 
        private void emitPushArguments(Name args)
        {
            emitPushArguments(args, 0);
        }
 
        private void emitPushArguments(Name args, int start)
        {
            for (int i = start; i < args.arguments.Length; i++)
            {
                emitPushArgument(args, i);
            }
        }
 
        private void emitPushArgument(Name name, int paramIndex)
        {
            object arg = name.arguments[paramIndex];
            Class ptype = name.function.methodType().parameterType(paramIndex);
            emitPushArgument(ptype, arg);
        }
 
        private void emitPushArgument(Class ptype, object arg)
        {
            BasicType bptype = BasicType.basicType(ptype);
            if (arg is Name)
            {
                Name n = (Name)arg;
                emitLoadInsn(n._type(), n.index());
                emitImplicitConversion(n._type(), ptype, n);
            }
            else if ((arg == null || arg is string) && bptype == BasicType.L_TYPE)
            {
                emitConst(arg);
            }
            else
            {
                if (Wrapper.isWrapperType(ikvm.extensions.ExtensionMethods.getClass(arg)) && bptype != BasicType.L_TYPE)
                {
                    emitConst(arg);
                }
                else
                {
                    EmitConstant(arg);
                    emitImplicitConversion(BasicType.L_TYPE, ptype, arg);
                }
            }
        }
 
        private void emitStoreResult(Name name)
        {
            if (name != null && name._type() != BasicType.V_TYPE)
            {
                // non-void: actually assign
                emitStoreInsn(name._type(), name.index());
            }
        }
 
        private void emitReturn(Name onStack)
        {
            // return statement
            Class rclass = invokerType.returnType();
            BasicType rtype = lambdaForm.returnType();
            //assert(rtype == basicType(rclass));  // must agree
            if (rtype == BasicType.V_TYPE)
            {
                // [IKVM] unlike the JVM, the CLR doesn't like left over values on the stack
                if (onStack != null && onStack._type() != BasicType.V_TYPE)
                {
                    ilgen.Emit(OpCodes.Pop);
                }
            }
            else
            {
                LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
 
                // put return value on the stack if it is not already there
                if (rn != onStack)
                {
                    emitLoadInsn(rtype, lambdaForm.result);
                }
 
                emitImplicitConversion(rtype, rclass, rn);
            }
            ilgen.Emit(OpCodes.Ret);
        }
 
        private void emitPrimCast(Wrapper from, Wrapper to)
        {
            // Here's how.
            // -   indicates forbidden
            // <-> indicates implicit
            //      to ----> boolean  byte     short    char     int      long     float    double
            // from boolean    <->        -        -        -        -        -        -        -
            //      byte        -       <->       i2s      i2c      <->      i2l      i2f      i2d
            //      short       -       i2b       <->      i2c      <->      i2l      i2f      i2d
            //      char        -       i2b       i2s      <->      <->      i2l      i2f      i2d
            //      int         -       i2b       i2s      i2c      <->      i2l      i2f      i2d
            //      long        -     l2i,i2b   l2i,i2s  l2i,i2c    l2i      <->      l2f      l2d
            //      float       -     f2i,i2b   f2i,i2s  f2i,i2c    f2i      f2l      <->      f2d
            //      double      -     d2i,i2b   d2i,i2s  d2i,i2c    d2i      d2l      d2f      <->
            if (from == to)
            {
                // no cast required, should be dead code anyway
                return;
            }
            if (from.isSubwordOrInt())
            {
                // cast from {byte,short,char,int} to anything
                emitI2X(to);
            }
            else
            {
                // cast from {long,float,double} to anything
                if (to.isSubwordOrInt())
                {
                    // cast to {byte,short,char,int}
                    emitX2I(from);
                    if (to.bitWidth() < 32)
                    {
                        // targets other than int require another conversion
                        emitI2X(to);
                    }
                }
                else
                {
                    // cast to {long,float,double} - this is verbose
                    bool error = false;
                    switch (from.name())
                    {
                        case "LONG":
                            switch (to.name())
                            {
                                case "FLOAT": ilgen.Emit(OpCodes.Conv_R4); break;
                                case "DOUBLE": ilgen.Emit(OpCodes.Conv_R8); break;
                                default: error = true; break;
                            }
                            break;
                        case "FLOAT":
                            switch (to.name())
                            {
                                case "LONG": ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.f2l); break;
                                case "DOUBLE": ilgen.Emit(OpCodes.Conv_R8); break;
                                default: error = true; break;
                            }
                            break;
                        case "DOUBLE":
                            switch (to.name())
                            {
                                case "LONG": ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.d2l); break;
                                case "FLOAT": ilgen.Emit(OpCodes.Conv_R4); break;
                                default: error = true; break;
                            }
                            break;
                        default:
                            error = true;
                            break;
                    }
                    if (error)
                    {
                        throw new BailoutException(Bailout.PreconditionViolated, "unhandled prim cast: " + from + "2" + to);
                    }
                }
            }
        }
 
        private void emitI2X(Wrapper type)
        {
            switch (type.name())
            {
                case "BYTE": ilgen.Emit(OpCodes.Conv_I1); break;
                case "SHORT": ilgen.Emit(OpCodes.Conv_I2); break;
                case "CHAR": ilgen.Emit(OpCodes.Conv_U2); break;
                case "INT":     /* naught */                  break;
                case "LONG": ilgen.Emit(OpCodes.Conv_I8); break;
                case "FLOAT": ilgen.Emit(OpCodes.Conv_R4); break;
                case "DOUBLE": ilgen.Emit(OpCodes.Conv_R8); break;
                case "BOOLEAN":
                    // For compatibility with ValueConversions and explicitCastArguments:
                    ilgen.EmitLdc_I4(1);
                    ilgen.Emit(OpCodes.And);
                    break;
                default: throw new BailoutException(Bailout.PreconditionViolated, "unknown type: " + type);
            }
        }
 
        private void emitX2I(Wrapper type)
        {
            switch (type.name())
            {
                case "LONG": ilgen.Emit(OpCodes.Conv_I4); break;
                case "FLOAT": ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.f2i); break;
                case "DOUBLE": ilgen.Emit(OpCodes.Call, context.ByteCodeHelperMethods.d2i); break;
                default: throw new BailoutException(Bailout.PreconditionViolated, "unknown type: " + type);
            }
        }
 
        private void EmitConstant(object obj)
        {
            if (obj == null)
            {
                ilgen.Emit(OpCodes.Ldnull);
                return;
            }
            int index = constants.IndexOf(obj);
            if (index == -1)
            {
                index = constants.Count;
                constants.Add(obj);
            }
            ilgen.EmitLdarg(0); // we want the bound value, not the real first parameter
            ilgen.EmitLdc_I4(index);
            ilgen.Emit(OpCodes.Ldelem_Ref);
        }
 
        private void EmitInvokeBasic(global::java.lang.invoke.MethodType mt)
        {
            RuntimeJavaType[] args = new RuntimeJavaType[mt.parameterCount()];
            for (int i = 0; i < args.Length; i++)
            {
                args[i] = RuntimeJavaType.FromClass(mt.parameterType(i));
                args[i].Finish();
            }
            RuntimeJavaType ret = RuntimeJavaType.FromClass(mt.returnType());
            ret.Finish();
            Compiler.MethodHandleMethodWrapper.EmitInvokeBasic(JVM.Context, ilgen, args, ret, false);
        }
 
        private OpCode arrayLoadOpcode(byte tcode)
        {
            switch (tcode)
            {
                case Opcodes.T_BOOLEAN:
                case Opcodes.T_BYTE:
                    return OpCodes.Ldelem_I1;
                case Opcodes.T_CHAR:
                    return OpCodes.Ldelem_U2;
                case Opcodes.T_SHORT:
                    return OpCodes.Ldelem_I2;
                case Opcodes.T_INT:
                    return OpCodes.Ldelem_I4;
                case Opcodes.T_LONG:
                    return OpCodes.Ldelem_I8;
                case Opcodes.T_FLOAT:
                    return OpCodes.Ldelem_R4;
                case Opcodes.T_DOUBLE:
                    return OpCodes.Ldelem_R8;
                case 0:
                    return OpCodes.Ldelem_Ref;
                default:
                    throw new BailoutException(Bailout.PreconditionViolated, "tcode = " + tcode);
            }
        }
 
        private bool IsMethodHandleLinkTo(java.lang.invoke.MemberName member)
        {
            return member.getDeclaringClass() == context.JavaBase.TypeOfJavaLangInvokeMethodHandle.ClassObject && member.getName().StartsWith("linkTo", StringComparison.Ordinal);
        }
 
        private bool IsMethodHandleInvokeBasic(java.lang.invoke.MemberName member)
        {
            return member.getDeclaringClass() == context.JavaBase.TypeOfJavaLangInvokeMethodHandle.ClassObject && member.getName() == "invokeBasic";
        }
 
        private RuntimeJavaMethod GetMethodWrapper(java.lang.invoke.MemberName member)
        {
            return RuntimeJavaType.FromClass(member.getDeclaringClass()).GetMethod(member.getName(), member.getSignature().Replace('/', '.'), true);
        }
 
        private bool IsStaticallyInvocable(RuntimeJavaMethod mw)
        {
            if (mw == null || mw.DeclaringType.IsUnloadable || mw.DeclaringType.IsGhost || mw.DeclaringType.IsNonPrimitiveValueType || mw.IsFinalizeOrClone || mw.IsDynamicOnly)
            {
                return false;
            }
            if (mw.ReturnType.IsUnloadable || mw.ReturnType.IsGhost || mw.ReturnType.IsNonPrimitiveValueType)
            {
                return false;
            }
            foreach (RuntimeJavaType tw in mw.GetParameters())
            {
                if (tw.IsUnloadable || tw.IsGhost || tw.IsNonPrimitiveValueType)
                {
                    return false;
                }
            }
            return true;
        }
 
        private RuntimeJavaField GetFieldWrapper(java.lang.invoke.MemberName member)
        {
            return RuntimeJavaType.FromClass(member.getDeclaringClass()).GetFieldWrapper(member.getName(), member.getSignature().Replace('/', '.'));
        }
 
        private bool IsStaticallyInvocable(RuntimeJavaField fw)
        {
            return fw != null
                && !fw.FieldTypeWrapper.IsUnloadable
                && !fw.FieldTypeWrapper.IsGhost
                && !fw.FieldTypeWrapper.IsNonPrimitiveValueType;
        }
 
#endif
 
    }
 
}