Java tutorial
/******************************************************************************* * Copyright (c) 2011-2014 Fernando Petrola * * This file is part of Dragome SDK. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the GNU Public License v3.0 * which accompanies this distribution, and is available at * http://www.gnu.org/licenses/gpl.html ******************************************************************************/ package com.dragome.compiler.invokedynamic; import static org.objectweb.asm.Opcodes.INVOKESTATIC; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.Handle; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.tree.ClassNode; import com.dragome.commons.compiler.BytecodeTransformer; public class InvokeDynamicBackporter implements BytecodeTransformer { public static byte[] transform(byte[] bytecode) { ClassNode classNode = new ClassNode(Opcodes.ASM5); InvokeDynamicConverter invokeDynamicConverter = new InvokeDynamicConverter(classNode); new ClassReader(bytecode).accept(invokeDynamicConverter, 0); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); classNode.accept(cw); return cw.toByteArray(); } private static class InvokeDynamicConverter extends ClassVisitor { private int classAccess; private String className; public InvokeDynamicConverter(ClassVisitor next) { super(Opcodes.ASM5, next); } public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { super.visit(version, access, name, signature, superName, interfaces); this.classAccess = access; this.className = name; } public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { if (isBridgeMethodOnInterface(access)) { return null; } if (isNonAbstractMethodOnInterface(access) && !isClassInitializerMethod(name, desc, access)) { // System.out.println("WARNING: Method '" + name + "' of interface '" + className + "' is non-abstract! " + "This will probably fail to run on Java 7 and below. " + "If you get this warning _without_ using Java 8's default methods, " + "please report a bug at https://github.com/orfjackal/retrolambda/issues " + "together with an SSCCE (http://www.sscce.org/)"); } MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); return new InvokeDynamicInsnConvertingMethodVisitor(api, mv, className); } private boolean isBridgeMethodOnInterface(int methodAccess) { return Flags.hasFlag(classAccess, Opcodes.ACC_INTERFACE) && Flags.hasFlag(methodAccess, Opcodes.ACC_BRIDGE); } private boolean isNonAbstractMethodOnInterface(int methodAccess) { return Flags.hasFlag(classAccess, Opcodes.ACC_INTERFACE) && !Flags.hasFlag(methodAccess, Opcodes.ACC_ABSTRACT); } private static boolean isClassInitializerMethod(String name, String desc, int methodAccess) { return name.equals("<clinit>") && desc.equals("()V") && Flags.hasFlag(methodAccess, Opcodes.ACC_STATIC); } } private static class InvokeDynamicInsnConvertingMethodVisitor extends MethodVisitor { private final String myClassName; public InvokeDynamicInsnConvertingMethodVisitor(int api, MethodVisitor mv, String myClassName) { super(api, mv); this.myClassName = myClassName; } public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) { backportLambda(name, Type.getType(desc), bsm, bsmArgs); } private void backportLambda(String invokedName, Type invokedType, Handle bsm, Object[] bsmArgs) { Type[] argumentTypes = Type.getArgumentTypes(invokedType.toString()); Type returnType = Type.getReturnType(invokedType.toString()); String returnTypeName = returnType.getClassName(); int length = argumentTypes.length; createArrayWithParameters(length, argumentTypes); this.visitLdcInsn(myClassName); this.visitLdcInsn(invokedName); this.visitLdcInsn(returnTypeName); this.visitLdcInsn(invokedType.toString()); this.visitLdcInsn(bsmArgs[1].toString()); this.visitVarInsn(Opcodes.ALOAD, 20); this.visitLdcInsn(bsm.getTag() == 5 ? "virtual" : "static"); String runnableSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;"; this.visitMethodInsn(INVOKESTATIC, "com/dragome/utils/DragomeCallsiteFactory", "create", runnableSignature, false); } private void createArrayWithParameters(int parametersCount, Type[] argumentTypes) { this.visitIntInsn(Opcodes.BIPUSH, parametersCount); this.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object"); this.visitVarInsn(Opcodes.ASTORE, 20); for (int i = parametersCount - 1; i >= 0; i--) { convertPrimitive(argumentTypes[i], i); this.visitVarInsn(Opcodes.ASTORE, 21); this.visitVarInsn(Opcodes.ALOAD, 20); this.visitIntInsn(Opcodes.BIPUSH, i); this.visitVarInsn(Opcodes.ALOAD, 21); this.visitInsn(Opcodes.AASTORE); } } private void convertPrimitive(Object tp, int i) { if (tp.equals(Type.BOOLEAN_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Boolean", "valueOf", "(Z)Ljava/lang/Boolean;", false); } else if (tp.equals(Type.BYTE_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Byte", "valueOf", "(B)Ljava/lang/Byte;", false); } else if (tp.equals(Type.CHAR_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "valueOf", "(C)Ljava/lang/Character;", false); } else if (tp.equals(Type.SHORT_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Short", "valueOf", "(S)Ljava/lang/Short;", false); } else if (tp.equals(Type.INT_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Integer", "valueOf", "(I)Ljava/lang/Integer;", false); } else if (tp.equals(Type.LONG_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Long", "valueOf", "(J)Ljava/lang/Long;", false); i++; } else if (tp.equals(Type.FLOAT_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "valueOf", "(F)Ljava/lang/Float;", false); } else if (tp.equals(Type.DOUBLE_TYPE)) { mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "valueOf", "(D)Ljava/lang/Double;", false); i++; } // else // mv.visitVarInsn(Opcodes.ALOAD, i); } } public byte[] transform(String className, byte[] bytecode) { return transform(bytecode); } public boolean requiresTransformation(String className) { return true; } }