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 (PROFILE_GWT && lambdaForm.isGWT) {
 632             mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$IgnoreProfile;", true);
 633         }
 634 
 635         if (lambdaForm.forceInline) {
 636             // Force inlining of this invoker method.
 637             mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
 638         } else {
 639             mv.visitAnnotation("Ljava/lang/invoke/DontInline;", true);
 640         }
 641 
 642         // iterate over the form's names, generating bytecode instructions for each
 643         // start iterating at the first name following the arguments
 644         Name onStack = null;
 645         for (int i = lambdaForm.arity; i < lambdaForm.names.length; i++) {
 646             Name name = lambdaForm.names[i];
 647 
 648             emitStoreResult(onStack);
 649             onStack = name;  // unless otherwise modified below
 650             MethodHandleImpl.Intrinsic intr = name.function.intrinsicName();
 651             switch (intr) {
 652                 case SELECT_ALTERNATIVE:
 653                     assert isSelectAlternative(i);
 654                     onStack = emitSelectAlternative(name, lambdaForm.names[i+1]);
 655                     i++;  // skip MH.invokeBasic of the selectAlternative result
 656                     continue;
 657                 case GUARD_WITH_CATCH:
 658                     assert isGuardWithCatch(i);
 659                     onStack = emitGuardWithCatch(i);
 660                     i = i+2; // Jump to the end of GWC idiom
 661                     continue;
 662                 case NEW_ARRAY:
 663                     Class<?> rtype = name.function.methodType().returnType();
 664                     if (isStaticallyNameable(rtype)) {
 665                         emitNewArray(name);
 666                         continue;
 667                     }
 668                     break;
 669                 case ARRAY_LOAD:
 670                     emitArrayLoad(name);
 671                     continue;
 672                 case ARRAY_STORE:
 673                     emitArrayStore(name);
 674                     continue;
 675                 case IDENTITY:
 676                     assert(name.arguments.length == 1);
 677                     emitPushArguments(name);
 678                     continue;
 679                 case ZERO:
 680                     assert(name.arguments.length == 0);
 681                     emitConst(name.type.basicTypeWrapper().zero());
 682                     continue;
 683                 case NONE:
 684                     // no intrinsic associated
 685                     break;
 686                 default:
 687                     throw newInternalError("Unknown intrinsic: "+intr);
 688             }
 689 
 690             MemberName member = name.function.member();
 691             if (isStaticallyInvocable(member)) {
 692                 emitStaticInvoke(member, name);
 693             } else {
 694                 emitInvoke(name);
 695             }
 696         }
 697 
 698         // return statement
 699         emitReturn(onStack);
 700 
 701         classFileEpilogue();
 702         bogusMethod(lambdaForm);
 703 
 704         final byte[] classFile = cw.toByteArray();
 705         maybeDump(className, classFile);
 706         return classFile;
 707     }
 708 
 709     void emitArrayLoad(Name name)  { emitArrayOp(name, Opcodes.AALOAD);  }
 710     void emitArrayStore(Name name) { emitArrayOp(name, Opcodes.AASTORE); }
 711 
 712     void emitArrayOp(Name name, int arrayOpcode) {
 713         assert arrayOpcode == Opcodes.AALOAD || arrayOpcode == Opcodes.AASTORE;
 714         Class<?> elementType = name.function.methodType().parameterType(0).getComponentType();
 715         assert elementType != null;
 716         emitPushArguments(name);
 717         if (elementType.isPrimitive()) {
 718             Wrapper w = Wrapper.forPrimitiveType(elementType);
 719             arrayOpcode = arrayInsnOpcode(arrayTypeCode(w), arrayOpcode);
 720         }
 721         mv.visitInsn(arrayOpcode);
 722     }
 723 
 724     /**
 725      * Emit an invoke for the given name.
 726      */
 727     void emitInvoke(Name name) {
 728         assert(!isLinkerMethodInvoke(name));  // should use the static path for these
 729         if (true) {
 730             // push receiver
 731             MethodHandle target = name.function.resolvedHandle;
 732             assert(target != null) : name.exprString();
 733             mv.visitLdcInsn(constantPlaceholder(target));
 734             emitReferenceCast(MethodHandle.class, target);
 735         } else {
 736             // load receiver
 737             emitAloadInsn(0);
 738             emitReferenceCast(MethodHandle.class, null);
 739             mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", LF_SIG);
 740             mv.visitFieldInsn(Opcodes.GETFIELD, LF, "names", LFN_SIG);
 741             // TODO more to come
 742         }
 743 
 744         // push arguments
 745         emitPushArguments(name);
 746 
 747         // invocation
 748         MethodType type = name.function.methodType();
 749         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString(), false);
 750     }
 751 
 752     static private Class<?>[] STATICALLY_INVOCABLE_PACKAGES = {
 753         // Sample classes from each package we are willing to bind to statically:
 754         java.lang.Object.class,
 755         java.util.Arrays.class,
 756         sun.misc.Unsafe.class
 757         //MethodHandle.class already covered
 758     };
 759 
 760     static boolean isStaticallyInvocable(Name name) {
 761         return isStaticallyInvocable(name.function.member());
 762     }
 763 
 764     static boolean isStaticallyInvocable(MemberName member) {
 765         if (member == null)  return false;
 766         if (member.isConstructor())  return false;
 767         Class<?> cls = member.getDeclaringClass();
 768         if (cls.isArray() || cls.isPrimitive())
 769             return false;  // FIXME
 770         if (cls.isAnonymousClass() || cls.isLocalClass())
 771             return false;  // inner class of some sort
 772         if (cls.getClassLoader() != MethodHandle.class.getClassLoader())
 773             return false;  // not on BCP
 774         if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
 775             return false;
 776         MethodType mtype = member.getMethodOrFieldType();
 777         if (!isStaticallyNameable(mtype.returnType()))
 778             return false;
 779         for (Class<?> ptype : mtype.parameterArray())
 780             if (!isStaticallyNameable(ptype))
 781                 return false;
 782         if (!member.isPrivate() && VerifyAccess.isSamePackage(MethodHandle.class, cls))
 783             return true;   // in java.lang.invoke package
 784         if (member.isPublic() && isStaticallyNameable(cls))
 785             return true;
 786         return false;
 787     }
 788 
 789     static boolean isStaticallyNameable(Class<?> cls) {
 790         if (cls == Object.class)
 791             return true;
 792         while (cls.isArray())
 793             cls = cls.getComponentType();
 794         if (cls.isPrimitive())
 795             return true;  // int[].class, for example
 796         if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
 797             return false;
 798         // could use VerifyAccess.isClassAccessible but the following is a safe approximation
 799         if (cls.getClassLoader() != Object.class.getClassLoader())
 800             return false;
 801         if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
 802             return true;
 803         if (!Modifier.isPublic(cls.getModifiers()))
 804             return false;
 805         for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
 806             if (VerifyAccess.isSamePackage(pkgcls, cls))
 807                 return true;
 808         }
 809         return false;
 810     }
 811 
 812     void emitStaticInvoke(Name name) {
 813         emitStaticInvoke(name.function.member(), name);
 814     }
 815 
 816     /**
 817      * Emit an invoke for the given name, using the MemberName directly.
 818      */
 819     void emitStaticInvoke(MemberName member, Name name) {
 820         assert(member.equals(name.function.member()));
 821         Class<?> defc = member.getDeclaringClass();
 822         String cname = getInternalName(defc);
 823         String mname = member.getName();
 824         String mtype;
 825         byte refKind = member.getReferenceKind();
 826         if (refKind == REF_invokeSpecial) {
 827             // in order to pass the verifier, we need to convert this to invokevirtual in all cases
 828             assert(member.canBeStaticallyBound()) : member;
 829             refKind = REF_invokeVirtual;
 830         }
 831 
 832         if (member.getDeclaringClass().isInterface() && refKind == REF_invokeVirtual) {
 833             // Methods from Object declared in an interface can be resolved by JVM to invokevirtual kind.
 834             // Need to convert it back to invokeinterface to pass verification and make the invocation works as expected.
 835             refKind = REF_invokeInterface;
 836         }
 837 
 838         // push arguments
 839         emitPushArguments(name);
 840 
 841         // invocation
 842         if (member.isMethod()) {
 843             mtype = member.getMethodType().toMethodDescriptorString();
 844             mv.visitMethodInsn(refKindOpcode(refKind), cname, mname, mtype,
 845                                member.getDeclaringClass().isInterface());
 846         } else {
 847             mtype = MethodType.toFieldDescriptorString(member.getFieldType());
 848             mv.visitFieldInsn(refKindOpcode(refKind), cname, mname, mtype);
 849         }
 850         // Issue a type assertion for the result, so we can avoid casts later.
 851         if (name.type == L_TYPE) {
 852             Class<?> rtype = member.getInvocationType().returnType();
 853             assert(!rtype.isPrimitive());
 854             if (rtype != Object.class && !rtype.isInterface()) {
 855                 assertStaticType(rtype, name);
 856             }
 857         }
 858     }
 859 
 860     void emitNewArray(Name name) throws InternalError {
 861         Class<?> rtype = name.function.methodType().returnType();
 862         if (name.arguments.length == 0) {
 863             // The array will be a constant.
 864             Object emptyArray;
 865             try {
 866                 emptyArray = name.function.resolvedHandle.invoke();
 867             } catch (Throwable ex) {
 868                 throw newInternalError(ex);
 869             }
 870             assert(java.lang.reflect.Array.getLength(emptyArray) == 0);
 871             assert(emptyArray.getClass() == rtype);  // exact typing
 872             mv.visitLdcInsn(constantPlaceholder(emptyArray));
 873             emitReferenceCast(rtype, emptyArray);
 874             return;
 875         }
 876         Class<?> arrayElementType = rtype.getComponentType();
 877         assert(arrayElementType != null);
 878         emitIconstInsn(name.arguments.length);
 879         int xas = Opcodes.AASTORE;
 880         if (!arrayElementType.isPrimitive()) {
 881             mv.visitTypeInsn(Opcodes.ANEWARRAY, getInternalName(arrayElementType));
 882         } else {
 883             byte tc = arrayTypeCode(Wrapper.forPrimitiveType(arrayElementType));
 884             xas = arrayInsnOpcode(tc, xas);
 885             mv.visitIntInsn(Opcodes.NEWARRAY, tc);
 886         }
 887         // store arguments
 888         for (int i = 0; i < name.arguments.length; i++) {
 889             mv.visitInsn(Opcodes.DUP);
 890             emitIconstInsn(i);
 891             emitPushArgument(name, i);
 892             mv.visitInsn(xas);
 893         }
 894         // the array is left on the stack
 895         assertStaticType(rtype, name);
 896     }
 897     int refKindOpcode(byte refKind) {
 898         switch (refKind) {
 899         case REF_invokeVirtual:      return Opcodes.INVOKEVIRTUAL;
 900         case REF_invokeStatic:       return Opcodes.INVOKESTATIC;
 901         case REF_invokeSpecial:      return Opcodes.INVOKESPECIAL;
 902         case REF_invokeInterface:    return Opcodes.INVOKEINTERFACE;
 903         case REF_getField:           return Opcodes.GETFIELD;
 904         case REF_putField:           return Opcodes.PUTFIELD;
 905         case REF_getStatic:          return Opcodes.GETSTATIC;
 906         case REF_putStatic:          return Opcodes.PUTSTATIC;
 907         }
 908         throw new InternalError("refKind="+refKind);
 909     }
 910 
 911     /**
 912      * Check if MemberName is a call to a method named {@code name} in class {@code declaredClass}.
 913      */
 914     private boolean memberRefersTo(MemberName member, Class<?> declaringClass, String name) {
 915         return member != null &&
 916                member.getDeclaringClass() == declaringClass &&
 917                member.getName().equals(name);
 918     }
 919     private boolean nameRefersTo(Name name, Class<?> declaringClass, String methodName) {
 920         return name.function != null &&
 921                memberRefersTo(name.function.member(), declaringClass, methodName);
 922     }
 923 
 924     /**
 925      * Check if MemberName is a call to MethodHandle.invokeBasic.
 926      */
 927     private boolean isInvokeBasic(Name name) {
 928         if (name.function == null)
 929             return false;
 930         if (name.arguments.length < 1)
 931             return false;  // must have MH argument
 932         MemberName member = name.function.member();
 933         return memberRefersTo(member, MethodHandle.class, "invokeBasic") &&
 934                !member.isPublic() && !member.isStatic();
 935     }
 936 
 937     /**
 938      * Check if MemberName is a call to MethodHandle.linkToStatic, etc.
 939      */
 940     private boolean isLinkerMethodInvoke(Name name) {
 941         if (name.function == null)
 942             return false;
 943         if (name.arguments.length < 1)
 944             return false;  // must have MH argument
 945         MemberName member = name.function.member();
 946         return member != null &&
 947                member.getDeclaringClass() == MethodHandle.class &&
 948                !member.isPublic() && member.isStatic() &&
 949                member.getName().startsWith("linkTo");
 950     }
 951 
 952     /**
 953      * Check if i-th name is a call to MethodHandleImpl.selectAlternative.
 954      */
 955     private boolean isSelectAlternative(int pos) {
 956         // selectAlternative idiom:
 957         //   t_{n}:L=MethodHandleImpl.selectAlternative(...)
 958         //   t_{n+1}:?=MethodHandle.invokeBasic(t_{n}, ...)
 959         if (pos+1 >= lambdaForm.names.length)  return false;
 960         Name name0 = lambdaForm.names[pos];
 961         Name name1 = lambdaForm.names[pos+1];
 962         return nameRefersTo(name0, MethodHandleImpl.class, "selectAlternative") &&
 963                isInvokeBasic(name1) &&
 964                name1.lastUseIndex(name0) == 0 &&        // t_{n+1}:?=MethodHandle.invokeBasic(t_{n}, ...)
 965                lambdaForm.lastUseIndex(name0) == pos+1; // t_{n} is local: used only in t_{n+1}
 966     }
 967 
 968     /**
 969      * Check if i-th name is a start of GuardWithCatch idiom.
 970      */
 971     private boolean isGuardWithCatch(int pos) {
 972         // GuardWithCatch idiom:
 973         //   t_{n}:L=MethodHandle.invokeBasic(...)
 974         //   t_{n+1}:L=MethodHandleImpl.guardWithCatch(*, *, *, t_{n});
 975         //   t_{n+2}:?=MethodHandle.invokeBasic(t_{n+1})
 976         if (pos+2 >= lambdaForm.names.length)  return false;
 977         Name name0 = lambdaForm.names[pos];
 978         Name name1 = lambdaForm.names[pos+1];
 979         Name name2 = lambdaForm.names[pos+2];
 980         return nameRefersTo(name1, MethodHandleImpl.class, "guardWithCatch") &&
 981                isInvokeBasic(name0) &&
 982                isInvokeBasic(name2) &&
 983                name1.lastUseIndex(name0) == 3 &&          // t_{n+1}:L=MethodHandleImpl.guardWithCatch(*, *, *, t_{n});
 984                lambdaForm.lastUseIndex(name0) == pos+1 && // t_{n} is local: used only in t_{n+1}
 985                name2.lastUseIndex(name1) == 1 &&          // t_{n+2}:?=MethodHandle.invokeBasic(t_{n+1})
 986                lambdaForm.lastUseIndex(name1) == pos+2;   // t_{n+1} is local: used only in t_{n+2}
 987     }
 988 
 989     /**
 990      * Emit bytecode for the selectAlternative idiom.
 991      *
 992      * The pattern looks like (Cf. MethodHandleImpl.makeGuardWithTest):
 993      * <blockquote><pre>{@code
 994      *   Lambda(a0:L,a1:I)=>{
 995      *     t2:I=foo.test(a1:I);
 996      *     t3:L=MethodHandleImpl.selectAlternative(t2:I,(MethodHandle(int)int),(MethodHandle(int)int));
 997      *     t4:I=MethodHandle.invokeBasic(t3:L,a1:I);t4:I}
 998      * }</pre></blockquote>
 999      */
1000     private Name emitSelectAlternative(Name selectAlternativeName, Name invokeBasicName) {
1001         assert isStaticallyInvocable(invokeBasicName);
1002 
1003         Name receiver = (Name) invokeBasicName.arguments[0];
1004 
1005         Label L_fallback = new Label();
1006         Label L_done     = new Label();
1007 
1008         // load test result
1009         emitPushArgument(selectAlternativeName, 0);
1010 
1011         if (PROFILE_GWT) {
1012             emitPushArgument(selectAlternativeName, 3);
1013             mv.visitMethodInsn(Opcodes.INVOKESTATIC, MHI, "profileBranch", "(Z[I)Z", false);
1014         }
1015 
1016         // if_icmpne L_fallback
1017         mv.visitJumpInsn(Opcodes.IFEQ, L_fallback);
1018 
1019         // invoke selectAlternativeName.arguments[1]
1020         Class<?>[] preForkClasses = localClasses.clone();
1021         emitPushArgument(selectAlternativeName, 1);  // get 2nd argument of selectAlternative
1022         emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
1023         emitStaticInvoke(invokeBasicName);
1024 
1025         // goto L_done
1026         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1027 
1028         // L_fallback:
1029         mv.visitLabel(L_fallback);
1030 
1031         // invoke selectAlternativeName.arguments[2]
1032         System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
1033         emitPushArgument(selectAlternativeName, 2);  // get 3rd argument of selectAlternative
1034         emitAstoreInsn(receiver.index());  // store the MH in the receiver slot
1035         emitStaticInvoke(invokeBasicName);
1036 
1037         // L_done:
1038         mv.visitLabel(L_done);
1039         // for now do not bother to merge typestate; just reset to the dominator state
1040         System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
1041 
1042         return invokeBasicName;  // return what's on stack
1043     }
1044 
1045     /**
1046       * Emit bytecode for the guardWithCatch idiom.
1047       *
1048       * The pattern looks like (Cf. MethodHandleImpl.makeGuardWithCatch):
1049       * <blockquote><pre>{@code
1050       *  guardWithCatch=Lambda(a0:L,a1:L,a2:L,a3:L,a4:L,a5:L,a6:L,a7:L)=>{
1051       *    t8:L=MethodHandle.invokeBasic(a4:L,a6:L,a7:L);
1052       *    t9:L=MethodHandleImpl.guardWithCatch(a1:L,a2:L,a3:L,t8:L);
1053       *   t10:I=MethodHandle.invokeBasic(a5:L,t9:L);t10:I}
1054       * }</pre></blockquote>
1055       *
1056       * It is compiled into bytecode equivalent of the following code:
1057       * <blockquote><pre>{@code
1058       *  try {
1059       *      return a1.invokeBasic(a6, a7);
1060       *  } catch (Throwable e) {
1061       *      if (!a2.isInstance(e)) throw e;
1062       *      return a3.invokeBasic(ex, a6, a7);
1063       *  }}
1064       */
1065     private Name emitGuardWithCatch(int pos) {
1066         Name args    = lambdaForm.names[pos];
1067         Name invoker = lambdaForm.names[pos+1];
1068         Name result  = lambdaForm.names[pos+2];
1069 
1070         Label L_startBlock = new Label();
1071         Label L_endBlock = new Label();
1072         Label L_handler = new Label();
1073         Label L_done = new Label();
1074 
1075         Class<?> returnType = result.function.resolvedHandle.type().returnType();
1076         MethodType type = args.function.resolvedHandle.type()
1077                               .dropParameterTypes(0,1)
1078                               .changeReturnType(returnType);
1079 
1080         mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_handler, "java/lang/Throwable");
1081 
1082         // Normal case
1083         mv.visitLabel(L_startBlock);
1084         // load target
1085         emitPushArgument(invoker, 0);
1086         emitPushArguments(args, 1); // skip 1st argument: method handle
1087         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString(), false);
1088         mv.visitLabel(L_endBlock);
1089         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1090 
1091         // Exceptional case
1092         mv.visitLabel(L_handler);
1093 
1094         // Check exception's type
1095         mv.visitInsn(Opcodes.DUP);
1096         // load exception class
1097         emitPushArgument(invoker, 1);
1098         mv.visitInsn(Opcodes.SWAP);
1099         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "isInstance", "(Ljava/lang/Object;)Z", false);
1100         Label L_rethrow = new Label();
1101         mv.visitJumpInsn(Opcodes.IFEQ, L_rethrow);
1102 
1103         // Invoke catcher
1104         // load catcher
1105         emitPushArgument(invoker, 2);
1106         mv.visitInsn(Opcodes.SWAP);
1107         emitPushArguments(args, 1); // skip 1st argument: method handle
1108         MethodType catcherType = type.insertParameterTypes(0, Throwable.class);
1109         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", catcherType.basicType().toMethodDescriptorString(), false);
1110         mv.visitJumpInsn(Opcodes.GOTO, L_done);
1111 
1112         mv.visitLabel(L_rethrow);
1113         mv.visitInsn(Opcodes.ATHROW);
1114 
1115         mv.visitLabel(L_done);
1116 
1117         return result;
1118     }
1119 
1120     private void emitPushArguments(Name args) {
1121         emitPushArguments(args, 0);
1122     }
1123 
1124     private void emitPushArguments(Name args, int start) {
1125         for (int i = start; i < args.arguments.length; i++) {
1126             emitPushArgument(args, i);
1127         }
1128     }
1129 
1130     private void emitPushArgument(Name name, int paramIndex) {
1131         Object arg = name.arguments[paramIndex];
1132         Class<?> ptype = name.function.methodType().parameterType(paramIndex);
1133         emitPushArgument(ptype, arg);
1134     }
1135 
1136     private void emitPushArgument(Class<?> ptype, Object arg) {
1137         BasicType bptype = basicType(ptype);
1138         if (arg instanceof Name) {
1139             Name n = (Name) arg;
1140             emitLoadInsn(n.type, n.index());
1141             emitImplicitConversion(n.type, ptype, n);
1142         } else if ((arg == null || arg instanceof String) && bptype == L_TYPE) {
1143             emitConst(arg);
1144         } else {
1145             if (Wrapper.isWrapperType(arg.getClass()) && bptype != L_TYPE) {
1146                 emitConst(arg);
1147             } else {
1148                 mv.visitLdcInsn(constantPlaceholder(arg));
1149                 emitImplicitConversion(L_TYPE, ptype, arg);
1150             }
1151         }
1152     }
1153 
1154     /**
1155      * Store the name to its local, if necessary.
1156      */
1157     private void emitStoreResult(Name name) {
1158         if (name != null && name.type != V_TYPE) {
1159             // non-void: actually assign
1160             emitStoreInsn(name.type, name.index());
1161         }
1162     }
1163 
1164     /**
1165      * Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.
1166      */
1167     private void emitReturn(Name onStack) {
1168         // return statement
1169         Class<?> rclass = invokerType.returnType();
1170         BasicType rtype = lambdaForm.returnType();
1171         assert(rtype == basicType(rclass));  // must agree
1172         if (rtype == V_TYPE) {
1173             // void
1174             mv.visitInsn(Opcodes.RETURN);
1175             // it doesn't matter what rclass is; the JVM will discard any value
1176         } else {
1177             LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
1178 
1179             // put return value on the stack if it is not already there
1180             if (rn != onStack) {
1181                 emitLoadInsn(rtype, lambdaForm.result);
1182             }
1183 
1184             emitImplicitConversion(rtype, rclass, rn);
1185 
1186             // generate actual return statement
1187             emitReturnInsn(rtype);
1188         }
1189     }
1190 
1191     /**
1192      * Emit a type conversion bytecode casting from "from" to "to".
1193      */
1194     private void emitPrimCast(Wrapper from, Wrapper to) {
1195         // Here's how.
1196         // -   indicates forbidden
1197         // <-> indicates implicit
1198         //      to ----> boolean  byte     short    char     int      long     float    double
1199         // from boolean    <->        -        -        -        -        -        -        -
1200         //      byte        -       <->       i2s      i2c      <->      i2l      i2f      i2d
1201         //      short       -       i2b       <->      i2c      <->      i2l      i2f      i2d
1202         //      char        -       i2b       i2s      <->      <->      i2l      i2f      i2d
1203         //      int         -       i2b       i2s      i2c      <->      i2l      i2f      i2d
1204         //      long        -     l2i,i2b   l2i,i2s  l2i,i2c    l2i      <->      l2f      l2d
1205         //      float       -     f2i,i2b   f2i,i2s  f2i,i2c    f2i      f2l      <->      f2d
1206         //      double      -     d2i,i2b   d2i,i2s  d2i,i2c    d2i      d2l      d2f      <->
1207         if (from == to) {
1208             // no cast required, should be dead code anyway
1209             return;
1210         }
1211         if (from.isSubwordOrInt()) {
1212             // cast from {byte,short,char,int} to anything
1213             emitI2X(to);
1214         } else {
1215             // cast from {long,float,double} to anything
1216             if (to.isSubwordOrInt()) {
1217                 // cast to {byte,short,char,int}
1218                 emitX2I(from);
1219                 if (to.bitWidth() < 32) {
1220                     // targets other than int require another conversion
1221                     emitI2X(to);
1222                 }
1223             } else {
1224                 // cast to {long,float,double} - this is verbose
1225                 boolean error = false;
1226                 switch (from) {
1227                 case LONG:
1228                     switch (to) {
1229                     case FLOAT:   mv.visitInsn(Opcodes.L2F);  break;
1230                     case DOUBLE:  mv.visitInsn(Opcodes.L2D);  break;
1231                     default:      error = true;               break;
1232                     }
1233                     break;
1234                 case FLOAT:
1235                     switch (to) {
1236                     case LONG :   mv.visitInsn(Opcodes.F2L);  break;
1237                     case DOUBLE:  mv.visitInsn(Opcodes.F2D);  break;
1238                     default:      error = true;               break;
1239                     }
1240                     break;
1241                 case DOUBLE:
1242                     switch (to) {
1243                     case LONG :   mv.visitInsn(Opcodes.D2L);  break;
1244                     case FLOAT:   mv.visitInsn(Opcodes.D2F);  break;
1245                     default:      error = true;               break;
1246                     }
1247                     break;
1248                 default:
1249                     error = true;
1250                     break;
1251                 }
1252                 if (error) {
1253                     throw new IllegalStateException("unhandled prim cast: " + from + "2" + to);
1254                 }
1255             }
1256         }
1257     }
1258 
1259     private void emitI2X(Wrapper type) {
1260         switch (type) {
1261         case BYTE:    mv.visitInsn(Opcodes.I2B);  break;
1262         case SHORT:   mv.visitInsn(Opcodes.I2S);  break;
1263         case CHAR:    mv.visitInsn(Opcodes.I2C);  break;
1264         case INT:     /* naught */                break;
1265         case LONG:    mv.visitInsn(Opcodes.I2L);  break;
1266         case FLOAT:   mv.visitInsn(Opcodes.I2F);  break;
1267         case DOUBLE:  mv.visitInsn(Opcodes.I2D);  break;
1268         case BOOLEAN:
1269             // For compatibility with ValueConversions and explicitCastArguments:
1270             mv.visitInsn(Opcodes.ICONST_1);
1271             mv.visitInsn(Opcodes.IAND);
1272             break;
1273         default:   throw new InternalError("unknown type: " + type);
1274         }
1275     }
1276 
1277     private void emitX2I(Wrapper type) {
1278         switch (type) {
1279         case LONG:    mv.visitInsn(Opcodes.L2I);  break;
1280         case FLOAT:   mv.visitInsn(Opcodes.F2I);  break;
1281         case DOUBLE:  mv.visitInsn(Opcodes.D2I);  break;
1282         default:      throw new InternalError("unknown type: " + type);
1283         }
1284     }
1285 
1286     /**
1287      * Generate bytecode for a LambdaForm.vmentry which calls interpretWithArguments.
1288      */
1289     static MemberName generateLambdaFormInterpreterEntryPoint(String sig) {
1290         assert(isValidSignature(sig));
1291         String name = "interpret_"+signatureReturn(sig).basicTypeChar();
1292         MethodType type = signatureType(sig);  // sig includes leading argument
1293         type = type.changeParameterType(0, MethodHandle.class);
1294         InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("LFI", name, type);
1295         return g.loadMethod(g.generateLambdaFormInterpreterEntryPointBytes());
1296     }
1297 
1298     private byte[] generateLambdaFormInterpreterEntryPointBytes() {
1299         classFilePrologue();
1300 
1301         // Suppress this method in backtraces displayed to the user.
1302         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
1303 
1304         // Don't inline the interpreter entry.
1305         mv.visitAnnotation("Ljava/lang/invoke/DontInline;", true);
1306 
1307         // create parameter array
1308         emitIconstInsn(invokerType.parameterCount());
1309         mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
1310 
1311         // fill parameter array
1312         for (int i = 0; i < invokerType.parameterCount(); i++) {
1313             Class<?> ptype = invokerType.parameterType(i);
1314             mv.visitInsn(Opcodes.DUP);
1315             emitIconstInsn(i);
1316             emitLoadInsn(basicType(ptype), i);
1317             // box if primitive type
1318             if (ptype.isPrimitive()) {
1319                 emitBoxing(Wrapper.forPrimitiveType(ptype));
1320             }
1321             mv.visitInsn(Opcodes.AASTORE);
1322         }
1323         // invoke
1324         emitAloadInsn(0);
1325         mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", "Ljava/lang/invoke/LambdaForm;");
1326         mv.visitInsn(Opcodes.SWAP);  // swap form and array; avoid local variable
1327         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, LF, "interpretWithArguments", "([Ljava/lang/Object;)Ljava/lang/Object;", false);
1328 
1329         // maybe unbox
1330         Class<?> rtype = invokerType.returnType();
1331         if (rtype.isPrimitive() && rtype != void.class) {
1332             emitUnboxing(Wrapper.forPrimitiveType(rtype));
1333         }
1334 
1335         // return statement
1336         emitReturnInsn(basicType(rtype));
1337 
1338         classFileEpilogue();
1339         bogusMethod(invokerType);
1340 
1341         final byte[] classFile = cw.toByteArray();
1342         maybeDump(className, classFile);
1343         return classFile;
1344     }
1345 
1346     /**
1347      * Generate bytecode for a NamedFunction invoker.
1348      */
1349     static MemberName generateNamedFunctionInvoker(MethodTypeForm typeForm) {
1350         MethodType invokerType = NamedFunction.INVOKER_METHOD_TYPE;
1351         String invokerName = "invoke_" + shortenSignature(basicTypeSignature(typeForm.erasedType()));
1352         InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("NFI", invokerName, invokerType);
1353         return g.loadMethod(g.generateNamedFunctionInvokerImpl(typeForm));
1354     }
1355 
1356     private byte[] generateNamedFunctionInvokerImpl(MethodTypeForm typeForm) {
1357         MethodType dstType = typeForm.erasedType();
1358         classFilePrologue();
1359 
1360         // Suppress this method in backtraces displayed to the user.
1361         mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
1362 
1363         // Force inlining of this invoker method.
1364         mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
1365 
1366         // Load receiver
1367         emitAloadInsn(0);
1368 
1369         // Load arguments from array
1370         for (int i = 0; i < dstType.parameterCount(); i++) {
1371             emitAloadInsn(1);
1372             emitIconstInsn(i);
1373             mv.visitInsn(Opcodes.AALOAD);
1374 
1375             // Maybe unbox
1376             Class<?> dptype = dstType.parameterType(i);
1377             if (dptype.isPrimitive()) {
1378                 Class<?> sptype = dstType.basicType().wrap().parameterType(i);
1379                 Wrapper dstWrapper = Wrapper.forBasicType(dptype);
1380                 Wrapper srcWrapper = dstWrapper.isSubwordOrInt() ? Wrapper.INT : dstWrapper;  // narrow subword from int
1381                 emitUnboxing(srcWrapper);
1382                 emitPrimCast(srcWrapper, dstWrapper);
1383             }
1384         }
1385 
1386         // Invoke
1387         String targetDesc = dstType.basicType().toMethodDescriptorString();
1388         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", targetDesc, false);
1389 
1390         // Box primitive types
1391         Class<?> rtype = dstType.returnType();
1392         if (rtype != void.class && rtype.isPrimitive()) {
1393             Wrapper srcWrapper = Wrapper.forBasicType(rtype);
1394             Wrapper dstWrapper = srcWrapper.isSubwordOrInt() ? Wrapper.INT : srcWrapper;  // widen subword to int
1395             // boolean casts not allowed
1396             emitPrimCast(srcWrapper, dstWrapper);
1397             emitBoxing(dstWrapper);
1398         }
1399 
1400         // If the return type is void we return a null reference.
1401         if (rtype == void.class) {
1402             mv.visitInsn(Opcodes.ACONST_NULL);
1403         }
1404         emitReturnInsn(L_TYPE);  // NOTE: NamedFunction invokers always return a reference value.
1405 
1406         classFileEpilogue();
1407         bogusMethod(dstType);
1408 
1409         final byte[] classFile = cw.toByteArray();
1410         maybeDump(className, classFile);
1411         return classFile;
1412     }
1413 
1414     /**
1415      * Emit a bogus method that just loads some string constants. This is to get the constants into the constant pool
1416      * for debugging purposes.
1417      */
1418     private void bogusMethod(Object... os) {
1419         if (DUMP_CLASS_FILES) {
1420             mv = cw.visitMethod(Opcodes.ACC_STATIC, "dummy", "()V", null, null);
1421             for (Object o : os) {
1422                 mv.visitLdcInsn(o.toString());
1423                 mv.visitInsn(Opcodes.POP);
1424             }
1425             mv.visitInsn(Opcodes.RETURN);
1426             mv.visitMaxs(0, 0);
1427             mv.visitEnd();
1428         }
1429     }
1430 }