1 /*
   2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.lang.invoke;
  27 
  28 import java.io.*;
  29 import java.util.*;
  30 import java.lang.reflect.Modifier;
  31 
  32 import jdk.internal.org.objectweb.asm.*;
  33 
  34 import static java.lang.invoke.LambdaForm.*;
  35 import static java.lang.invoke.LambdaForm.BasicType.*;
  36 import static java.lang.invoke.MethodHandleStatics.*;
  37 import static java.lang.invoke.MethodHandleNatives.Constants.*;
  38 
  39 import sun.invoke.util.VerifyAccess;
  40 import sun.invoke.util.VerifyType;
  41 import sun.invoke.util.Wrapper;
  42 import sun.reflect.misc.ReflectUtil;
  43 
  44 /**
  45  * Code generation backend for LambdaForm.
  46  * <p>
  47  * @author John Rose, JSR 292 EG
  48  */
  49 class InvokerBytecodeGenerator {
  50     /** Define class names for convenience. */
  51     private static final String MH      = "java/lang/invoke/MethodHandle";
  52     private static final String MHI     = "java/lang/invoke/MethodHandleImpl";
  53     private static final String LF      = "java/lang/invoke/LambdaForm";
  54     private static final String LFN     = "java/lang/invoke/LambdaForm$Name";
  55     private static final String CLS     = "java/lang/Class";
  56     private static final String OBJ     = "java/lang/Object";
  57     private static final String OBJARY  = "[Ljava/lang/Object;";
  58 
  59     private static final String LF_SIG  = "L" + LF + ";";
  60     private static final String LFN_SIG = "L" + LFN + ";";
  61     private static final String LL_SIG  = "(L" + OBJ + ";)L" + OBJ + ";";
  62     private static final String CLL_SIG = "(L" + CLS + ";L" + OBJ + ";)L" + OBJ + ";";
  63 
  64     /** Name of its super class*/
  65     private static final String superName = OBJ;
  66 
  67     /** Name of new class */
  68     private final String className;
  69 
  70     /** Name of the source file (for stack trace printing). */
  71     private final String sourceFile;
  72 
  73     private final LambdaForm lambdaForm;
  74     private final String     invokerName;
  75     private final MethodType invokerType;
  76 
  77     /** Info about local variables in compiled lambda form */
  78     private final int[]       localsMap;    // index
  79     private final BasicType[] localTypes;   // basic type
  80     private final Class<?>[]  localClasses; // type
  81 
  82     /** ASM bytecode generation. */
  83     private ClassWriter cw;
  84     private MethodVisitor mv;
  85 
  86     private static final MemberName.Factory MEMBERNAME_FACTORY = MemberName.getFactory();
  87     private static final Class<?> HOST_CLASS = LambdaForm.class;
  88 
  89     /** Main constructor; other constructors delegate to this one. */
  90     private InvokerBytecodeGenerator(LambdaForm lambdaForm, int localsMapSize,
  91                                      String className, String invokerName, MethodType invokerType) {
  92         if (invokerName.contains(".")) {
  93             int p = invokerName.indexOf('.');
  94             className = invokerName.substring(0, p);
  95             invokerName = invokerName.substring(p+1);
  96         }
  97         if (DUMP_CLASS_FILES) {
  98             className = makeDumpableClassName(className);
  99         }
 100         this.className  = LF + "$" + className;
 101         this.sourceFile = "LambdaForm$" + className;
 102         this.lambdaForm = lambdaForm;
 103         this.invokerName = invokerName;
 104         this.invokerType = invokerType;
 105         this.localsMap = new int[localsMapSize+1];
 106         // last entry of localsMap is count of allocated local slots
 107         this.localTypes = new BasicType[localsMapSize+1];
 108         this.localClasses = new Class<?>[localsMapSize+1];
 109     }
 110 
 111     /** For generating LambdaForm interpreter entry points. */
 112     private InvokerBytecodeGenerator(String className, String invokerName, MethodType invokerType) {
 113         this(null, invokerType.parameterCount(),
 114              className, invokerName, invokerType);
 115         // Create an array to map name indexes to locals indexes.
 116         localTypes[localTypes.length - 1] = V_TYPE;
 117         for (int i = 0; i < localsMap.length; i++) {
 118             localsMap[i] = invokerType.parameterSlotCount() - invokerType.parameterSlotDepth(i);
 119             if (i < invokerType.parameterCount())
 120                 localTypes[i] = basicType(invokerType.parameterType(i));
 121         }
 122     }
 123 
 124     /** For generating customized code for a single LambdaForm. */
 125     private InvokerBytecodeGenerator(String className, LambdaForm form, MethodType invokerType) {
 126         this(form, form.names.length,
 127              className, form.debugName, invokerType);
 128         // Create an array to map name indexes to locals indexes.
 129         Name[] names = form.names;
 130         for (int i = 0, index = 0; i < localsMap.length; i++) {
 131             localsMap[i] = index;
 132             if (i < names.length) {
 133                 BasicType type = names[i].type();
 134                 index += type.basicTypeSlots();
 135                 localTypes[i] = type;
 136             }
 137         }
 138     }
 139 
 140 
 141     /** instance counters for dumped classes */
 142     private final static HashMap<String,Integer> DUMP_CLASS_FILES_COUNTERS;
 143     /** debugging flag for saving generated class files */
 144     private final static File DUMP_CLASS_FILES_DIR;
 145 
 146     static {
 147         if (DUMP_CLASS_FILES) {
 148             DUMP_CLASS_FILES_COUNTERS = new HashMap<>();
 149             try {
 150                 File dumpDir = new File("DUMP_CLASS_FILES");
 151                 if (!dumpDir.exists()) {
 152                     dumpDir.mkdirs();
 153                 }
 154                 DUMP_CLASS_FILES_DIR = dumpDir;
 155                 System.out.println("Dumping class files to "+DUMP_CLASS_FILES_DIR+"/...");
 156             } catch (Exception e) {
 157                 throw newInternalError(e);
 158             }
 159         } else {
 160             DUMP_CLASS_FILES_COUNTERS = null;
 161             DUMP_CLASS_FILES_DIR = null;
 162         }
 163     }
 164 
 165     static void maybeDump(final String className, final byte[] classFile) {
 166         if (DUMP_CLASS_FILES) {
 167             java.security.AccessController.doPrivileged(
 168             new java.security.PrivilegedAction<Void>() {
 169                 public Void run() {
 170                     try {
 171                         String dumpName = className;
 172                         //dumpName = dumpName.replace('/', '-');
 173                         File dumpFile = new File(DUMP_CLASS_FILES_DIR, dumpName+".class");
 174                         System.out.println("dump: " + dumpFile);
 175                         dumpFile.getParentFile().mkdirs();
 176                         FileOutputStream file = new FileOutputStream(dumpFile);
 177                         file.write(classFile);
 178                         file.close();
 179                         return null;
 180                     } catch (IOException ex) {
 181                         throw newInternalError(ex);
 182                     }
 183                 }
 184             });
 185         }
 186 
 187     }
 188 
 189     private static String makeDumpableClassName(String className) {
 190         Integer ctr;
 191         synchronized (DUMP_CLASS_FILES_COUNTERS) {
 192             ctr = DUMP_CLASS_FILES_COUNTERS.get(className);
 193             if (ctr == null)  ctr = 0;
 194             DUMP_CLASS_FILES_COUNTERS.put(className, ctr+1);
 195         }
 196         String sfx = ctr.toString();
 197         while (sfx.length() < 3)
 198             sfx = "0"+sfx;
 199         className += sfx;
 200         return className;
 201     }
 202 
 203     class CpPatch {
 204         final int index;
 205         final String placeholder;
 206         final Object value;
 207         CpPatch(int index, String placeholder, Object value) {
 208             this.index = index;
 209             this.placeholder = placeholder;
 210             this.value = value;
 211         }
 212         public String toString() {
 213             return "CpPatch/index="+index+",placeholder="+placeholder+",value="+value;
 214         }
 215     }
 216 
 217     Map<Object, CpPatch> cpPatches = new HashMap<>();
 218 
 219     int cph = 0;  // for counting constant placeholders
 220 
 221     String constantPlaceholder(Object arg) {
 222         String cpPlaceholder = "CONSTANT_PLACEHOLDER_" + cph++;
 223         if (DUMP_CLASS_FILES) cpPlaceholder += " <<" + debugString(arg) + ">>";  // debugging aid
 224         if (cpPatches.containsKey(cpPlaceholder)) {
 225             throw new InternalError("observed CP placeholder twice: " + cpPlaceholder);
 226         }
 227         // insert placeholder in CP and remember the patch
 228         int index = cw.newConst((Object) cpPlaceholder);  // TODO check if already in the constant pool
 229         cpPatches.put(cpPlaceholder, new CpPatch(index, cpPlaceholder, arg));
 230         return cpPlaceholder;
 231     }
 232 
 233     Object[] cpPatches(byte[] classFile) {
 234         int size = getConstantPoolSize(classFile);
 235         Object[] res = new Object[size];
 236         for (CpPatch p : cpPatches.values()) {
 237             if (p.index >= size)
 238                 throw new InternalError("in cpool["+size+"]: "+p+"\n"+Arrays.toString(Arrays.copyOf(classFile, 20)));
 239             res[p.index] = p.value;
 240         }
 241         return res;
 242     }
 243 
 244     private static String debugString(Object arg) {
 245         if (arg instanceof MethodHandle) {
 246             MethodHandle mh = (MethodHandle) arg;
 247             MemberName member = mh.internalMemberName();
 248             if (member != null)
 249                 return member.toString();
 250             return mh.debugString();
 251         }
 252         return arg.toString();
 253     }
 254 
 255     /**
 256      * Extract the number of constant pool entries from a given class file.
 257      *
 258      * @param classFile the bytes of the class file in question.
 259      * @return the number of entries in the constant pool.
 260      */
 261     private static int getConstantPoolSize(byte[] classFile) {
 262         // The first few bytes:
 263         // u4 magic;
 264         // u2 minor_version;
 265         // u2 major_version;
 266         // u2 constant_pool_count;
 267         return ((classFile[8] & 0xFF) << 8) | (classFile[9] & 0xFF);
 268     }
 269 
 270     /**
 271      * Extract the MemberName of a newly-defined method.
 272      */
 273     private MemberName loadMethod(byte[] classFile) {
 274         Class<?> invokerClass = loadAndInitializeInvokerClass(classFile, cpPatches(classFile));
 275         return resolveInvokerMember(invokerClass, invokerName, invokerType);
 276     }
 277 
 278     /**
 279      * Define a given class as anonymous class in the runtime system.
 280      */
 281     private static Class<?> loadAndInitializeInvokerClass(byte[] classBytes, Object[] patches) {
 282         Class<?> invokerClass = UNSAFE.defineAnonymousClass(HOST_CLASS, classBytes, patches);
 283         UNSAFE.ensureClassInitialized(invokerClass);  // Make sure the class is initialized; VM might complain.
 284         return invokerClass;
 285     }
 286 
 287     private static MemberName resolveInvokerMember(Class<?> invokerClass, String name, MethodType type) {
 288         MemberName member = new MemberName(invokerClass, name, type, REF_invokeStatic);
 289         //System.out.println("resolveInvokerMember => "+member);
 290         //for (Method m : invokerClass.getDeclaredMethods())  System.out.println("  "+m);
 291         try {
 292             member = MEMBERNAME_FACTORY.resolveOrFail(REF_invokeStatic, member, HOST_CLASS, ReflectiveOperationException.class);
 293         } catch (ReflectiveOperationException e) {
 294             throw newInternalError(e);
 295         }
 296         //System.out.println("resolveInvokerMember => "+member);
 297         return member;
 298     }
 299 
 300     /**
 301      * Set up class file generation.
 302      */
 303     private void classFilePrologue() {
 304         final int NOT_ACC_PUBLIC = 0;  // not ACC_PUBLIC
 305         cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
 306         cw.visit(Opcodes.V1_8, NOT_ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, className, null, superName, null);
 307         cw.visitSource(sourceFile, null);
 308 
 309         String invokerDesc = invokerType.toMethodDescriptorString();
 310         mv = cw.visitMethod(Opcodes.ACC_STATIC, invokerName, invokerDesc, null, null);
 311     }
 312 
 313     /**
 314      * Tear down class file generation.
 315      */
 316     private void classFileEpilogue() {
 317         mv.visitMaxs(0, 0);
 318         mv.visitEnd();
 319     }
 320 
 321     /*
 322      * Low-level emit helpers.
 323      */
 324     private void emitConst(Object con) {
 325         if (con == null) {
 326             mv.visitInsn(Opcodes.ACONST_NULL);
 327             return;
 328         }
 329         if (con instanceof Integer) {
 330             emitIconstInsn((int) con);
 331             return;
 332         }
 333         if (con instanceof Long) {
 334             long x = (long) con;
 335             if (x == (short) x) {
 336                 emitIconstInsn((int) x);
 337                 mv.visitInsn(Opcodes.I2L);
 338                 return;
 339             }
 340         }
 341         if (con instanceof Float) {
 342             float x = (float) con;
 343             if (x == (short) x) {
 344                 emitIconstInsn((int) x);
 345                 mv.visitInsn(Opcodes.I2F);
 346                 return;
 347             }
 348         }
 349         if (con instanceof Double) {
 350             double x = (double) con;
 351             if (x == (short) x) {
 352                 emitIconstInsn((int) x);
 353                 mv.visitInsn(Opcodes.I2D);
 354                 return;
 355             }
 356         }
 357         if (con instanceof Boolean) {
 358             emitIconstInsn((boolean) con ? 1 : 0);
 359             return;
 360         }
 361         // fall through:
 362         mv.visitLdcInsn(con);
 363     }
 364 
 365     private void emitIconstInsn(int i) {
 366         int opcode;
 367         switch (i) {
 368         case 0:  opcode = Opcodes.ICONST_0;  break;
 369         case 1:  opcode = Opcodes.ICONST_1;  break;
 370         case 2:  opcode = Opcodes.ICONST_2;  break;
 371         case 3:  opcode = Opcodes.ICONST_3;  break;
 372         case 4:  opcode = Opcodes.ICONST_4;  break;
 373         case 5:  opcode = Opcodes.ICONST_5;  break;
 374         default:
 375             if (i == (byte) i) {
 376                 mv.visitIntInsn(Opcodes.BIPUSH, i & 0xFF);
 377             } else if (i == (short) i) {
 378                 mv.visitIntInsn(Opcodes.SIPUSH, (char) i);
 379             } else {
 380                 mv.visitLdcInsn(i);
 381             }
 382             return;
 383         }
 384         mv.visitInsn(opcode);
 385     }
 386 
 387     /*
 388      * NOTE: These load/store methods use the localsMap to find the correct index!
 389      */
 390     private void emitLoadInsn(BasicType type, int index) {
 391         int opcode = loadInsnOpcode(type);
 392         mv.visitVarInsn(opcode, localsMap[index]);
 393     }
 394 
 395     private int loadInsnOpcode(BasicType type) throws InternalError {
 396         switch (type) {
 397             case I_TYPE: return Opcodes.ILOAD;
 398             case J_TYPE: return Opcodes.LLOAD;
 399             case F_TYPE: return Opcodes.FLOAD;
 400             case D_TYPE: return Opcodes.DLOAD;
 401             case L_TYPE: return Opcodes.ALOAD;
 402             default:
 403                 throw new InternalError("unknown type: " + type);
 404         }
 405     }
 406     private void emitAloadInsn(int index) {
 407         emitLoadInsn(L_TYPE, index);
 408     }
 409 
 410     private void emitStoreInsn(BasicType type, int index) {
 411         int opcode = storeInsnOpcode(type);
 412         mv.visitVarInsn(opcode, localsMap[index]);
 413     }
 414 
 415     private int storeInsnOpcode(BasicType type) throws InternalError {
 416         switch (type) {
 417             case I_TYPE: return Opcodes.ISTORE;
 418             case J_TYPE: return Opcodes.LSTORE;
 419             case F_TYPE: return Opcodes.FSTORE;
 420             case D_TYPE: return Opcodes.DSTORE;
 421             case L_TYPE: return Opcodes.ASTORE;
 422             default:
 423                 throw new InternalError("unknown type: " + type);
 424         }
 425     }
 426     private void emitAstoreInsn(int index) {
 427         emitStoreInsn(L_TYPE, index);
 428     }
 429 
 430     private byte arrayTypeCode(Wrapper elementType) {
 431         switch (elementType) {
 432             case BOOLEAN: return Opcodes.T_BOOLEAN;
 433             case BYTE:    return Opcodes.T_BYTE;
 434             case CHAR:    return Opcodes.T_CHAR;
 435             case SHORT:   return Opcodes.T_SHORT;
 436             case INT:     return Opcodes.T_INT;
 437             case LONG:    return Opcodes.T_LONG;
 438             case FLOAT:   return Opcodes.T_FLOAT;
 439             case DOUBLE:  return Opcodes.T_DOUBLE;
 440             case OBJECT:  return 0; // in place of Opcodes.T_OBJECT
 441             default:      throw new InternalError();
 442         }
 443     }
 444 
 445     private int arrayInsnOpcode(byte tcode, int aaop) throws InternalError {
 446         assert(aaop == Opcodes.AASTORE || aaop == Opcodes.AALOAD);
 447         int xas;
 448         switch (tcode) {
 449             case Opcodes.T_BOOLEAN: xas = Opcodes.BASTORE; break;
 450             case Opcodes.T_BYTE:    xas = Opcodes.BASTORE; break;
 451             case Opcodes.T_CHAR:    xas = Opcodes.CASTORE; break;
 452             case Opcodes.T_SHORT:   xas = Opcodes.SASTORE; break;
 453             case Opcodes.T_INT:     xas = Opcodes.IASTORE; break;
 454             case Opcodes.T_LONG:    xas = Opcodes.LASTORE; break;
 455             case Opcodes.T_FLOAT:   xas = Opcodes.FASTORE; break;
 456             case Opcodes.T_DOUBLE:  xas = Opcodes.DASTORE; break;
 457             case 0:                 xas = Opcodes.AASTORE; break;
 458             default:      throw new InternalError();
 459         }
 460         return xas - Opcodes.AASTORE + aaop;
 461     }
 462 
 463 
 464     private void freeFrameLocal(int oldFrameLocal) {
 465         int i = indexForFrameLocal(oldFrameLocal);
 466         if (i < 0)  return;
 467         BasicType type = localTypes[i];
 468         int newFrameLocal = makeLocalTemp(type);
 469         mv.visitVarInsn(loadInsnOpcode(type), oldFrameLocal);
 470         mv.visitVarInsn(storeInsnOpcode(type), newFrameLocal);
 471         assert(localsMap[i] == oldFrameLocal);
 472         localsMap[i] = newFrameLocal;
 473         assert(indexForFrameLocal(oldFrameLocal) < 0);
 474     }
 475     private int indexForFrameLocal(int frameLocal) {
 476         for (int i = 0; i < localsMap.length; i++) {
 477             if (localsMap[i] == frameLocal && localTypes[i] != V_TYPE)
 478                 return i;
 479         }
 480         return -1;
 481     }
 482     private int makeLocalTemp(BasicType type) {
 483         int frameLocal = localsMap[localsMap.length - 1];
 484         localsMap[localsMap.length - 1] = frameLocal + type.basicTypeSlots();
 485         return frameLocal;
 486     }
 487 
 488     /**
 489      * Emit a boxing call.
 490      *
 491      * @param wrapper primitive type class to box.
 492      */
 493     private void emitBoxing(Wrapper wrapper) {
 494         String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
 495         String name  = "valueOf";
 496         String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
 497         mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
 498     }
 499 
 500     /**
 501      * Emit an unboxing call (plus preceding checkcast).
 502      *
 503      * @param wrapper wrapper type class to unbox.
 504      */
 505     private void emitUnboxing(Wrapper wrapper) {
 506         String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
 507         String name  = wrapper.primitiveSimpleName() + "Value";
 508         String desc  = "()" + wrapper.basicTypeChar();
 509         emitReferenceCast(wrapper.wrapperType(), null);
 510         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false);
 511     }
 512 
 513     /**
 514      * Emit an implicit conversion for an argument which must be of the given pclass.
 515      * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 516      *
 517      * @param ptype type of value present on stack
 518      * @param pclass type of value required on stack
 519      * @param arg compile-time representation of value on stack (Node, constant) or null if none
 520      */
 521     private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
 522         assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
 523         if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
 524             return;   // nothing to do
 525         switch (ptype) {
 526             case L_TYPE:
 527                 if (VerifyType.isNullConversion(Object.class, pclass, false)) {
 528                     if (PROFILE_LEVEL > 0)
 529                         emitReferenceCast(Object.class, arg);
 530                     return;
 531                 }
 532                 emitReferenceCast(pclass, arg);
 533                 return;
 534             case I_TYPE:
 535                 if (!VerifyType.isNullConversion(int.class, pclass, false))
 536                     emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
 537                 return;
 538         }
 539         throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
 540     }
 541 
 542     /** Update localClasses type map.  Return true if the information is already present. */
 543     private boolean assertStaticType(Class<?> cls, Name n) {
 544         int local = n.index();
 545         Class<?> aclass = localClasses[local];
 546         if (aclass != null && (aclass == cls || cls.isAssignableFrom(aclass))) {
 547             return true;  // type info is already present
 548         } else if (aclass == null || aclass.isAssignableFrom(cls)) {
 549             localClasses[local] = cls;  // type info can be improved
 550         }
 551         return false;
 552     }
 553 
 554     private void emitReferenceCast(Class<?> cls, Object arg) {
 555         Name writeBack = null;  // local to write back result
 556         if (arg instanceof Name) {
 557             Name n = (Name) arg;
 558             if (assertStaticType(cls, n))
 559                 return;  // this cast was already performed
 560             if (lambdaForm.useCount(n) > 1) {
 561                 // This guy gets used more than once.
 562                 writeBack = n;
 563             }
 564         }
 565         if (isStaticallyNameable(cls)) {
 566             String sig = getInternalName(cls);
 567             mv.visitTypeInsn(Opcodes.CHECKCAST, sig);
 568         } else {
 569             mv.visitLdcInsn(constantPlaceholder(cls));
 570             mv.visitTypeInsn(Opcodes.CHECKCAST, CLS);
 571             mv.visitInsn(Opcodes.SWAP);
 572             mv.visitMethodInsn(Opcodes.INVOKESTATIC, MHI, "castReference", CLL_SIG, false);
 573             if (Object[].class.isAssignableFrom(cls))
 574                 mv.visitTypeInsn(Opcodes.CHECKCAST, OBJARY);
 575             else if (PROFILE_LEVEL > 0)
 576                 mv.visitTypeInsn(Opcodes.CHECKCAST, OBJ);
 577         }
 578         if (writeBack != null) {
 579             mv.visitInsn(Opcodes.DUP);
 580             emitAstoreInsn(writeBack.index());
 581         }
 582     }
 583 
 584     /**
 585      * Emits an actual return instruction conforming to the given return type.
 586      */
 587     private void emitReturnInsn(BasicType type) {
 588         int opcode;
 589         switch (type) {
 590         case I_TYPE:  opcode = Opcodes.IRETURN;  break;
 591         case J_TYPE:  opcode = Opcodes.LRETURN;  break;
 592         case F_TYPE:  opcode = Opcodes.FRETURN;  break;
 593         case D_TYPE:  opcode = Opcodes.DRETURN;  break;
 594         case L_TYPE:  opcode = Opcodes.ARETURN;  break;
 595         case V_TYPE:  opcode = Opcodes.RETURN;   break;
 596         default:
 597             throw new InternalError("unknown return type: " + type);
 598         }
 599         mv.visitInsn(opcode);
 600     }
 601 
 602     private static String getInternalName(Class<?> c) {
 603         if (c == Object.class)             return OBJ;
 604         else if (c == Object[].class)      return OBJARY;
 605         else if (c == Class.class)         return CLS;
 606         else if (c == MethodHandle.class)  return MH;
 607         assert(VerifyAccess.isTypeVisible(c, Object.class)) : c.getName();
 608         return c.getName().replace('.', '/');
 609     }
 610 
 611     /**
 612      * Generate customized bytecode for a given LambdaForm.
 613      */
 614     static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) {
 615         InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("MH", form, invokerType);
 616         return g.loadMethod(g.generateCustomizedCodeBytes());
 617     }
 618 
 619     /**
 620      * Generate an invoker method for the passed {@link LambdaForm}.
 621      */
 622     private byte[] generateCustomizedCodeBytes() {
 623         classFilePrologue();
 624 
 625         // Suppress this method in backtraces displayed to the user.
 626         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
 627 
 628         // Mark this method as a compiled LambdaForm
 629         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Compiled;", true);
 630 
 631         if (lambdaForm.forceInline) {
 632             // Force inlining of this invoker method.
 633             mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
 634         } else {
 635             mv.visitAnnotation("Ljava/lang/invoke/DontInline;", true);
 636         }
 637 
 638         // iterate over the form's names, generating bytecode instructions for each
 639         // start iterating at the first name following the arguments
 640         Name onStack = null;
 641         for (int i = lambdaForm.arity; i < lambdaForm.names.length; i++) {
 642             Name name = lambdaForm.names[i];
 643 
 644             emitStoreResult(onStack);
 645             onStack = name;  // unless otherwise modified below
 646             MethodHandleImpl.Intrinsic intr = name.function.intrinsicName();
 647             switch (intr) {
 648                 case SELECT_ALTERNATIVE:
 649                     assert isSelectAlternative(i);
 650                     onStack = emitSelectAlternative(name, lambdaForm.names[i+1]);
 651                     i++;  // skip MH.invokeBasic of the selectAlternative result
 652                     continue;
 653                 case GUARD_WITH_CATCH:
 654                     assert isGuardWithCatch(i);
 655                     onStack = emitGuardWithCatch(i);
 656                     i = i+2; // Jump to the end of GWC idiom
 657                     continue;
 658                 case NEW_ARRAY:
 659                     Class<?> rtype = name.function.methodType().returnType();
 660                     if (isStaticallyNameable(rtype)) {
 661                         emitNewArray(name);
 662                         continue;
 663                     }
 664                     break;
 665                 case ARRAY_LOAD:
 666                     emitArrayLoad(name);
 667                     continue;
 668                 case ARRAY_STORE:
 669                     emitArrayStore(name);
 670                     continue;
 671                 case IDENTITY:
 672                     assert(name.arguments.length == 1);
 673                     emitPushArguments(name);
 674                     continue;
 675                 case ZERO:
 676                     assert(name.arguments.length == 0);
 677                     emitConst(name.type.basicTypeWrapper().zero());
 678                     continue;
 679                 case NONE:
 680                     // no intrinsic associated
 681                     break;
 682                 default:
 683                     throw newInternalError("Unknown intrinsic: "+intr);
 684             }
 685 
 686             MemberName member = name.function.member();
 687             if (isStaticallyInvocable(member)) {
 688                 emitStaticInvoke(member, name);
 689             } else {
 690                 emitInvoke(name);
 691             }
 692         }
 693 
 694         // return statement
 695         emitReturn(onStack);
 696 
 697         classFileEpilogue();
 698         bogusMethod(lambdaForm);
 699 
 700         final byte[] classFile = cw.toByteArray();
 701         maybeDump(className, classFile);
 702         return classFile;
 703     }
 704 
 705     void emitArrayLoad(Name name)  { emitArrayOp(name, Opcodes.AALOAD);  }
 706     void emitArrayStore(Name name) { emitArrayOp(name, Opcodes.AASTORE); }
 707 
 708     void emitArrayOp(Name name, int arrayOpcode) {
 709         assert arrayOpcode == Opcodes.AALOAD || arrayOpcode == Opcodes.AASTORE;
 710         Class<?> elementType = name.function.methodType().parameterType(0).getComponentType();
 711         assert elementType != null;
 712         emitPushArguments(name);
 713         if (elementType.isPrimitive()) {
 714             Wrapper w = Wrapper.forPrimitiveType(elementType);
 715             arrayOpcode = arrayInsnOpcode(arrayTypeCode(w), arrayOpcode);
 716         }
 717         mv.visitInsn(arrayOpcode);
 718     }
 719 
 720     /**
 721      * Emit an invoke for the given name.
 722      */
 723     void emitInvoke(Name name) {
 724         assert(!isLinkerMethodInvoke(name));  // should use the static path for these
 725         if (true) {
 726             // push receiver
 727             MethodHandle target = name.function.resolvedHandle;
 728             assert(target != null) : name.exprString();
 729             mv.visitLdcInsn(constantPlaceholder(target));
 730             emitReferenceCast(MethodHandle.class, target);
 731         } else {
 732             // load receiver
 733             emitAloadInsn(0);
 734             emitReferenceCast(MethodHandle.class, null);
 735             mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", LF_SIG);
 736             mv.visitFieldInsn(Opcodes.GETFIELD, LF, "names", LFN_SIG);
 737             // TODO more to come
 738         }
 739 
 740         // push arguments
 741         emitPushArguments(name);
 742 
 743         // invocation
 744         MethodType type = name.function.methodType();
 745         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString(), false);
 746     }
 747 
 748     static private Class<?>[] STATICALLY_INVOCABLE_PACKAGES = {
 749         // Sample classes from each package we are willing to bind to statically:
 750         java.lang.Object.class,
 751         java.util.Arrays.class,
 752         sun.misc.Unsafe.class
 753         //MethodHandle.class already covered
 754     };
 755 
 756     static boolean isStaticallyInvocable(Name name) {
 757         return isStaticallyInvocable(name.function.member());
 758     }
 759 
 760     static boolean isStaticallyInvocable(MemberName member) {
 761         if (member == null)  return false;
 762         if (member.isConstructor())  return false;
 763         Class<?> cls = member.getDeclaringClass();
 764         if (cls.isArray() || cls.isPrimitive())
 765             return false;  // FIXME
 766         if (cls.isAnonymousClass() || cls.isLocalClass())
 767             return false;  // inner class of some sort
 768         if (cls.getClassLoader() != MethodHandle.class.getClassLoader())
 769             return false;  // not on BCP
 770         if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
 771             return false;
 772         MethodType mtype = member.getMethodOrFieldType();
 773         if (!isStaticallyNameable(mtype.returnType()))
 774             return false;
 775         for (Class<?> ptype : mtype.parameterArray())
 776             if (!isStaticallyNameable(ptype))
 777                 return false;
 778         if (!member.isPrivate() && VerifyAccess.isSamePackage(MethodHandle.class, cls))
 779             return true;   // in java.lang.invoke package
 780         if (member.isPublic() && isStaticallyNameable(cls))
 781             return true;
 782         return false;
 783     }
 784 
 785     static boolean isStaticallyNameable(Class<?> cls) {
 786         if (cls == Object.class)
 787             return true;
 788         while (cls.isArray())
 789             cls = cls.getComponentType();
 790         if (cls.isPrimitive())
 791             return true;  // int[].class, for example
 792         if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
 793             return false;
 794         // could use VerifyAccess.isClassAccessible but the following is a safe approximation
 795         if (cls.getClassLoader() != Object.class.getClassLoader())
 796             return false;
 797         if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
 798             return true;
 799         if (!Modifier.isPublic(cls.getModifiers()))
 800             return false;
 801         for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
 802             if (VerifyAccess.isSamePackage(pkgcls, cls))
 803                 return true;
 804         }
 805         return false;
 806     }
 807 
 808     void emitStaticInvoke(Name name) {
 809         emitStaticInvoke(name.function.member(), name);
 810     }
 811 
 812     /**
 813      * Emit an invoke for the given name, using the MemberName directly.
 814      */
 815     void emitStaticInvoke(MemberName member, Name name) {
 816         assert(member.equals(name.function.member()));
 817         Class<?> defc = member.getDeclaringClass();
 818         String cname = getInternalName(defc);
 819         String mname = member.getName();
 820         String mtype;
 821         byte refKind = member.getReferenceKind();
 822         if (refKind == REF_invokeSpecial) {
 823             // in order to pass the verifier, we need to convert this to invokevirtual in all cases
 824             assert(member.canBeStaticallyBound()) : member;
 825             refKind = REF_invokeVirtual;
 826         }
 827 
 828         if (member.getDeclaringClass().isInterface() && refKind == REF_invokeVirtual) {
 829             // Methods from Object declared in an interface can be resolved by JVM to invokevirtual kind.
 830             // Need to convert it back to invokeinterface to pass verification and make the invocation works as expected.
 831             refKind = REF_invokeInterface;
 832         }
 833 
 834         // push arguments
 835         emitPushArguments(name);
 836 
 837         // invocation
 838         if (member.isMethod()) {
 839             mtype = member.getMethodType().toMethodDescriptorString();
 840             mv.visitMethodInsn(refKindOpcode(refKind), cname, mname, mtype,
 841                                member.getDeclaringClass().isInterface());
 842         } else {
 843             mtype = MethodType.toFieldDescriptorString(member.getFieldType());
 844             mv.visitFieldInsn(refKindOpcode(refKind), cname, mname, mtype);
 845         }
 846         // Issue a type assertion for the result, so we can avoid casts later.
 847         if (name.type == L_TYPE) {
 848             Class<?> rtype = member.getInvocationType().returnType();
 849             assert(!rtype.isPrimitive());
 850             if (rtype != Object.class && !rtype.isInterface()) {
 851                 assertStaticType(rtype, name);
 852             }
 853         }
 854     }
 855 
 856     void emitNewArray(Name name) throws InternalError {
 857         Class<?> rtype = name.function.methodType().returnType();
 858         if (name.arguments.length == 0) {
 859             // The array will be a constant.
 860             Object emptyArray;
 861             try {
 862                 emptyArray = name.function.resolvedHandle.invoke();
 863             } catch (Throwable ex) {
 864                 throw newInternalError(ex);
 865             }
 866             assert(java.lang.reflect.Array.getLength(emptyArray) == 0);
 867             assert(emptyArray.getClass() == rtype);  // exact typing
 868             mv.visitLdcInsn(constantPlaceholder(emptyArray));
 869             emitReferenceCast(rtype, emptyArray);
 870             return;
 871         }
 872         Class<?> arrayElementType = rtype.getComponentType();
 873         assert(arrayElementType != null);
 874         emitIconstInsn(name.arguments.length);
 875         int xas = Opcodes.AASTORE;
 876         if (!arrayElementType.isPrimitive()) {
 877             mv.visitTypeInsn(Opcodes.ANEWARRAY, getInternalName(arrayElementType));
 878         } else {
 879             byte tc = arrayTypeCode(Wrapper.forPrimitiveType(arrayElementType));
 880             xas = arrayInsnOpcode(tc, xas);
 881             mv.visitIntInsn(Opcodes.NEWARRAY, tc);
 882         }
 883         // store arguments
 884         for (int i = 0; i < name.arguments.length; i++) {
 885             mv.visitInsn(Opcodes.DUP);
 886             emitIconstInsn(i);
 887             emitPushArgument(name, i);
 888             mv.visitInsn(xas);
 889         }
 890         // the array is left on the stack
 891         assertStaticType(rtype, name);
 892     }
 893     int refKindOpcode(byte refKind) {
 894         switch (refKind) {
 895         case REF_invokeVirtual:      return Opcodes.INVOKEVIRTUAL;
 896         case REF_invokeStatic:       return Opcodes.INVOKESTATIC;
 897         case REF_invokeSpecial:      return Opcodes.INVOKESPECIAL;
 898         case REF_invokeInterface:    return Opcodes.INVOKEINTERFACE;
 899         case REF_getField:           return Opcodes.GETFIELD;
 900         case REF_putField:           return Opcodes.PUTFIELD;
 901         case REF_getStatic:          return Opcodes.GETSTATIC;
 902         case REF_putStatic:          return Opcodes.PUTSTATIC;
 903         }
 904         throw new InternalError("refKind="+refKind);
 905     }
 906 
 907     /**
 908      * Check if MemberName is a call to a method named {@code name} in class {@code declaredClass}.
 909      */
 910     private boolean memberRefersTo(MemberName member, Class<?> declaringClass, String name) {
 911         return member != null &&
 912                member.getDeclaringClass() == declaringClass &&
 913                member.getName().equals(name);
 914     }
 915     private boolean nameRefersTo(Name name, Class<?> declaringClass, String methodName) {
 916         return name.function != null &&
 917                memberRefersTo(name.function.member(), declaringClass, methodName);
 918     }
 919 
 920     /**
 921      * Check if MemberName is a call to MethodHandle.invokeBasic.
 922      */
 923     private boolean isInvokeBasic(Name name) {
 924         if (name.function == null)
 925             return false;
 926         if (name.arguments.length < 1)
 927             return false;  // must have MH argument
 928         MemberName member = name.function.member();
 929         return memberRefersTo(member, MethodHandle.class, "invokeBasic") &&
 930                !member.isPublic() && !member.isStatic();
 931     }
 932 
 933     /**
 934      * Check if MemberName is a call to MethodHandle.linkToStatic, etc.
 935      */
 936     private boolean isLinkerMethodInvoke(Name name) {
 937         if (name.function == null)
 938             return false;
 939         if (name.arguments.length < 1)
 940             return false;  // must have MH argument
 941         MemberName member = name.function.member();
 942         return member != null &&
 943                member.getDeclaringClass() == MethodHandle.class &&
 944                !member.isPublic() && member.isStatic() &&
 945                member.getName().startsWith("linkTo");
 946     }
 947 
 948     /**
 949      * Check if i-th name is a call to MethodHandleImpl.selectAlternative.
 950      */
 951     private boolean isSelectAlternative(int pos) {
 952         // selectAlternative idiom:
 953         //   t_{n}:L=MethodHandleImpl.selectAlternative(...)
 954         //   t_{n+1}:?=MethodHandle.invokeBasic(t_{n}, ...)
 955         if (pos+1 >= lambdaForm.names.length)  return false;
 956         Name name0 = lambdaForm.names[pos];
 957         Name name1 = lambdaForm.names[pos+1];
 958         return nameRefersTo(name0, MethodHandleImpl.class, "selectAlternative") &&
 959                isInvokeBasic(name1) &&
 960                name1.lastUseIndex(name0) == 0 &&        // t_{n+1}:?=MethodHandle.invokeBasic(t_{n}, ...)
 961                lambdaForm.lastUseIndex(name0) == pos+1; // t_{n} is local: used only in t_{n+1}
 962     }
 963 
 964     /**
 965      * Check if i-th name is a start of GuardWithCatch idiom.
 966      */
 967     private boolean isGuardWithCatch(int pos) {
 968         // GuardWithCatch idiom:
 969         //   t_{n}:L=MethodHandle.invokeBasic(...)
 970         //   t_{n+1}:L=MethodHandleImpl.guardWithCatch(*, *, *, t_{n});
 971         //   t_{n+2}:?=MethodHandle.invokeBasic(t_{n+1})
 972         if (pos+2 >= lambdaForm.names.length)  return false;
 973         Name name0 = lambdaForm.names[pos];
 974         Name name1 = lambdaForm.names[pos+1];
 975         Name name2 = lambdaForm.names[pos+2];
 976         return nameRefersTo(name1, MethodHandleImpl.class, "guardWithCatch") &&
 977                isInvokeBasic(name0) &&
 978                isInvokeBasic(name2) &&
 979                name1.lastUseIndex(name0) == 3 &&          // t_{n+1}:L=MethodHandleImpl.guardWithCatch(*, *, *, t_{n});
 980                lambdaForm.lastUseIndex(name0) == pos+1 && // t_{n} is local: used only in t_{n+1}
 981                name2.lastUseIndex(name1) == 1 &&          // t_{n+2}:?=MethodHandle.invokeBasic(t_{n+1})
 982                lambdaForm.lastUseIndex(name1) == pos+2;   // t_{n+1} is local: used only in t_{n+2}
 983     }
 984 
 985     /**
 986      * Emit bytecode for the selectAlternative idiom.
 987      *
 988      * The pattern looks like (Cf. MethodHandleImpl.makeGuardWithTest):
 989      * <blockquote><pre>{@code
 990      *   Lambda(a0:L,a1:I)=>{
 991      *     t2:I=foo.test(a1:I);
 992      *     t3:L=MethodHandleImpl.selectAlternative(t2:I,(MethodHandle(int)int),(MethodHandle(int)int));
 993      *     t4:I=MethodHandle.invokeBasic(t3:L,a1:I);t4:I}
 994      * }</pre></blockquote>
 995      */
 996     private Name emitSelectAlternative(Name selectAlternativeName, Name invokeBasicName) {
 997         assert isStaticallyInvocable(invokeBasicName);
 998 
 999         Name receiver = (Name) invokeBasicName.arguments[0];
1000 
1001         Label L_fallback = new Label();
1002         Label L_done     = new Label();
1003 
1004         // load test result
1005         emitPushArgument(selectAlternativeName, 0);
1006 
1007         // if_icmpne L_fallback
1008         mv.visitJumpInsn(Opcodes.IFEQ, L_fallback);
1009 
1010         // invoke selectAlternativeName.arguments[1]
1011         Class<?>[] preForkClasses = localClasses.clone();
1012         emitPushArgument(selectAlternativeName, 1);  // get 2nd argument of selectAlternative
1013         emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
1014         emitStaticInvoke(invokeBasicName);
1015 
1016         // goto L_done
1017         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1018 
1019         // L_fallback:
1020         mv.visitLabel(L_fallback);
1021 
1022         // invoke selectAlternativeName.arguments[2]
1023         System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
1024         emitPushArgument(selectAlternativeName, 2);  // get 3rd argument of selectAlternative
1025         emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
1026         emitStaticInvoke(invokeBasicName);
1027 
1028         // L_done:
1029         mv.visitLabel(L_done);
1030         // for now do not bother to merge typestate; just reset to the dominator state
1031         System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
1032 
1033         return invokeBasicName;  // return what's on stack
1034     }
1035 
1036     /**
1037       * Emit bytecode for the guardWithCatch idiom.
1038       *
1039       * The pattern looks like (Cf. MethodHandleImpl.makeGuardWithCatch):
1040       * <blockquote><pre>{@code
1041       *  guardWithCatch=Lambda(a0:L,a1:L,a2:L,a3:L,a4:L,a5:L,a6:L,a7:L)=>{
1042       *    t8:L=MethodHandle.invokeBasic(a4:L,a6:L,a7:L);
1043       *    t9:L=MethodHandleImpl.guardWithCatch(a1:L,a2:L,a3:L,t8:L);
1044       *   t10:I=MethodHandle.invokeBasic(a5:L,t9:L);t10:I}
1045       * }</pre></blockquote>
1046       *
1047       * It is compiled into bytecode equivalent of the following code:
1048       * <blockquote><pre>{@code
1049       *  try {
1050       *      return a1.invokeBasic(a6, a7);
1051       *  } catch (Throwable e) {
1052       *      if (!a2.isInstance(e)) throw e;
1053       *      return a3.invokeBasic(ex, a6, a7);
1054       *  }}
1055       */
1056     private Name emitGuardWithCatch(int pos) {
1057         Name args    = lambdaForm.names[pos];
1058         Name invoker = lambdaForm.names[pos+1];
1059         Name result  = lambdaForm.names[pos+2];
1060 
1061         Label L_startBlock = new Label();
1062         Label L_endBlock = new Label();
1063         Label L_handler = new Label();
1064         Label L_done = new Label();
1065 
1066         Class<?> returnType = result.function.resolvedHandle.type().returnType();
1067         MethodType type = args.function.resolvedHandle.type()
1068                               .dropParameterTypes(0,1)
1069                               .changeReturnType(returnType);
1070 
1071         mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_handler, "java/lang/Throwable");
1072 
1073         // Normal case
1074         mv.visitLabel(L_startBlock);
1075         // load target
1076         emitPushArgument(invoker, 0);
1077         emitPushArguments(args, 1); // skip 1st argument: method handle
1078         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString(), false);
1079         mv.visitLabel(L_endBlock);
1080         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1081 
1082         // Exceptional case
1083         mv.visitLabel(L_handler);
1084 
1085         // Check exception's type
1086         mv.visitInsn(Opcodes.DUP);
1087         // load exception class
1088         emitPushArgument(invoker, 1);
1089         mv.visitInsn(Opcodes.SWAP);
1090         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "isInstance", "(Ljava/lang/Object;)Z", false);
1091         Label L_rethrow = new Label();
1092         mv.visitJumpInsn(Opcodes.IFEQ, L_rethrow);
1093 
1094         // Invoke catcher
1095         // load catcher
1096         emitPushArgument(invoker, 2);
1097         mv.visitInsn(Opcodes.SWAP);
1098         emitPushArguments(args, 1); // skip 1st argument: method handle
1099         MethodType catcherType = type.insertParameterTypes(0, Throwable.class);
1100         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", catcherType.basicType().toMethodDescriptorString(), false);
1101         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1102 
1103         mv.visitLabel(L_rethrow);
1104         mv.visitInsn(Opcodes.ATHROW);
1105 
1106         mv.visitLabel(L_done);
1107 
1108         return result;
1109     }
1110 
1111     private void emitPushArguments(Name args) {
1112         emitPushArguments(args, 0);
1113     }
1114 
1115     private void emitPushArguments(Name args, int start) {
1116         for (int i = start; i < args.arguments.length; i++) {
1117             emitPushArgument(args, i);
1118         }
1119     }
1120 
1121     private void emitPushArgument(Name name, int paramIndex) {
1122         Object arg = name.arguments[paramIndex];
1123         Class<?> ptype = name.function.methodType().parameterType(paramIndex);
1124         emitPushArgument(ptype, arg);
1125     }
1126 
1127     private void emitPushArgument(Class<?> ptype, Object arg) {
1128         BasicType bptype = basicType(ptype);
1129         if (arg instanceof Name) {
1130             Name n = (Name) arg;
1131             emitLoadInsn(n.type, n.index());
1132             emitImplicitConversion(n.type, ptype, n);
1133         } else if ((arg == null || arg instanceof String) && bptype == L_TYPE) {
1134             emitConst(arg);
1135         } else {
1136             if (Wrapper.isWrapperType(arg.getClass()) && bptype != L_TYPE) {
1137                 emitConst(arg);
1138             } else {
1139                 mv.visitLdcInsn(constantPlaceholder(arg));
1140                 emitImplicitConversion(L_TYPE, ptype, arg);
1141             }
1142         }
1143     }
1144 
1145     /**
1146      * Store the name to its local, if necessary.
1147      */
1148     private void emitStoreResult(Name name) {
1149         if (name != null && name.type != V_TYPE) {
1150             // non-void: actually assign
1151             emitStoreInsn(name.type, name.index());
1152         }
1153     }
1154 
1155     /**
1156      * Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.
1157      */
1158     private void emitReturn(Name onStack) {
1159         // return statement
1160         Class<?> rclass = invokerType.returnType();
1161         BasicType rtype = lambdaForm.returnType();
1162         assert(rtype == basicType(rclass));  // must agree
1163         if (rtype == V_TYPE) {
1164             // void
1165             mv.visitInsn(Opcodes.RETURN);
1166             // it doesn't matter what rclass is; the JVM will discard any value
1167         } else {
1168             LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
1169 
1170             // put return value on the stack if it is not already there
1171             if (rn != onStack) {
1172                 emitLoadInsn(rtype, lambdaForm.result);
1173             }
1174 
1175             emitImplicitConversion(rtype, rclass, rn);
1176 
1177             // generate actual return statement
1178             emitReturnInsn(rtype);
1179         }
1180     }
1181 
1182     /**
1183      * Emit a type conversion bytecode casting from "from" to "to".
1184      */
1185     private void emitPrimCast(Wrapper from, Wrapper to) {
1186         // Here's how.
1187         // -   indicates forbidden
1188         // <-> indicates implicit
1189         //      to ----> boolean  byte     short    char     int      long     float    double
1190         // from boolean    <->        -        -        -        -        -        -        -
1191         //      byte        -       <->       i2s      i2c      <->      i2l      i2f      i2d
1192         //      short       -       i2b       <->      i2c      <->      i2l      i2f      i2d
1193         //      char        -       i2b       i2s      <->      <->      i2l      i2f      i2d
1194         //      int         -       i2b       i2s      i2c      <->      i2l      i2f      i2d
1195         //      long        -     l2i,i2b   l2i,i2s  l2i,i2c    l2i      <->      l2f      l2d
1196         //      float       -     f2i,i2b   f2i,i2s  f2i,i2c    f2i      f2l      <->      f2d
1197         //      double      -     d2i,i2b   d2i,i2s  d2i,i2c    d2i      d2l      d2f      <->
1198         if (from == to) {
1199             // no cast required, should be dead code anyway
1200             return;
1201         }
1202         if (from.isSubwordOrInt()) {
1203             // cast from {byte,short,char,int} to anything
1204             emitI2X(to);
1205         } else {
1206             // cast from {long,float,double} to anything
1207             if (to.isSubwordOrInt()) {
1208                 // cast to {byte,short,char,int}
1209                 emitX2I(from);
1210                 if (to.bitWidth() < 32) {
1211                     // targets other than int require another conversion
1212                     emitI2X(to);
1213                 }
1214             } else {
1215                 // cast to {long,float,double} - this is verbose
1216                 boolean error = false;
1217                 switch (from) {
1218                 case LONG:
1219                     switch (to) {
1220                     case FLOAT:   mv.visitInsn(Opcodes.L2F);  break;
1221                     case DOUBLE:  mv.visitInsn(Opcodes.L2D);  break;
1222                     default:      error = true;               break;
1223                     }
1224                     break;
1225                 case FLOAT:
1226                     switch (to) {
1227                     case LONG :   mv.visitInsn(Opcodes.F2L);  break;
1228                     case DOUBLE:  mv.visitInsn(Opcodes.F2D);  break;
1229                     default:      error = true;               break;
1230                     }
1231                     break;
1232                 case DOUBLE:
1233                     switch (to) {
1234                     case LONG :   mv.visitInsn(Opcodes.D2L);  break;
1235                     case FLOAT:   mv.visitInsn(Opcodes.D2F);  break;
1236                     default:      error = true;               break;
1237                     }
1238                     break;
1239                 default:
1240                     error = true;
1241                     break;
1242                 }
1243                 if (error) {
1244                     throw new IllegalStateException("unhandled prim cast: " + from + "2" + to);
1245                 }
1246             }
1247         }
1248     }
1249 
1250     private void emitI2X(Wrapper type) {
1251         switch (type) {
1252         case BYTE:    mv.visitInsn(Opcodes.I2B);  break;
1253         case SHORT:   mv.visitInsn(Opcodes.I2S);  break;
1254         case CHAR:    mv.visitInsn(Opcodes.I2C);  break;
1255         case INT:     /* naught */                break;
1256         case LONG:    mv.visitInsn(Opcodes.I2L);  break;
1257         case FLOAT:   mv.visitInsn(Opcodes.I2F);  break;
1258         case DOUBLE:  mv.visitInsn(Opcodes.I2D);  break;
1259         case BOOLEAN:
1260             // For compatibility with ValueConversions and explicitCastArguments:
1261             mv.visitInsn(Opcodes.ICONST_1);
1262             mv.visitInsn(Opcodes.IAND);
1263             break;
1264         default:   throw new InternalError("unknown type: " + type);
1265         }
1266     }
1267 
1268     private void emitX2I(Wrapper type) {
1269         switch (type) {
1270         case LONG:    mv.visitInsn(Opcodes.L2I);  break;
1271         case FLOAT:   mv.visitInsn(Opcodes.F2I);  break;
1272         case DOUBLE:  mv.visitInsn(Opcodes.D2I);  break;
1273         default:      throw new InternalError("unknown type: " + type);
1274         }
1275     }
1276 
1277     /**
1278      * Generate bytecode for a LambdaForm.vmentry which calls interpretWithArguments.
1279      */
1280     static MemberName generateLambdaFormInterpreterEntryPoint(String sig) {
1281         assert(isValidSignature(sig));
1282         String name = "interpret_"+signatureReturn(sig).basicTypeChar();
1283         MethodType type = signatureType(sig);  // sig includes leading argument
1284         type = type.changeParameterType(0, MethodHandle.class);
1285         InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("LFI", name, type);
1286         return g.loadMethod(g.generateLambdaFormInterpreterEntryPointBytes());
1287     }
1288 
1289     private byte[] generateLambdaFormInterpreterEntryPointBytes() {
1290         classFilePrologue();
1291 
1292         // Suppress this method in backtraces displayed to the user.
1293         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
1294 
1295         // Don't inline the interpreter entry.
1296         mv.visitAnnotation("Ljava/lang/invoke/DontInline;", true);
1297 
1298         // create parameter array
1299         emitIconstInsn(invokerType.parameterCount());
1300         mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
1301 
1302         // fill parameter array
1303         for (int i = 0; i < invokerType.parameterCount(); i++) {
1304             Class<?> ptype = invokerType.parameterType(i);
1305             mv.visitInsn(Opcodes.DUP);
1306             emitIconstInsn(i);
1307             emitLoadInsn(basicType(ptype), i);
1308             // box if primitive type
1309             if (ptype.isPrimitive()) {
1310                 emitBoxing(Wrapper.forPrimitiveType(ptype));
1311             }
1312             mv.visitInsn(Opcodes.AASTORE);
1313         }
1314         // invoke
1315         emitAloadInsn(0);
1316         mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", "Ljava/lang/invoke/LambdaForm;");
1317         mv.visitInsn(Opcodes.SWAP);  // swap form and array; avoid local variable
1318         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, LF, "interpretWithArguments", "([Ljava/lang/Object;)Ljava/lang/Object;", false);
1319 
1320         // maybe unbox
1321         Class<?> rtype = invokerType.returnType();
1322         if (rtype.isPrimitive() && rtype != void.class) {
1323             emitUnboxing(Wrapper.forPrimitiveType(rtype));
1324         }
1325 
1326         // return statement
1327         emitReturnInsn(basicType(rtype));
1328 
1329         classFileEpilogue();
1330         bogusMethod(invokerType);
1331 
1332         final byte[] classFile = cw.toByteArray();
1333         maybeDump(className, classFile);
1334         return classFile;
1335     }
1336 
1337     /**
1338      * Generate bytecode for a NamedFunction invoker.
1339      */
1340     static MemberName generateNamedFunctionInvoker(MethodTypeForm typeForm) {
1341         MethodType invokerType = NamedFunction.INVOKER_METHOD_TYPE;
1342         String invokerName = "invoke_" + shortenSignature(basicTypeSignature(typeForm.erasedType()));
1343         InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("NFI", invokerName, invokerType);
1344         return g.loadMethod(g.generateNamedFunctionInvokerImpl(typeForm));
1345     }
1346 
1347     private byte[] generateNamedFunctionInvokerImpl(MethodTypeForm typeForm) {
1348         MethodType dstType = typeForm.erasedType();
1349         classFilePrologue();
1350 
1351         // Suppress this method in backtraces displayed to the user.
1352         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
1353 
1354         // Force inlining of this invoker method.
1355         mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
1356 
1357         // Load receiver
1358         emitAloadInsn(0);
1359 
1360         // Load arguments from array
1361         for (int i = 0; i < dstType.parameterCount(); i++) {
1362             emitAloadInsn(1);
1363             emitIconstInsn(i);
1364             mv.visitInsn(Opcodes.AALOAD);
1365 
1366             // Maybe unbox
1367             Class<?> dptype = dstType.parameterType(i);
1368             if (dptype.isPrimitive()) {
1369                 Class<?> sptype = dstType.basicType().wrap().parameterType(i);
1370                 Wrapper dstWrapper = Wrapper.forBasicType(dptype);
1371                 Wrapper srcWrapper = dstWrapper.isSubwordOrInt() ? Wrapper.INT : dstWrapper;  // narrow subword from int
1372                 emitUnboxing(srcWrapper);
1373                 emitPrimCast(srcWrapper, dstWrapper);
1374             }
1375         }
1376 
1377         // Invoke
1378         String targetDesc = dstType.basicType().toMethodDescriptorString();
1379         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", targetDesc, false);
1380 
1381         // Box primitive types
1382         Class<?> rtype = dstType.returnType();
1383         if (rtype != void.class && rtype.isPrimitive()) {
1384             Wrapper srcWrapper = Wrapper.forBasicType(rtype);
1385             Wrapper dstWrapper = srcWrapper.isSubwordOrInt() ? Wrapper.INT : srcWrapper;  // widen subword to int
1386             // boolean casts not allowed
1387             emitPrimCast(srcWrapper, dstWrapper);
1388             emitBoxing(dstWrapper);
1389         }
1390 
1391         // If the return type is void we return a null reference.
1392         if (rtype == void.class) {
1393             mv.visitInsn(Opcodes.ACONST_NULL);
1394         }
1395         emitReturnInsn(L_TYPE);  // NOTE: NamedFunction invokers always return a reference value.
1396 
1397         classFileEpilogue();
1398         bogusMethod(dstType);
1399 
1400         final byte[] classFile = cw.toByteArray();
1401         maybeDump(className, classFile);
1402         return classFile;
1403     }
1404 
1405     /**
1406      * Emit a bogus method that just loads some string constants. This is to get the constants into the constant pool
1407      * for debugging purposes.
1408      */
1409     private void bogusMethod(Object... os) {
1410         if (DUMP_CLASS_FILES) {
1411             mv = cw.visitMethod(Opcodes.ACC_STATIC, "dummy", "()V", null, null);
1412             for (Object o : os) {
1413                 mv.visitLdcInsn(o.toString());
1414                 mv.visitInsn(Opcodes.POP);
1415             }
1416             mv.visitInsn(Opcodes.RETURN);
1417             mv.visitMaxs(0, 0);
1418             mv.visitEnd();
1419         }
1420     }
1421 }