--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/lang/invoke/InvokerBytecodeGenerator.java Tue Jul 24 10:47:44 2012 -0700
@@ -0,0 +1,1065 @@
+/*
+ * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.invoke;
+
+import sun.invoke.util.VerifyAccess;
+import java.lang.invoke.LambdaForm.Name;
+import java.lang.invoke.MethodHandles.Lookup;
+
+import sun.invoke.util.Wrapper;
+
+import java.io.*;
+import java.util.*;
+
+import com.sun.xml.internal.ws.org.objectweb.asm.*;
+
+import java.lang.reflect.*;
+import static java.lang.invoke.MethodHandleStatics.*;
+import static java.lang.invoke.MethodHandleNatives.Constants.*;
+import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
+import sun.invoke.util.ValueConversions;
+import sun.invoke.util.VerifyType;
+
+/**
+ * Code generation backend for LambdaForm.
+ * <p>
+ * @author John Rose, JSR 292 EG
+ */
+class InvokerBytecodeGenerator {
+ /** Define class names for convenience. */
+ private static final String MH = "java/lang/invoke/MethodHandle";
+ private static final String BMH = "java/lang/invoke/BoundMethodHandle";
+ private static final String LF = "java/lang/invoke/LambdaForm";
+ private static final String LFN = "java/lang/invoke/LambdaForm$Name";
+ private static final String CLS = "java/lang/Class";
+ private static final String OBJ = "java/lang/Object";
+ private static final String OBJARY = "[Ljava/lang/Object;";
+
+ private static final String LF_SIG = "L" + LF + ";";
+ private static final String LFN_SIG = "L" + LFN + ";";
+ private static final String LL_SIG = "(L" + OBJ + ";)L" + OBJ + ";";
+
+ /** Name of its super class*/
+ private static final String superName = LF;
+
+ /** Name of new class */
+ private final String className;
+
+ /** Name of the source file (for stack trace printing). */
+ private final String sourceFile;
+
+ private final LambdaForm lambdaForm;
+ private final String invokerName;
+ private final MethodType invokerType;
+ private final int[] localsMap;
+
+ /** ASM bytecode generation. */
+ private ClassWriter cw;
+ private MethodVisitor mv;
+
+ private static final MemberName.Factory MEMBERNAME_FACTORY = MemberName.getFactory();
+ private static final Class<?> HOST_CLASS = LambdaForm.class;
+
+ private InvokerBytecodeGenerator(LambdaForm lambdaForm, int localsMapSize,
+ String className, String invokerName, MethodType invokerType) {
+ if (invokerName.contains(".")) {
+ int p = invokerName.indexOf(".");
+ className = invokerName.substring(0, p);
+ invokerName = invokerName.substring(p+1);
+ }
+ if (DUMP_CLASS_FILES) {
+ className = makeDumpableClassName(className);
+ }
+ this.className = superName + "$" + className;
+ this.sourceFile = "LambdaForm$" + className;
+ this.lambdaForm = lambdaForm;
+ this.invokerName = invokerName;
+ this.invokerType = invokerType;
+ this.localsMap = new int[localsMapSize];
+ }
+
+ private InvokerBytecodeGenerator(String className, String invokerName, MethodType invokerType) {
+ this(null, invokerType.parameterCount(),
+ className, invokerName, invokerType);
+ // Create an array to map name indexes to locals indexes.
+ for (int i = 0; i < localsMap.length; i++) {
+ localsMap[i] = invokerType.parameterSlotCount() - invokerType.parameterSlotDepth(i);
+ }
+ }
+
+ private InvokerBytecodeGenerator(String className, LambdaForm form, MethodType invokerType) {
+ this(form, form.names.length,
+ className, form.debugName, invokerType);
+ // Create an array to map name indexes to locals indexes.
+ Name[] names = form.names;
+ for (int i = 0, index = 0; i < localsMap.length; i++) {
+ localsMap[i] = index;
+ index += Wrapper.forBasicType(names[i].type).stackSlots();
+ }
+ }
+
+
+ /** instance counters for dumped classes */
+ private final static HashMap<String,Integer> DUMP_CLASS_FILES_COUNTERS;
+ /** debugging flag for saving generated class files */
+ private final static File DUMP_CLASS_FILES_DIR;
+
+ static {
+ if (DUMP_CLASS_FILES) {
+ DUMP_CLASS_FILES_COUNTERS = new HashMap<>();
+ try {
+ File dumpDir = new File("DUMP_CLASS_FILES");
+ if (!dumpDir.exists()) {
+ dumpDir.mkdirs();
+ }
+ DUMP_CLASS_FILES_DIR = dumpDir;
+ System.out.println("Dumping class files to "+DUMP_CLASS_FILES_DIR+"/...");
+ } catch (Exception e) {
+ throw new InternalError(e);
+ }
+ } else {
+ DUMP_CLASS_FILES_COUNTERS = null;
+ DUMP_CLASS_FILES_DIR = null;
+ }
+ }
+
+ static void maybeDump(final String className, final byte[] classFile) {
+ if (DUMP_CLASS_FILES) {
+ System.out.println("dump: " + className);
+ java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction<Void>() {
+ public Void run() {
+ try {
+ String dumpName = className;
+ //dumpName = dumpName.replace('/', '-');
+ File dumpFile = new File(DUMP_CLASS_FILES_DIR, dumpName+".class");
+ dumpFile.getParentFile().mkdirs();
+ FileOutputStream file = new FileOutputStream(dumpFile);
+ file.write(classFile);
+ file.close();
+ return null;
+ } catch (IOException ex) {
+ throw new InternalError(ex);
+ }
+ }
+ });
+ }
+
+ }
+
+ private static String makeDumpableClassName(String className) {
+ Integer ctr;
+ synchronized (DUMP_CLASS_FILES_COUNTERS) {
+ ctr = DUMP_CLASS_FILES_COUNTERS.get(className);
+ if (ctr == null) ctr = 0;
+ DUMP_CLASS_FILES_COUNTERS.put(className, ctr+1);
+ }
+ String sfx = ctr.toString();
+ while (sfx.length() < 3)
+ sfx = "0"+sfx;
+ className += sfx;
+ return className;
+ }
+
+ class CpPatch {
+ int index;
+ Object value;
+ CpPatch(int index, Object value) {
+ this.index = index;
+ this.value = value;
+ }
+ }
+
+ Map<Object, CpPatch> cpPatches = new HashMap<>();
+
+ int cph = 0; // for counting constant placeholders
+
+ String constantPlaceholder(Object arg) {
+ String cpPlaceholder = "CONSTANT_PLACEHOLDER_" + cph++;
+ if (DUMP_CLASS_FILES) cpPlaceholder += " <<" + arg.toString() + ">>"; // debugging aid
+ if (cpPatches.containsKey(cpPlaceholder)) {
+ throw new InternalError("observed CP placeholder twice: " + cpPlaceholder);
+ }
+ // insert placeholder in CP and remember the patch
+ int index = cw.newConst((Object) cpPlaceholder); // TODO check if aready in the constant pool
+ cpPatches.put(cpPlaceholder, new CpPatch(index, arg));
+ return cpPlaceholder;
+ }
+
+ Object[] cpPatches(byte[] classFile) {
+ int size = getConstantPoolSize(classFile);
+ Object[] res = new Object[size];
+ for (CpPatch p : cpPatches.values()) {
+ res[p.index] = p.value;
+ }
+ return res;
+ }
+
+ /**
+ * Extract the number of constant pool entries from a given class file.
+ *
+ * @param classFile the bytes of the class file in question.
+ * @return the number of entries in the constant pool.
+ */
+ private static int getConstantPoolSize(byte[] classFile) {
+ // The first few bytes:
+ // u4 magic;
+ // u2 minor_version;
+ // u2 major_version;
+ // u2 constant_pool_count;
+ return ((classFile[8] << 8) & 0xFF) | ( classFile[9] & 0xFF);
+ }
+
+ /**
+ * Extract the MemberName of a newly-defined method.
+ *
+ * @param classFile
+ * @return
+ */
+ private MemberName loadMethod(byte[] classFile) {
+ Class<?> invokerClass = loadAndInitializeInvokerClass(classFile, cpPatches(classFile));
+ return resolveInvokerMember(invokerClass, invokerName, invokerType);
+ }
+
+ /**
+ * Define a given class as anonymous class in the runtime system.
+ *
+ * @param classBytes
+ * @param patches
+ * @return
+ */
+ private static Class<?> loadAndInitializeInvokerClass(byte[] classBytes, Object[] patches) {
+ Class<?> invokerClass = UNSAFE.defineAnonymousClass(HOST_CLASS, classBytes, patches);
+ UNSAFE.ensureClassInitialized(invokerClass); // Make sure the class is initialized; VM might complain.
+ return invokerClass;
+ }
+
+ /**
+ * TODO
+ *
+ * @param invokerClass
+ * @param name
+ * @param type
+ * @return
+ */
+ private static MemberName resolveInvokerMember(Class<?> invokerClass, String name, MethodType type) {
+ MemberName member = new MemberName(invokerClass, name, type, REF_invokeStatic);
+ //System.out.println("resolveInvokerMember => "+member);
+ //for (Method m : invokerClass.getDeclaredMethods()) System.out.println(" "+m);
+ try {
+ member = MEMBERNAME_FACTORY.resolveOrFail(REF_invokeStatic, member, HOST_CLASS, ReflectiveOperationException.class);
+ } catch (ReflectiveOperationException e) {
+ throw new InternalError(e);
+ }
+ //System.out.println("resolveInvokerMember => "+member);
+ return member;
+ }
+
+ /**
+ * Set up class file generation.
+ */
+ private void classFilePrologue() {
+ cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
+ cw.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, className, null, superName, null);
+ cw.visitSource(sourceFile, null);
+
+ String invokerDesc = invokerType.toMethodDescriptorString();
+ mv = cw.visitMethod(Opcodes.ACC_STATIC, invokerName, invokerDesc, null, null);
+
+ // Force inlining of this invoker method.
+ mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
+ }
+
+ /**
+ * Tear down class file generation.
+ */
+ private void classFileEpilogue() {
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ }
+
+ /*
+ * Low-level emit helpers.
+ */
+ private void emitConst(Object con) {
+ if (con == null) {
+ mv.visitInsn(Opcodes.ACONST_NULL);
+ return;
+ }
+ if (con instanceof Integer) {
+ emitIconstInsn((int) con);
+ return;
+ }
+ if (con instanceof Long) {
+ long x = (long) con;
+ if (x == (short) x) {
+ emitIconstInsn((int) x);
+ mv.visitInsn(Opcodes.I2L);
+ return;
+ }
+ }
+ if (con instanceof Float) {
+ float x = (float) con;
+ if (x == (short) x) {
+ emitIconstInsn((int) x);
+ mv.visitInsn(Opcodes.I2F);
+ return;
+ }
+ }
+ if (con instanceof Double) {
+ double x = (double) con;
+ if (x == (short) x) {
+ emitIconstInsn((int) x);
+ mv.visitInsn(Opcodes.I2D);
+ return;
+ }
+ }
+ if (con instanceof Boolean) {
+ emitIconstInsn((boolean) con ? 1 : 0);
+ return;
+ }
+ // fall through:
+ mv.visitLdcInsn(con);
+ }
+
+ private void emitIconstInsn(int i) {
+ int opcode;
+ switch (i) {
+ case 0: opcode = Opcodes.ICONST_0; break;
+ case 1: opcode = Opcodes.ICONST_1; break;
+ case 2: opcode = Opcodes.ICONST_2; break;
+ case 3: opcode = Opcodes.ICONST_3; break;
+ case 4: opcode = Opcodes.ICONST_4; break;
+ case 5: opcode = Opcodes.ICONST_5; break;
+ default:
+ if (i == (byte) i) {
+ mv.visitIntInsn(Opcodes.BIPUSH, i & 0xFF);
+ } else if (i == (short) i) {
+ mv.visitIntInsn(Opcodes.SIPUSH, (char) i);
+ } else {
+ mv.visitLdcInsn(i);
+ }
+ return;
+ }
+ mv.visitInsn(opcode);
+ }
+
+ /*
+ * NOTE: These load/store methods use the localsMap to find the correct index!
+ */
+ private void emitLoadInsn(char type, int index) {
+ int opcode;
+ switch (type) {
+ case 'I': opcode = Opcodes.ILOAD; break;
+ case 'J': opcode = Opcodes.LLOAD; break;
+ case 'F': opcode = Opcodes.FLOAD; break;
+ case 'D': opcode = Opcodes.DLOAD; break;
+ case 'L': opcode = Opcodes.ALOAD; break;
+ default:
+ throw new InternalError("unknown type: " + type);
+ }
+ mv.visitVarInsn(opcode, localsMap[index]);
+ }
+ private void emitAloadInsn(int index) {
+ emitLoadInsn('L', index);
+ }
+
+ private void emitStoreInsn(char type, int index) {
+ int opcode;
+ switch (type) {
+ case 'I': opcode = Opcodes.ISTORE; break;
+ case 'J': opcode = Opcodes.LSTORE; break;
+ case 'F': opcode = Opcodes.FSTORE; break;
+ case 'D': opcode = Opcodes.DSTORE; break;
+ case 'L': opcode = Opcodes.ASTORE; break;
+ default:
+ throw new InternalError("unknown type: " + type);
+ }
+ mv.visitVarInsn(opcode, localsMap[index]);
+ }
+ private void emitAstoreInsn(int index) {
+ emitStoreInsn('L', index);
+ }
+
+ /**
+ * Emit a boxing call.
+ *
+ * @param type primitive type class to box.
+ */
+ private void emitBoxing(Class<?> type) {
+ Wrapper wrapper = Wrapper.forPrimitiveType(type);
+ String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
+ String name = "valueOf";
+ String desc = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
+ mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc);
+ }
+
+ /**
+ * Emit an unboxing call (plus preceding checkcast).
+ *
+ * @param type wrapper type class to unbox.
+ */
+ private void emitUnboxing(Class<?> type) {
+ Wrapper wrapper = Wrapper.forWrapperType(type);
+ String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
+ String name = wrapper.primitiveSimpleName() + "Value";
+ String desc = "()" + wrapper.basicTypeChar();
+ mv.visitTypeInsn(Opcodes.CHECKCAST, owner);
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc);
+ }
+
+ /**
+ * Emit an implicit conversion.
+ *
+ * @param ptype type of value present on stack
+ * @param pclass type of value required on stack
+ */
+ private void emitImplicitConversion(char ptype, Class<?> pclass) {
+ switch (ptype) {
+ case 'L':
+ if (VerifyType.isNullConversion(Object.class, pclass))
+ return;
+ if (isStaticallyNameable(pclass)) {
+ mv.visitTypeInsn(Opcodes.CHECKCAST, getInternalName(pclass));
+ } else {
+ mv.visitLdcInsn(constantPlaceholder(pclass));
+ mv.visitTypeInsn(Opcodes.CHECKCAST, CLS);
+ mv.visitInsn(Opcodes.SWAP);
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CLS, "cast", LL_SIG);
+ if (pclass.isArray())
+ mv.visitTypeInsn(Opcodes.CHECKCAST, OBJARY);
+ }
+ return;
+ case 'I':
+ if (!VerifyType.isNullConversion(int.class, pclass))
+ emitPrimCast(ptype, Wrapper.basicTypeChar(pclass));
+ return;
+ case 'J':
+ assert(pclass == long.class);
+ return;
+ case 'F':
+ assert(pclass == float.class);
+ return;
+ case 'D':
+ assert(pclass == double.class);
+ return;
+ }
+ throw new InternalError("bad implicit conversion: tc="+ptype+": "+pclass);
+ }
+
+ /**
+ * Emits an actual return instruction conforming to the given return type.
+ */
+ private void emitReturnInsn(Class<?> type) {
+ int opcode;
+ switch (Wrapper.basicTypeChar(type)) {
+ case 'I': opcode = Opcodes.IRETURN; break;
+ case 'J': opcode = Opcodes.LRETURN; break;
+ case 'F': opcode = Opcodes.FRETURN; break;
+ case 'D': opcode = Opcodes.DRETURN; break;
+ case 'L': opcode = Opcodes.ARETURN; break;
+ case 'V': opcode = Opcodes.RETURN; break;
+ default:
+ throw new InternalError("unknown return type: " + type);
+ }
+ mv.visitInsn(opcode);
+ }
+
+ private static String getInternalName(Class<?> c) {
+ assert(VerifyAccess.isTypeVisible(c, Object.class));
+ return c.getName().replace('.', '/');
+ }
+
+ /**
+ * Generate customized bytecode for a given LambdaForm.
+ *
+ * @param form
+ * @param invokerType
+ * @return
+ */
+ static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) {
+ InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("MH", form, invokerType);
+ return g.loadMethod(g.generateCustomizedCodeBytes());
+ }
+
+ /**
+ * Generate an invoker method for the passed {@link LambdaForm}.
+ */
+ private byte[] generateCustomizedCodeBytes() {
+ classFilePrologue();
+
+ // Suppress this method in backtraces displayed to the user.
+ mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
+
+ // Mark this method as a compiled LambdaForm
+ mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Compiled;", true);
+
+ // iterate over the form's names, generating bytecode instructions for each
+ // start iterating at the first name following the arguments
+ for (int i = lambdaForm.arity; i < lambdaForm.names.length; i++) {
+ Name name = lambdaForm.names[i];
+ MemberName member = name.function.member();
+
+ if (isSelectAlternative(member)) {
+ // selectAlternative idiom
+ // FIXME: make sure this idiom is really present!
+ emitSelectAlternative(name, lambdaForm.names[i + 1]);
+ i++; // skip MH.invokeBasic of the selectAlternative result
+ } else if (isStaticallyInvocable(member)) {
+ emitStaticInvoke(member, name);
+ } else {
+ emitInvoke(name);
+ }
+
+ // store the result from evaluating to the target name in a local if required
+ // (if this is the last value, i.e., the one that is going to be returned,
+ // avoid store/load/return and just return)
+ if (i == lambdaForm.names.length - 1 && i == lambdaForm.result) {
+ // return value - do nothing
+ } else if (name.type != 'V') {
+ // non-void: actually assign
+ emitStoreInsn(name.type, name.index());
+ }
+ }
+
+ // return statement
+ emitReturn();
+
+ classFileEpilogue();
+ bogusMethod(lambdaForm);
+
+ final byte[] classFile = cw.toByteArray();
+ maybeDump(className, classFile);
+ return classFile;
+ }
+
+ /**
+ * Emit an invoke for the given name.
+ *
+ * @param name
+ */
+ void emitInvoke(Name name) {
+ if (true) {
+ // push receiver
+ MethodHandle target = name.function.resolvedHandle;
+ assert(target != null) : name.exprString();
+ mv.visitLdcInsn(constantPlaceholder(target));
+ mv.visitTypeInsn(Opcodes.CHECKCAST, MH);
+ } else {
+ // load receiver
+ emitAloadInsn(0);
+ mv.visitTypeInsn(Opcodes.CHECKCAST, MH);
+ mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", LF_SIG);
+ mv.visitFieldInsn(Opcodes.GETFIELD, LF, "names", LFN_SIG);
+ // TODO more to come
+ }
+
+ // push arguments
+ for (int i = 0; i < name.arguments.length; i++) {
+ emitPushArgument(name, i);
+ }
+
+ // invocation
+ MethodType type = name.function.methodType();
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString());
+ }
+
+ static private Class<?>[] STATICALLY_INVOCABLE_PACKAGES = {
+ // Sample classes from each package we are willing to bind to statically:
+ java.lang.Object.class,
+ java.util.Arrays.class,
+ sun.misc.Unsafe.class
+ //MethodHandle.class already covered
+ };
+
+ static boolean isStaticallyInvocable(MemberName member) {
+ if (member == null) return false;
+ if (member.isConstructor()) return false;
+ Class<?> cls = member.getDeclaringClass();
+ if (cls.isArray() || cls.isPrimitive())
+ return false; // FIXME
+ if (cls.isAnonymousClass() || cls.isLocalClass())
+ return false; // inner class of some sort
+ if (cls.getClassLoader() != MethodHandle.class.getClassLoader())
+ return false; // not on BCP
+ if (!member.isPrivate() && VerifyAccess.isSamePackage(MethodHandle.class, cls))
+ return true; // in java.lang.invoke package
+ if (member.isPublic() && isStaticallyNameable(cls))
+ return true;
+ return false;
+ }
+
+ static boolean isStaticallyNameable(Class<?> cls) {
+ while (cls.isArray())
+ cls = cls.getComponentType();
+ if (cls.isPrimitive())
+ return true; // int[].class, for example
+ if (cls.getClassLoader() != Object.class.getClassLoader())
+ return false;
+ if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
+ return true;
+ if (!Modifier.isPublic(cls.getModifiers()))
+ return false;
+ for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
+ if (VerifyAccess.isSamePackage(pkgcls, cls))
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Emit an invoke for the given name, using the MemberName directly.
+ *
+ * @param name
+ */
+ void emitStaticInvoke(MemberName member, Name name) {
+ assert(member.equals(name.function.member()));
+ String cname = getInternalName(member.getDeclaringClass());
+ String mname = member.getName();
+ String mtype;
+ byte refKind = member.getReferenceKind();
+ if (refKind == REF_invokeSpecial) {
+ // in order to pass the verifier, we need to convert this to invokevirtual in all cases
+ assert(member.canBeStaticallyBound()) : member;
+ refKind = REF_invokeVirtual;
+ }
+
+ // push arguments
+ for (int i = 0; i < name.arguments.length; i++) {
+ emitPushArgument(name, i);
+ }
+
+ // invocation
+ if (member.isMethod()) {
+ mtype = member.getMethodType().toMethodDescriptorString();
+ mv.visitMethodInsn(refKindOpcode(refKind), cname, mname, mtype);
+ } else {
+ mtype = MethodType.toFieldDescriptorString(member.getFieldType());
+ mv.visitFieldInsn(refKindOpcode(refKind), cname, mname, mtype);
+ }
+ }
+ int refKindOpcode(byte refKind) {
+ switch (refKind) {
+ case REF_invokeVirtual: return Opcodes.INVOKEVIRTUAL;
+ case REF_invokeStatic: return Opcodes.INVOKESTATIC;
+ case REF_invokeSpecial: return Opcodes.INVOKESPECIAL;
+ case REF_invokeInterface: return Opcodes.INVOKEINTERFACE;
+ case REF_getField: return Opcodes.GETFIELD;
+ case REF_putField: return Opcodes.PUTFIELD;
+ case REF_getStatic: return Opcodes.GETSTATIC;
+ case REF_putStatic: return Opcodes.PUTSTATIC;
+ }
+ throw new InternalError("refKind="+refKind);
+ }
+
+ /**
+ * Check if MemberName is a call to MethodHandleImpl.selectAlternative.
+ *
+ * @param member
+ * @return true if member is a call to MethodHandleImpl.selectAlternative
+ */
+ private boolean isSelectAlternative(MemberName member) {
+ return member != null &&
+ member.getDeclaringClass() == MethodHandleImpl.class &&
+ member.getName().equals("selectAlternative");
+ }
+
+ /**
+ * Emit bytecode for the selectAlternative idiom.
+ *
+ * The pattern looks like (Cf. MethodHandleImpl.makeGuardWithTest):
+ *
+ * Lambda(a0:L,a1:I)=>{
+ * t2:I=foo.test(a1:I);
+ * t3:L=MethodHandleImpl.selectAlternative(t2:I,(MethodHandle(int)int),(MethodHandle(int)int));
+ * t4:I=MethodHandle.invokeBasic(t3:L,a1:I);t4:I}
+ *
+ * @param selectAlternativeName
+ * @param invokeBasicName
+ */
+ private void emitSelectAlternative(Name selectAlternativeName, Name invokeBasicName) {
+ MethodType type = selectAlternativeName.function.methodType();
+
+ Name receiver = (Name) invokeBasicName.arguments[0];
+
+ Label L_fallback = new Label();
+ Label L_done = new Label();
+
+ // load test result
+ emitPushArgument(selectAlternativeName, 0);
+ mv.visitInsn(Opcodes.ICONST_1);
+
+ // if_icmpne L_fallback
+ mv.visitJumpInsn(Opcodes.IF_ICMPNE, L_fallback);
+
+ // invoke selectAlternativeName.arguments[1]
+ MethodHandle target = (MethodHandle) selectAlternativeName.arguments[1];
+ emitPushArgument(selectAlternativeName, 1); // get 2nd argument of selectAlternative
+ emitAstoreInsn(receiver.index()); // store the MH in the receiver slot
+ emitInvoke(invokeBasicName);
+
+ // goto L_done
+ mv.visitJumpInsn(Opcodes.GOTO, L_done);
+
+ // L_fallback:
+ mv.visitLabel(L_fallback);
+
+ // invoke selectAlternativeName.arguments[2]
+ MethodHandle fallback = (MethodHandle) selectAlternativeName.arguments[2];
+ emitPushArgument(selectAlternativeName, 2); // get 3rd argument of selectAlternative
+ emitAstoreInsn(receiver.index()); // store the MH in the receiver slot
+ emitInvoke(invokeBasicName);
+
+ // L_done:
+ mv.visitLabel(L_done);
+ }
+
+ /**
+ *
+ * @param name
+ * @param paramIndex
+ */
+ private void emitPushArgument(Name name, int paramIndex) {
+ Object arg = name.arguments[paramIndex];
+ char ptype = name.function.parameterType(paramIndex);
+ MethodType mtype = name.function.methodType();
+ if (arg instanceof Name) {
+ Name n = (Name) arg;
+ emitLoadInsn(n.type, n.index());
+ emitImplicitConversion(n.type, mtype.parameterType(paramIndex));
+ } else if ((arg == null || arg instanceof String) && ptype == 'L') {
+ emitConst(arg);
+ } else {
+ if (Wrapper.isWrapperType(arg.getClass()) && ptype != 'L') {
+ emitConst(arg);
+ } else {
+ mv.visitLdcInsn(constantPlaceholder(arg));
+ emitImplicitConversion('L', mtype.parameterType(paramIndex));
+ }
+ }
+ }
+
+ /**
+ * Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.
+ */
+ private void emitReturn() {
+ // return statement
+ if (lambdaForm.result == -1) {
+ // void
+ mv.visitInsn(Opcodes.RETURN);
+ } else {
+ LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
+ char rtype = Wrapper.basicTypeChar(invokerType.returnType());
+
+ // put return value on the stack if it is not already there
+ if (lambdaForm.result != lambdaForm.names.length - 1) {
+ emitLoadInsn(rn.type, lambdaForm.result);
+ }
+
+ // potentially generate cast
+ // rtype is the return type of the invoker - generated code must conform to this
+ // rn.type is the type of the result Name in the LF
+ if (rtype != rn.type) {
+ // need cast
+ if (rtype == 'L') {
+ // possibly cast the primitive to the correct type for boxing
+ char boxedType = Wrapper.forWrapperType(invokerType.returnType()).basicTypeChar();
+ if (boxedType != rn.type) {
+ emitPrimCast(rn.type, boxedType);
+ }
+ // cast primitive to reference ("boxing")
+ emitBoxing(invokerType.returnType());
+ } else {
+ // to-primitive cast
+ if (rn.type != 'L') {
+ // prim-to-prim cast
+ emitPrimCast(rn.type, rtype);
+ } else {
+ // ref-to-prim cast ("unboxing")
+ throw new InternalError("no ref-to-prim (unboxing) casts supported right now");
+ }
+ }
+ }
+
+ // generate actual return statement
+ emitReturnInsn(invokerType.returnType());
+ }
+ }
+
+ /**
+ * Emit a type conversion bytecode casting from "from" to "to".
+ */
+ private void emitPrimCast(char from, char to) {
+ // Here's how.
+ // - indicates forbidden
+ // <-> indicates implicit
+ // to ----> boolean byte short char int long float double
+ // from boolean <-> - - - - - - -
+ // byte - <-> i2s i2c <-> i2l i2f i2d
+ // short - i2b <-> i2c <-> i2l i2f i2d
+ // char - i2b i2s <-> <-> i2l i2f i2d
+ // int - i2b i2s i2c <-> i2l i2f i2d
+ // long - l2i,i2b l2i,i2s l2i,i2c l2i <-> l2f l2d
+ // float - f2i,i2b f2i,i2s f2i,i2c f2i f2l <-> f2d
+ // double - d2i,i2b d2i,i2s d2i,i2c d2i d2l d2f <->
+ if (from == to) {
+ // no cast required, should be dead code anyway
+ return;
+ }
+ Wrapper wfrom = Wrapper.forBasicType(from);
+ Wrapper wto = Wrapper.forBasicType(to);
+ if (wfrom.isSubwordOrInt()) {
+ // cast from {byte,short,char,int} to anything
+ emitI2X(to);
+ } else {
+ // cast from {long,float,double} to anything
+ if (wto.isSubwordOrInt()) {
+ // cast to {byte,short,char,int}
+ emitX2I(from);
+ if (wto.bitWidth() < 32) {
+ // targets other than int require another conversion
+ emitI2X(to);
+ }
+ } else {
+ // cast to {long,float,double} - this is verbose
+ boolean error = false;
+ switch (from) {
+ case 'J':
+ if (to == 'F') { mv.visitInsn(Opcodes.L2F); }
+ else if (to == 'D') { mv.visitInsn(Opcodes.L2D); }
+ else error = true;
+ break;
+ case 'F':
+ if (to == 'J') { mv.visitInsn(Opcodes.F2L); }
+ else if (to == 'D') { mv.visitInsn(Opcodes.F2D); }
+ else error = true;
+ break;
+ case 'D':
+ if (to == 'J') { mv.visitInsn(Opcodes.D2L); }
+ else if (to == 'F') { mv.visitInsn(Opcodes.D2F); }
+ else error = true;
+ break;
+ default:
+ error = true;
+ break;
+ }
+ if (error) {
+ throw new IllegalStateException("unhandled prim cast: " + from + "2" + to);
+ }
+ }
+ }
+ }
+
+ private void emitI2X(char type) {
+ switch (type) {
+ case 'B': mv.visitInsn(Opcodes.I2B); break;
+ case 'S': mv.visitInsn(Opcodes.I2S); break;
+ case 'C': mv.visitInsn(Opcodes.I2C); break;
+ case 'I': /* naught */ break;
+ case 'J': mv.visitInsn(Opcodes.I2L); break;
+ case 'F': mv.visitInsn(Opcodes.I2F); break;
+ case 'D': mv.visitInsn(Opcodes.I2D); break;
+ case 'Z':
+ // For compatibility with ValueConversions and explicitCastArguments:
+ mv.visitInsn(Opcodes.ICONST_1);
+ mv.visitInsn(Opcodes.IAND);
+ break;
+ default: throw new InternalError("unknown type: " + type);
+ }
+ }
+
+ private void emitX2I(char type) {
+ switch (type) {
+ case 'J': mv.visitInsn(Opcodes.L2I); break;
+ case 'F': mv.visitInsn(Opcodes.F2I); break;
+ case 'D': mv.visitInsn(Opcodes.D2I); break;
+ default: throw new InternalError("unknown type: " + type);
+ }
+ }
+
+ private static String basicTypeCharSignature(String prefix, MethodType type) {
+ StringBuilder buf = new StringBuilder(prefix);
+ for (Class<?> ptype : type.parameterList())
+ buf.append(Wrapper.forBasicType(ptype).basicTypeChar());
+ buf.append('_').append(Wrapper.forBasicType(type.returnType()).basicTypeChar());
+ return buf.toString();
+ }
+
+ /**
+ * Generate bytecode for a LambdaForm.vmentry which calls interpretWithArguments.
+ *
+ * @param sig
+ * @return
+ */
+ static MemberName generateLambdaFormInterpreterEntryPoint(String sig) {
+ assert(LambdaForm.isValidSignature(sig));
+ //System.out.println("generateExactInvoker "+sig);
+ // compute method type
+ // first parameter and return type
+ char tret = LambdaForm.signatureReturn(sig);
+ MethodType type = MethodType.methodType(LambdaForm.typeClass(tret), MethodHandle.class);
+ // other parameter types
+ int arity = LambdaForm.signatureArity(sig);
+ for (int i = 1; i < arity; i++) {
+ type = type.appendParameterTypes(LambdaForm.typeClass(sig.charAt(i)));
+ }
+ InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("LFI", "interpret_"+tret, type);
+ return g.loadMethod(g.generateLambdaFormInterpreterEntryPointBytes());
+ }
+
+ private byte[] generateLambdaFormInterpreterEntryPointBytes() {
+ classFilePrologue();
+
+ // Suppress this method in backtraces displayed to the user.
+ mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
+
+ // create parameter array
+ emitIconstInsn(invokerType.parameterCount());
+ mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
+
+ // fill parameter array
+ for (int i = 0; i < invokerType.parameterCount(); i++) {
+ Class<?> ptype = invokerType.parameterType(i);
+ mv.visitInsn(Opcodes.DUP);
+ emitIconstInsn(i);
+ emitLoadInsn(Wrapper.basicTypeChar(ptype), i);
+ // box if primitive type
+ if (ptype.isPrimitive()) {
+ emitBoxing(ptype);
+ }
+ mv.visitInsn(Opcodes.AASTORE);
+ }
+ // invoke
+ emitAloadInsn(0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", "Ljava/lang/invoke/LambdaForm;");
+ mv.visitInsn(Opcodes.SWAP); // swap form and array; avoid local variable
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, LF, "interpretWithArguments", "([Ljava/lang/Object;)Ljava/lang/Object;");
+
+ // maybe unbox
+ Class<?> rtype = invokerType.returnType();
+ if (rtype.isPrimitive() && rtype != void.class) {
+ emitUnboxing(Wrapper.asWrapperType(rtype));
+ }
+
+ // return statement
+ emitReturnInsn(rtype);
+
+ classFileEpilogue();
+ bogusMethod(invokerType);
+
+ final byte[] classFile = cw.toByteArray();
+ maybeDump(className, classFile);
+ return classFile;
+ }
+
+ /**
+ * Generate bytecode for a NamedFunction invoker.
+ *
+ * @param srcType
+ * @param dstType
+ * @return
+ */
+ static MemberName generateNamedFunctionInvoker(MethodTypeForm typeForm) {
+ MethodType invokerType = LambdaForm.NamedFunction.INVOKER_METHOD_TYPE;
+ String invokerName = basicTypeCharSignature("invoke_", typeForm.erasedType());
+ InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("NFI", invokerName, invokerType);
+ return g.loadMethod(g.generateNamedFunctionInvokerImpl(typeForm));
+ }
+
+ static int nfi = 0;
+
+ private byte[] generateNamedFunctionInvokerImpl(MethodTypeForm typeForm) {
+ MethodType dstType = typeForm.erasedType();
+ classFilePrologue();
+
+ // Suppress this method in backtraces displayed to the user.
+ mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
+
+ // Load receiver
+ emitAloadInsn(0);
+
+ // Load arguments from array
+ for (int i = 0; i < dstType.parameterCount(); i++) {
+ emitAloadInsn(1);
+ emitIconstInsn(i);
+ mv.visitInsn(Opcodes.AALOAD);
+
+ // Maybe unbox
+ Class<?> dptype = dstType.parameterType(i);
+ if (dptype.isPrimitive()) {
+ Class<?> sptype = dstType.basicType().wrap().parameterType(i);
+ Wrapper dstWrapper = Wrapper.forBasicType(dptype);
+ Wrapper srcWrapper = dstWrapper.isSubwordOrInt() ? Wrapper.INT : dstWrapper; // narrow subword from int
+ emitUnboxing(srcWrapper.wrapperType());
+ emitPrimCast(srcWrapper.basicTypeChar(), dstWrapper.basicTypeChar());
+ }
+ }
+
+ // Invoke
+ String targetDesc = dstType.basicType().toMethodDescriptorString();
+ mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", targetDesc);
+
+ // Box primitive types
+ Class<?> rtype = dstType.returnType();
+ if (rtype != void.class && rtype.isPrimitive()) {
+ Wrapper srcWrapper = Wrapper.forBasicType(rtype);
+ Wrapper dstWrapper = srcWrapper.isSubwordOrInt() ? Wrapper.INT : srcWrapper; // widen subword to int
+ // boolean casts not allowed
+ emitPrimCast(srcWrapper.basicTypeChar(), dstWrapper.basicTypeChar());
+ emitBoxing(dstWrapper.primitiveType());
+ }
+
+ // If the return type is void we return a null reference.
+ if (rtype == void.class) {
+ mv.visitInsn(Opcodes.ACONST_NULL);
+ }
+ emitReturnInsn(Object.class); // NOTE: NamedFunction invokers always return a reference value.
+
+ classFileEpilogue();
+ bogusMethod(dstType);
+
+ final byte[] classFile = cw.toByteArray();
+ maybeDump(className, classFile);
+ return classFile;
+ }
+
+ /**
+ * Emit a bogus method that just loads some string constants. This is to get the constants into the constant pool
+ * for debugging purposes.
+ */
+ private void bogusMethod(Object... os) {
+ if (DUMP_CLASS_FILES) {
+ mv = cw.visitMethod(Opcodes.ACC_STATIC, "dummy", "()V", null, null);
+ for (Object o : os) {
+ mv.visitLdcInsn(o.toString());
+ mv.visitInsn(Opcodes.POP);
+ }
+ mv.visitInsn(Opcodes.RETURN);
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+ }
+ }
+}