List of usage examples for org.objectweb.asm.tree ClassNode accept
public void accept(final ClassVisitor classVisitor)
From source file:pl.clareo.coroutines.core.ClassTransformer.java
License:Apache License
@SuppressWarnings("unchecked") void transform() { for (MethodNode coroutine : coroutines) { if (log.isLoggable(Level.FINEST)) { log.finest("Generating method for coroutine " + coroutine.name + coroutine.desc); }// w ww . ja v a 2 s . c o m String coroutineName = getCoroutineName(coroutine); MethodTransformer methodTransformer = new MethodTransformer(coroutine, thisType); MethodNode coroutineImpl = methodTransformer.transform(coroutineName, generateDebugCode); thisNode.methods.add(coroutineImpl); /* * generate co iterators and method stubs */ log.finest("Generating CoIterator implementation and method stubs"); String baseCoIteratorName; Map<String, Object> annotation = getCoroutineAnnotationValues(coroutine); if (getBoolean(annotation, "threadLocal")) { baseCoIteratorName = Type.getInternalName(ThreadLocalCoIterator.class); } else { baseCoIteratorName = Type.getInternalName(SingleThreadedCoIterator.class); } String coIteratorClassName = "pl/clareo/coroutines/core/CoIterator" + num; ClassNode coIteratorClass = new ClassNode(); coIteratorClass.version = Opcodes.V1_6; coIteratorClass.access = Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SUPER; coIteratorClass.name = coIteratorClassName; coIteratorClass.superName = baseCoIteratorName; if (generateDebugCode) { /* * If debugging code is emitted create field keeping JDK logger */ FieldNode loggerField = new FieldNode(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_STATIC, "logger", "Ljava/util/logging/Logger;", null, null); coIteratorClass.fields.add(loggerField); MethodNode clinit = new MethodNode(); clinit.access = Opcodes.ACC_STATIC; clinit.name = "<clinit>"; clinit.desc = "()V"; clinit.exceptions = Collections.EMPTY_LIST; String loggerName = thisType.getClassName(); InsnList clinitCode = clinit.instructions; clinitCode.add(new LdcInsnNode(loggerName)); clinitCode.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/logging/Logger", "getLogger", "(Ljava/lang/String;)Ljava/util/logging/Logger;")); clinitCode.add(new FieldInsnNode(Opcodes.PUTSTATIC, coIteratorClassName, "logger", "Ljava/util/logging/Logger;")); clinitCode.add(new InsnNode(Opcodes.RETURN)); clinit.maxStack = 1; clinit.maxLocals = 0; coIteratorClass.methods.add(clinit); } /* * Generate constructor */ MethodNode init = new MethodNode(); init.access = Opcodes.ACC_PUBLIC; init.name = "<init>"; init.desc = CO_ITERATOR_CONSTRUCTOR_DESCRIPTOR; init.exceptions = Collections.EMPTY_LIST; InsnList initCode = init.instructions; initCode.add(new VarInsnNode(Opcodes.ALOAD, 0)); initCode.add(new VarInsnNode(Opcodes.ALOAD, 1)); initCode.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, baseCoIteratorName, "<init>", CO_ITERATOR_CONSTRUCTOR_DESCRIPTOR)); initCode.add(new InsnNode(Opcodes.RETURN)); init.maxStack = 2; init.maxLocals = 2; coIteratorClass.methods.add(init); /* * Generate overriden call to coroutine */ MethodNode call = new MethodNode(); call.access = Opcodes.ACC_PROTECTED; call.name = "call"; call.desc = CALL_METHOD_DESCRIPTOR; call.exceptions = Collections.EMPTY_LIST; InsnList callCode = call.instructions; /* * if debug needed generate call details */ if (generateDebugCode) { String coroutineId = "Coroutine " + coroutine.name; callCode.add(loggingInstructions(coIteratorClassName, "logger", Level.FINER, coroutineId + " call. Caller sent: ", 2)); callCode.add(new FrameNode(Opcodes.F_SAME, 0, EMPTY_LOCALS, 0, EMPTY_STACK)); callCode.add(loggingInstructions(coIteratorClassName, "logger", Level.FINEST, coroutineId + " state ", 1)); callCode.add(new FrameNode(Opcodes.F_SAME, 0, EMPTY_LOCALS, 0, EMPTY_STACK)); } /* * push call arguments: this (if not static), frame, input, output */ boolean isStatic = (coroutine.access & Opcodes.ACC_STATIC) != 0; if (!isStatic) { callCode.add(new VarInsnNode(Opcodes.ALOAD, 1)); callCode.add( new MethodInsnNode(Opcodes.INVOKEVIRTUAL, FRAME_NAME, "getThis", "()Ljava/lang/Object;")); callCode.add(new TypeInsnNode(Opcodes.CHECKCAST, thisType.getInternalName())); } callCode.add(new VarInsnNode(Opcodes.ALOAD, 1)); callCode.add(new InsnNode(Opcodes.ACONST_NULL)); callCode.add(new VarInsnNode(Opcodes.ALOAD, 2)); callCode.add(new MethodInsnNode(isStatic ? Opcodes.INVOKESTATIC : Opcodes.INVOKEVIRTUAL, thisType.getInternalName(), coroutineName, COROUTINE_METHOD_DESCRIPTOR)); // stack: * if (!generateDebugCode) { callCode.add(new InsnNode(Opcodes.ARETURN)); } else { // save result display suspension point (two more locals // needed) callCode.add(new VarInsnNode(Opcodes.ASTORE, 3)); callCode.add(new VarInsnNode(Opcodes.ALOAD, 1)); callCode.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, FRAME_NAME, "getLineOfCode", "()I")); callCode.add(box_int(Type.INT)); callCode.add(new VarInsnNode(Opcodes.ASTORE, 4)); callCode.add(loggingInstructions(coIteratorClassName, "logger", Level.FINER, "Coroutine suspended at line ", 4, ". Yielded:", 3)); callCode.add(new FrameNode(Opcodes.F_APPEND, 2, new Object[] { "java/lang/Object", "java/lang/Integer" }, 0, EMPTY_STACK)); callCode.add(new VarInsnNode(Opcodes.ALOAD, 3)); callCode.add(new InsnNode(Opcodes.ARETURN)); } coIteratorClass.methods.add(call); // if debugging code is emitted it needs space for two // additional locals and 5 stack operand if (generateDebugCode) { call.maxStack = 5; call.maxLocals = 5; } else { if (isStatic) { call.maxStack = 3; } else { call.maxStack = 4; } call.maxLocals = 3; } /* * CoIterator created - define it in the runtime and verify if * needed */ if (log.isLoggable(Level.FINEST)) { log.finest("Generated class " + coIteratorClassName); } ClassWriter cw = new ClassWriter(0); coIteratorClass.accept(cw); byte[] classBytes = cw.toByteArray(); try { CoroutineInstrumentator.dumpClass(coIteratorClassName, classBytes); } catch (IOException e) { throw new CoroutineGenerationException("Unable to write class " + coIteratorClassName, e); } /* * start generating method - new method is named as the method in * user code, it: returns instance of appropriate CoIterator (see * above), saves arguments of call */ if (log.isLoggable(Level.FINEST)) { log.finest("Instrumenting method " + coroutine.name); } InsnList code = coroutine.instructions; code.clear(); /* * create new Frame */ boolean isDebugFramePossible = generateDebugCode && coroutine.localVariables != null; if (isDebugFramePossible) { code.add(createDebugFrame(coroutine)); } else { code.add(createFrame(coroutine)); } /* * save frame in the first, and locals array in the second local * variable */ int argsSize = Type.getArgumentsAndReturnSizes(coroutine.desc) >> 2; if (isStatic) { argsSize -= 1; } code.add(new VarInsnNode(Opcodes.ASTORE, argsSize)); code.add(new VarInsnNode(Opcodes.ALOAD, argsSize)); code.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, FRAME_NAME, "getLocals", "()[Ljava/lang/Object;")); int localsArrayIndex = argsSize + 1; code.add(new VarInsnNode(Opcodes.ASTORE, localsArrayIndex)); /* * save all call arguments (along with this if this method is not * static) into locals array */ Type[] argsTypes = Type.getArgumentTypes(coroutine.desc); if (!isStatic) { code.add(saveloc(localsArrayIndex, 0, 0, JAVA_LANG_OBJECT)); code.add(savelocs(localsArrayIndex, 1, 1, argsTypes)); } else { code.add(savelocs(localsArrayIndex, 0, 0, argsTypes)); } /* * create CoIterator instance with saved frame, make initial call to * next if needed and return to caller */ code.add(new TypeInsnNode(Opcodes.NEW, coIteratorClassName)); code.add(new InsnNode(Opcodes.DUP)); code.add(new VarInsnNode(Opcodes.ALOAD, argsSize)); code.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, coIteratorClassName, "<init>", CO_ITERATOR_CONSTRUCTOR_DESCRIPTOR)); if (!getBoolean(annotation, "generator", true)) { code.add(new InsnNode(Opcodes.DUP)); code.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, coIteratorClassName, "next", "()Ljava/lang/Object;")); code.add(new InsnNode(Opcodes.POP)); } code.add(new InsnNode(Opcodes.ARETURN)); /* * end method generation; maxs can be statically determined 3 * operands on stack (call to frame setLocals and CoIterator * constructor) + 1 if any argument is long or double (debug frame * needs 7 operands for variable names creation); locals = argsSize * + 1 reference to frame + 1 array of locals */ if (isDebugFramePossible) { coroutine.maxStack = 7; } else { boolean isCategory2ArgumentPresent = false; for (Type argType : argsTypes) { int sort = argType.getSort(); if (sort == Type.LONG || sort == Type.DOUBLE) { isCategory2ArgumentPresent = true; break; } } coroutine.maxStack = isCategory2ArgumentPresent ? 4 : 3; } coroutine.maxLocals = localsArrayIndex + 1; coroutine.localVariables.clear(); coroutine.tryCatchBlocks.clear(); num++; } }
From source file:pl.clareo.coroutines.core.CoroutineInstrumentator.java
License:Apache License
@Override public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException { if (classBeingRedefined != null) { return null; }/*from w ww . ja v a2 s . c om*/ if (className.startsWith("java/") || className.startsWith("javax/") || className.startsWith("sun/")) { return null; } List<MethodNode> coroutineMethodsInCurrentClass; boolean debug = generateDebugCode; boolean print = printCode; boolean verify = runVerification; boolean outputBin = generateBinaryOutput; boolean asmComputeFrames = overrideFrames; if (!detectCoroutineClasses) { int classnameIndex = Arrays.binarySearch(coroutineEnabledClassnames, className); if (classnameIndex < 0) { // search package String packageName = className; int indexOfSlash; while ((indexOfSlash = packageName.lastIndexOf('/')) != -1) { packageName = packageName.substring(0, indexOfSlash); classnameIndex = Arrays.binarySearch(coroutineEnabledClassnames, packageName); if (classnameIndex >= 0) { break; } } if (classnameIndex < 0) return null; } debug = debugMode[classnameIndex]; print = printMode[classnameIndex]; verify = verifyMode[classnameIndex]; outputBin = outputBinMode[classnameIndex]; asmComputeFrames = overrideFramesMode[classnameIndex]; } boolean log = logger.isLoggable(Level.FINEST); if (log) { logger.finest(className + ": Analyzing"); } ClassReader asmClassReader = new ClassReader(classfileBuffer); ClassNode cn = new ClassNode(); asmClassReader.accept(cn, debug ? 0 : ClassReader.SKIP_DEBUG); ClassAnalyzer analyzer = new ClassAnalyzer(cn); analyzer.analyze(); coroutineMethodsInCurrentClass = analyzer.getCoroutineMethods(); if (coroutineMethodsInCurrentClass.isEmpty()) { return null; } if (log) { logger.finest(className + ": Instrumenting coroutines " + methodNodeListToString(coroutineMethodsInCurrentClass)); } ClassWriter asmClassWriter = new ClassWriter( (asmComputeFrames ? ClassWriter.COMPUTE_FRAMES : 0) | ClassWriter.COMPUTE_MAXS); ClassVisitor cv = asmClassWriter; byte[] instrumentedClassContents; try { if (print) { try { cv = createTracer(className, cv); } catch (FileNotFoundException e) { throw new CoroutineGenerationException("Unable to write trace file ", e); } } new ClassTransformer(cn, coroutineMethodsInCurrentClass, debug).transform(); cn.accept(cv); instrumentedClassContents = asmClassWriter.toByteArray(); if (verify) { verifyClass(className, new ClassReader(instrumentedClassContents), print); } if (outputBin) { dumpClass(className + "Instrumented", instrumentedClassContents); } } catch (IllegalStateException e) { logger.log(Level.WARNING, "Verification failed", e); return null; } catch (IllegalArgumentException e) { logger.log(Level.WARNING, "Verification failed", e); return null; } catch (CoroutineGenerationException e) { logger.warning(e.getMessage()); return null; } catch (Throwable t) { logger.log(Level.SEVERE, "Coroutine generation ended abruptly. This may be a bug in the package itself. Details below:", t); return null; } return instrumentedClassContents; }
From source file:portablejim.veinminer.asm.ItemInWorldManagerTransformer.java
License:Open Source License
public byte[] transformItemInWorldManager(String obfuscatedClassName, byte[] bytes) { ClassNode classNode = new ClassNode(); ClassReader classReader = new ClassReader(bytes); classReader.accept(classNode, 0);/*from www. ja v a 2 s. c o m*/ // Setup type map for (FieldNode variable : classNode.fields) { String srgVariableName = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(obfuscatedClassName, variable.name, variable.desc); if (getCorrectName("theWorld").equals(srgVariableName) || getCorrectName("thisPlayerMP").equals(srgVariableName)) { typemap.put(srgVariableName, variable.desc); } } try { for (MethodNode curMethod : classNode.methods) { String srgFunctionName = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(obfuscatedClassName, curMethod.name, curMethod.desc); if (getCorrectName("uncheckedTryHarvestBlock").equals(srgFunctionName)) { Logger.debug("Inserting call to uncheckedTryHarvestBlock (%s)", srgFunctionName); insertCallAfterTryHarvestBlockFunction(curMethod, obfuscatedClassName); } else if (getCorrectName("onBlockClicked").equals(srgFunctionName)) { Logger.debug("Inserting call to onBlockClicked (%s)", srgFunctionName); int afterFirst = insertCallAfterTryHarvestBlockFunction(curMethod, obfuscatedClassName); insertCallAfterTryHarvestBlockFunction(curMethod, obfuscatedClassName, afterFirst); } } } catch (IndexOutOfBoundsException e) { FMLLog.getLogger().log(Level.WARNING, "[%s] Problem inserting all required code. This mod may not function correctly. Please report a bug.", ModInfo.MOD_NAME); } ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); classNode.accept(writer); return writer.toByteArray(); }
From source file:the.bytecode.club.bootloader.LibraryClassLoader.java
License:Open Source License
protected Class<?> define(ClassNode cn) { ClassWriter writer = new ResolvingClassWriter(tree); cn.accept(cn); byte[] bytes = writer.toByteArray(); return defineClass(bytes, 0, bytes.length); }
From source file:the.bytecode.club.bytecodeviewer.api.ClassNodeLoader.java
License:Open Source License
/** * Converts a class node to a class// w w w . ja va 2 s.c o m * * @param node * The node to convert * @return The converted class */ public Class<?> nodeToClass(ClassNode node) { if (super.findLoadedClass(node.name.replace("/", ".")) != null) return findLoadedClass(node.name.replace("/", ".")); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); try { node.accept(cw); } catch (Exception e) { e.printStackTrace(); } byte[] b = cw.toByteArray(); return defineClass(node.name.replaceAll("/", "."), b, 0, b.length, getDomain()); }
From source file:the.bytecode.club.bytecodeviewer.JarUtils.java
License:Open Source License
/** * Saves as jar with manifest/*from ww w . j a v a 2 s. c o m*/ * @param nodeList the loaded ClassNodes * @param path the exact path of the output jar file * @param manifest the manifest contents */ public static void saveAsJar(ArrayList<ClassNode> nodeList, String path, String manifest) { try (JarOutputStream out = new JarOutputStream(new FileOutputStream(path))) { for (ClassNode cn : nodeList) { ClassWriter cw = new ClassWriter(0); cn.accept(cw); out.putNextEntry(new ZipEntry(cn.name + ".class")); out.write(cw.toByteArray()); out.closeEntry(); } out.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF")); out.write((manifest.trim() + "\r\n\r\n").getBytes()); out.closeEntry(); for (FileContainer container : BytecodeViewer.files) for (Entry<String, byte[]> entry : container.files.entrySet()) { String filename = entry.getKey(); if (!filename.startsWith("META-INF")) { out.putNextEntry(new ZipEntry(filename)); out.write(entry.getValue()); out.closeEntry(); } } } catch (IOException e) { new the.bytecode.club.bytecodeviewer.api.ExceptionUI(e); } }
From source file:the.bytecode.club.bytecodeviewer.JarUtils.java
License:Open Source License
/** * Saves a jar without the manifest/* w w w. j a v a 2s . c o m*/ * @param nodeList The loaded ClassNodes * @param path the exact jar output path */ public static void saveAsJarClassesOnly(ArrayList<ClassNode> nodeList, String path) { try (JarOutputStream out = new JarOutputStream(new FileOutputStream(path))) { ArrayList<String> noDupe = new ArrayList<String>(); for (ClassNode cn : nodeList) { ClassWriter cw = new ClassWriter(0); cn.accept(cw); String name = cn.name + ".class"; if (!noDupe.contains(name)) { noDupe.add(name); out.putNextEntry(new ZipEntry(name)); out.write(cw.toByteArray()); out.closeEntry(); } } noDupe.clear(); } catch (IOException e) { new the.bytecode.club.bytecodeviewer.api.ExceptionUI(e); } }
From source file:uk.co.mysterymayhem.tessellatorfix.Transformer.java
private static byte[] patchTessellatorClass(byte[] bytes) { String targetMethodName;//from w ww. j a va 2 s .co m if (Plugin.runtimeDeobfEnabled) { targetMethodName = "func_147564_a"; } else { targetMethodName = "getVertexState"; } ClassNode classNode = new ClassNode(); ClassReader classReader = new ClassReader(bytes); classReader.accept(classNode, 0); Iterator<MethodNode> methods = classNode.methods.iterator(); while (methods.hasNext()) { MethodNode m = methods.next(); if ((m.name.equals(targetMethodName) && m.desc.equals("(FFF)Lnet/minecraft/client/shader/TesselatorVertexState;"))) { FMLLog.info("Inside target Tessellator method"); InsnList toInject = new InsnList(); // Insertion of "if (this.rawBufferIndex < 1) return" LabelNode labelNode = new LabelNode(); toInject.add(new VarInsnNode(Opcodes.ALOAD, 0)); String fieldName; if (Plugin.runtimeDeobfEnabled) { fieldName = "field_147569_p"; } else { fieldName = "rawBufferIndex"; } toInject.add(new FieldInsnNode(Opcodes.GETFIELD, "net/minecraft/client/renderer/Tessellator", fieldName, "I")); toInject.add(new InsnNode(Opcodes.ICONST_1)); toInject.add(new JumpInsnNode(Opcodes.IF_ICMPGE, labelNode)); toInject.add(new InsnNode(Opcodes.ACONST_NULL)); toInject.add(new InsnNode(Opcodes.ARETURN)); toInject.add(labelNode); // Insert after m.instructions.insert(toInject); ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); classNode.accept(writer); FMLLog.info("Exiting target Tessellator method"); return writer.toByteArray(); } } FMLLog.warning("Could not find Tessellator method out of:"); StringBuilder builder = new StringBuilder(); for (MethodNode methodNode : classNode.methods) { builder.append(methodNode.name).append(":").append(methodNode.desc).append("\n"); } FMLLog.info(builder.toString()); return bytes; }
From source file:vazkii.quark.base.asm.ClassTransformer.java
License:Creative Commons License
private static byte[] transform(byte[] basicClass, Pair<MethodSignature, MethodAction>... methods) { ClassReader reader = new ClassReader(basicClass); ClassNode node = new ClassNode(); reader.accept(node, 0);/* w ww .j a v a 2 s .com*/ boolean didAnything = false; for (Pair<MethodSignature, MethodAction> pair : methods) { log("Applying Transformation to method (" + pair.getLeft() + ")"); didAnything |= findMethodAndTransform(node, pair.getLeft(), pair.getRight()); } if (didAnything) { ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); node.accept(writer); return writer.toByteArray(); } return basicClass; }
From source file:xt.to.cs.mixmaster.MixMaster.java
@SuppressWarnings("unchecked") public void generate() { cv.visit(version, access, name, signature, superName, interfaces.toArray(new String[] {})); for (ClassNode node : nodes) node.accept(mixAdapter); String[] exceptions = new String[initNode.exceptions.size()]; initNode.exceptions.toArray(exceptions); MethodVisitor mv = cv.visitMethod(access, initNode.name, initNode.desc, initNode.signature, exceptions); initNode.accept(new AdviceAdapter(mv, initNode.access, initNode.name, initNode.desc) { @Override/* ww w. j a v a 2 s. co m*/ protected void onMethodEnter() { for (String initMethod : initMethods) { visitIntInsn(ALOAD, 0); visitMethodInsn(Opcodes.INVOKESPECIAL, MixMaster.this.name, initMethod, initNode.desc); } } }); cv.visitEnd(); }