Example usage for org.objectweb.asm.tree ClassNode accept

List of usage examples for org.objectweb.asm.tree ClassNode accept

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.tree.*
  5. ClassNode
  6. accept

Introduction

In this page you can find the example usage for org.objectweb.asm.tree ClassNode accept.

Prototype

public void accept(final ClassVisitor classVisitor)

Source Link

Document

Makes the given class visitor visit this class.

Usage

From source file:com.lion328.thaifixes.coremod.patcher.GuiChatBytecodePatcher.java

License:Open Source License

@Override
public byte[] patchClass(byte[] source) {
    if (ThaiFixesConfiguration.getFontStyle() != ThaiFixesFontStyle.MCPX)
        return source;

    ClassReader classReader = new ClassReader(source);
    ClassNode classNode = new ClassNode();
    classReader.accept(classNode, 0);/*from  w w  w .j  a v  a  2  s  .  c o m*/

    for (MethodNode method : classNode.methods) {
        boolean drawScreenFlag;
        if ((drawScreenFlag = (method.name.equals(CLASSMAP.getMethod("drawScreen"))
                && method.desc.equals("(IIF)V")))
                || (method.name.equals(CLASSMAP.getMethod("initGui")) && method.desc.equals("()V"))) {
            for (int i = 0; i < method.instructions.size(); i++) {
                if ((method.instructions.get(i).getOpcode() == Opcodes.BIPUSH)
                        && (method.instructions.get(i + 1).getOpcode() == Opcodes.ISUB)) {
                    IntInsnNode node = (IntInsnNode) method.instructions.get(i);
                    if (node.operand == (drawScreenFlag ? 14 : 12))
                        method.instructions.set(node,
                                new VarInsnNode(Opcodes.BIPUSH,
                                        (drawScreenFlag ? ThaiFixesFontRenderer.MCPX_CHATBLOCK_HEIGHT + 2
                                                : ThaiFixesFontRenderer.MCPX_CHATBLOCK_TEXT_YPOS + 2)));
                }
            }
        }
    }

    ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    classNode.accept(writer);
    return writer.toByteArray();
}

From source file:com.lion328.thaifixes.coremod.patcher.GuiNewChatBytecodePatcher.java

License:Open Source License

@Override
public byte[] patchClass(byte[] source) {
    if (ThaiFixesConfiguration.getFontStyle() != ThaiFixesFontStyle.MCPX)
        return source;

    ClassReader classReader = new ClassReader(source);
    ClassNode classNode = new ClassNode();
    classReader.accept(classNode, 0);//from   w ww  . jav  a 2  s. co m

    for (MethodNode method : classNode.methods) {
        if (method.name.equals(CLASSMAP.getMethod("drawChat")) && method.desc.equals("(I)V")) {
            AbstractInsnNode currentNode = null;
            for (int i = 0; i < method.instructions.size(); i++) {
                currentNode = method.instructions.get(i);
                if (currentNode.getOpcode() == Opcodes.BIPUSH) {
                    if (method.instructions.get(i + 1).getOpcode() == Opcodes.IMUL)
                        method.instructions.set(currentNode,
                                new VarInsnNode(Opcodes.BIPUSH, ThaiFixesFontRenderer.MCPX_CHATBLOCK_HEIGHT));
                    else if (method.instructions.get(i + 1).getOpcode() == Opcodes.ISUB
                            && method.instructions.get(i - 1).getOpcode() == Opcodes.ILOAD) {
                        IntInsnNode node = (IntInsnNode) currentNode;
                        if (node.operand == 9)
                            method.instructions.set(currentNode, new VarInsnNode(Opcodes.BIPUSH,
                                    ThaiFixesFontRenderer.MCPX_CHATBLOCK_HEIGHT));
                        else if (node.operand == 8)
                            method.instructions.set(currentNode, new VarInsnNode(Opcodes.BIPUSH,
                                    ThaiFixesFontRenderer.MCPX_CHATBLOCK_TEXT_YPOS));
                    }
                }
            }
        } else if (method.name.equals(CLASSMAP.getMethod("func_146236_a"))
                && method.desc.equals("(II)L" + ClassMap.getClassMap("net.minecraft.util.IChatComponent")
                        .getClassInfo().getProductionClassName().replace('.', '/') + ";")) {
            for (int i = 0; i < method.instructions.size(); i++) {
                if (method.instructions.get(i).getOpcode() == Opcodes.GETFIELD) {
                    FieldInsnNode node = (FieldInsnNode) method.instructions.get(i);
                    if (node.owner.equals(ClassMap.getClassMap("net.minecraft.client.gui.FontRenderer")
                            .getClassInfo().getProductionClassName().replace('.', '/'))
                            && node.name.equals(ClassMap.getClassMap("net.minecraft.client.gui.FontRenderer")
                                    .getField("FONT_HEIGHT"))) {
                        method.instructions.set(node,
                                new VarInsnNode(Opcodes.BIPUSH, ThaiFixesFontRenderer.MCPX_CHATBLOCK_HEIGHT));
                        method.instructions.remove(method.instructions.get(i - 1)); // GETFIELD Minecraft.mc
                        method.instructions.remove(method.instructions.get(i - 2)); // GETFIELD GuiNewChat.mc
                        method.instructions.remove(method.instructions.get(i - 3)); // ALOAD 0
                    }
                }
            }
        }
    }

    ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    classNode.accept(writer);
    return writer.toByteArray();
}

From source file:com.lion328.xenonlauncher.patcher.StringReplaceFilePatcher.java

License:Open Source License

@Override
public byte[] patchFile(String name, byte[] original) {
    if (!name.endsWith(".class")) {
        return original;
    }/*w  ww  .  j  ava2  s  .c om*/

    ClassReader reader = new ClassReader(original);
    ClassNode node = new ClassNode();
    reader.accept(node, 0);

    List fields = node.fields;
    FieldNode field;
    for (Object obj : fields) {
        if (!(obj instanceof FieldNode)) {
            continue;
        }

        field = (FieldNode) obj;

        if (field.value instanceof String) {
            field.value = ((String) field.value).replace(find, replace);
        }
    }

    List methods = node.methods;
    MethodNode method;
    for (Object obj : methods) {
        if (!(obj instanceof MethodNode)) {
            continue;
        }

        method = (MethodNode) obj;

        InsnList insns = method.instructions;

        for (int i = 0; i < insns.size(); i++) {
            AbstractInsnNode insn = insns.get(i);

            if (!(insn instanceof LdcInsnNode)) {
                continue;
            }

            LdcInsnNode ldc = (LdcInsnNode) insn;

            if (!(ldc.cst instanceof String)) {
                continue;
            }

            ldc.cst = ((String) ldc.cst).replace(find, replace);
        }
    }

    ClassWriter writer = new ClassWriter(0);
    node.accept(writer);

    return writer.toByteArray();
}

From source file:com.microsoft.Malmo.OverclockingClassTransformer.java

License:Open Source License

private static byte[] transform(byte[] serverClass, boolean isObfuscated, transformType type) {
    System.out.println("MALMO: Attempting to transform MinecraftServer");
    try {/*  w w w  .  ja v a 2s.  co  m*/
        ClassNode cnode = new ClassNode();
        ClassReader creader = new ClassReader(serverClass);
        creader.accept(cnode, 0);

        switch (type) {
        case SERVER:
            overclockServer(cnode, isObfuscated);
            break;
        case RENDERER:
            overclockRenderer(cnode, isObfuscated);
            break;
        }

        ClassWriter cwriter = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
        cnode.accept(cwriter);
        return cwriter.toByteArray();
    } catch (Exception e) {
        System.out.println("MALMO FAILED to transform MinecraftServer - overclocking not available!");
    }
    return serverClass;
}

From source file:com.mogujie.instantrun.IncrementalVisitor.java

License:Apache License

public static boolean instrumentClass(ZipEntry entry, ZipFile zipFile, ZipOutputStream zos,
        VisitorBuilder visitorBuilder, boolean isHotfix) throws IOException {
    byte[] classBytes = FileUtils.toByteArray(zipFile.getInputStream(entry));
    ClassReader classReader = new ClassReader(classBytes);
    // override the getCommonSuperClass to use the thread context class loader instead of
    // the system classloader. This is useful as ASM needs to load classes from the project
    // which the system classloader does not have visibility upon.
    // TODO: investigate if there is not a simpler way than overriding.
    ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_FRAMES) {
        @Override//from   w  ww.  ja v  a 2s . c om
        protected String getCommonSuperClass(final String type1, final String type2) {
            Class<?> c, d;
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            try {
                c = Class.forName(type1.replace('/', '.'), false, classLoader);
                d = Class.forName(type2.replace('/', '.'), false, classLoader);
            } catch (ClassNotFoundException e) {
                // This may happen if we're processing class files which reference APIs not
                // available on the target device. In this case return a dummy value, since this
                // is ignored during dx compilation.
                return "instant/run/NoCommonSuperClass";
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            if (c.isAssignableFrom(d)) {
                return type1;
            }
            if (d.isAssignableFrom(c)) {
                return type2;
            }
            if (c.isInterface() || d.isInterface()) {
                return "java/lang/Object";
            } else {
                do {
                    c = c.getSuperclass();
                } while (!c.isAssignableFrom(d));
                return c.getName().replace('.', '/');
            }
        }
    };

    ClassNode classNode = new TransformAccessClassNode();
    classReader.accept(classNode, ClassReader.EXPAND_FRAMES);

    // when dealing with interface, we just copy the inputFile over without any changes unless
    // this is a package private interface.
    AccessRight accessRight = AccessRight.fromNodeAccess(classNode.access);
    ZipEntry nowEntry;
    if (isHotfix) {
        String name = entry.getName();
        name = name.substring(0, name.lastIndexOf(".class"));
        nowEntry = new ZipEntry(name + "$override" + ".class");
    } else {
        nowEntry = new ZipEntry(entry.getName());
    }

    if ((classNode.access & Opcodes.ACC_INTERFACE) != 0) {
        if (visitorBuilder.getOutputType() == OutputType.INSTRUMENT) {
            // don't change the name of interfaces.
            zos.putNextEntry(nowEntry);
            if (accessRight == AccessRight.PACKAGE_PRIVATE) {
                classNode.access = classNode.access | Opcodes.ACC_PUBLIC;
                classNode.accept(classWriter);
                zos.write(classWriter.toByteArray());
            } else {
                // just copy the input file over, no change.
                zos.write(classBytes);
            }
            zos.closeEntry();
            return true;
        } else {
            return false;
        }
    }

    List<ClassNode> parentsNodes = parseParents(zipFile, classNode);

    IncrementalVisitor visitor = visitorBuilder.build(classNode, parentsNodes, classWriter);
    classNode.accept(visitor);

    zos.putNextEntry(nowEntry);
    zos.write(classWriter.toByteArray());
    zos.closeEntry();

    if (isHotfix) {
        IncrementalChangeVisitor changeVisitor = (IncrementalChangeVisitor) visitor;
        if (changeVisitor.superMethods.size() > 0) {
            if (parentsNodes.size() <= 0) {
                throw new GradleException("not found " + changeVisitor.visitedClassName + " 's parents.");
            }
            SuperHelperVisitor superHelperVisitor = new SuperHelperVisitor(Opcodes.ASM5, changeVisitor,
                    parentsNodes.get(0));
            superHelperVisitor.start();
            String newName = entry.getName();
            newName = newName.substring(0, newName.lastIndexOf(".class"));
            newName += "$helper.class";
            ZipEntry zipEntry = new ZipEntry(newName);
            zos.putNextEntry(zipEntry);
            zos.write(superHelperVisitor.toByteArray());
            zos.closeEntry();
        }

    }
    return true;
}

From source file:com.navercorp.pinpoint.profiler.instrument.ASMAspectWeaverTest.java

License:Apache License

private Object getInstnace(final String originalName, final String aspectName) throws Exception {
    final ClassLoader defaultClassLoader = Thread.currentThread().getContextClassLoader();
    final ClassLoader classLoader = new ClassLoader() {
        @Override/*from w w  w .j  a va2 s .com*/
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            if (name.equals(originalName)) {
                try {
                    final ClassReader cr = new ClassReader(
                            getClass().getResourceAsStream("/" + name.replace('.', '/') + ".class"));
                    final ClassNode classNode = new ClassNode();
                    cr.accept(classNode, 0);

                    final ASMClassNodeAdapter sourceClassNode = new ASMClassNodeAdapter(defaultClassLoader,
                            classNode);
                    final ASMClassNodeAdapter adviceClassNode = ASMClassNodeAdapter.get(defaultClassLoader,
                            aspectName.replace('.', '/'));

                    final ASMAspectWeaver aspectWeaver = new ASMAspectWeaver();
                    aspectWeaver.weaving(sourceClassNode, adviceClassNode);

                    final ClassWriter cw = new ClassWriter(0);
                    classNode.accept(cw);
                    final byte[] bytecode = cw.toByteArray();
                    CheckClassAdapter.verify(new ClassReader(bytecode), false, new PrintWriter(System.out));

                    return super.defineClass(name, bytecode, 0, bytecode.length);
                } catch (Exception ex) {
                    throw new ClassNotFoundException("Load error: " + ex.toString(), ex);
                }
            } else {
                return super.loadClass(name);
            }
        }
    };
    Class clazz = classLoader.loadClass(originalName);
    return clazz.newInstance();
}

From source file:com.navercorp.pinpoint.profiler.instrument.ASMClassWriterTest.java

License:Apache License

@Test
public void accept() throws Exception {
    final String className = "com.navercorp.pinpoint.profiler.instrument.mock.SampleClass";
    ClassNode classNode = ASMClassNodeLoader.get(className.replace('.', '/'));

    ASMClassWriter cw = new ASMClassWriter(classNode.name, classNode.superName, 0, null);
    TraceClassVisitor tcv = new TraceClassVisitor(cw, new PrintWriter(System.out));
    classNode.accept(tcv);
}

From source file:com.offbynull.coroutines.instrumenter.Instrumenter.java

License:Open Source License

/**
 * Instruments a class./* w w  w  .j  av  a 2s .c o m*/
 * @param input class file contents
 * @return instrumented class
 * @throws IllegalArgumentException if the class could not be instrumented for some reason
 * @throws NullPointerException if any argument is {@code null}
 */
public byte[] instrument(byte[] input) {
    Validate.notNull(input);
    Validate.isTrue(input.length > 0);

    // Read class as tree model -- because we're using SimpleClassNode, JSR blocks get inlined
    ClassReader cr = new ClassReader(input);
    ClassNode classNode = new SimpleClassNode();
    cr.accept(classNode, 0);

    // Is this class an interface? if so, skip it
    if ((classNode.access & Opcodes.ACC_INTERFACE) == Opcodes.ACC_INTERFACE) {
        return input.clone();
    }

    // Has this class already been instrumented? if so, skip it
    if (classNode.interfaces.contains(INSTRUMENTED_CLASS_TYPE.getInternalName())) {
        return input.clone();
    }

    // Find methods that need to be instrumented. If none are found, skip
    List<MethodNode> methodNodesToInstrument = findMethodsWithParameter(classNode.methods,
            CONTINUATION_CLASS_TYPE);
    if (methodNodesToInstrument.isEmpty()) {
        return input.clone();
    }

    // Add the "Instrumented" interface to this class so if we ever come back to it, we can skip it
    classNode.interfaces.add(INSTRUMENTED_CLASS_TYPE.getInternalName());

    // Instrument each method that was returned
    for (MethodNode methodNode : methodNodesToInstrument) {
        // Check if method is constructor -- we cannot instrument constructor
        Validate.isTrue(!"<init>".equals(methodNode.name), "Instrumentation of constructors not allowed");

        // Check for JSR blocks -- Emitted for finally blocks in older versions of the JDK. Should never happen since we already inlined
        // these blocks before coming to this point. This is a sanity check.
        Validate.isTrue(searchForOpcodes(methodNode.instructions, Opcodes.JSR).isEmpty(),
                "JSR instructions not allowed");

        // Find invocations of continuation points
        List<AbstractInsnNode> suspendInvocationInsnNodes = findInvocationsOf(methodNode.instructions,
                CONTINUATION_SUSPEND_METHOD);
        List<AbstractInsnNode> invokeInvocationInsnNodes = findInvocationsWithParameter(methodNode.instructions,
                CONTINUATION_CLASS_TYPE);

        // If there are no continuation points, we don't need to instrument this method. It'll be like any other normal method
        // invocation because it won't have the potential to pause or call in to another method that may potentially pause.
        if (suspendInvocationInsnNodes.isEmpty() && invokeInvocationInsnNodes.isEmpty()) {
            continue;
        }

        // Check for continuation points that use invokedynamic instruction, which are currently only used by lambdas. See comments in
        // validateNoInvokeDynamic to see why we need to do this.
        validateNoInvokeDynamic(suspendInvocationInsnNodes);
        validateNoInvokeDynamic(invokeInvocationInsnNodes);

        // Analyze method
        Frame<BasicValue>[] frames;
        try {
            frames = new Analyzer<>(new SimpleVerifier(classRepo)).analyze(classNode.name, methodNode);
        } catch (AnalyzerException ae) {
            throw new IllegalArgumentException("Analyzer failed to analyze method", ae);
        }

        // Manage arguments and additional local variables that we need for instrumentation
        int contArgIdx = getLocalVariableIndexOfContinuationParameter(methodNode);

        VariableTable varTable = new VariableTable(classNode, methodNode);
        Variable contArg = varTable.getArgument(contArgIdx); // Continuation argument
        Variable methodStateVar = varTable.acquireExtra(MethodState.class); // var shared between monitor and flow instrumentation
        Variable tempObjVar = varTable.acquireExtra(Object.class); // var shared between monitor and flow instrumentation

        // Generate code to deal with suspending around synchronized blocks
        MonitorInstrumentationVariables monitorInstrumentationVariables = new MonitorInstrumentationVariables(
                varTable, methodStateVar, tempObjVar);
        MonitorInstrumentationInstructions monitorInstrumentationLogic = new MonitorInstrumentationGenerator(
                methodNode, monitorInstrumentationVariables).generate();

        // Generate code to deal with flow control (makes use of some of the code generated in monitorInstrumentationLogic)
        FlowInstrumentationVariables flowInstrumentationVariables = new FlowInstrumentationVariables(varTable,
                contArg, methodStateVar, tempObjVar);
        FlowInstrumentationInstructions flowInstrumentationInstructions = new FlowInstrumentationGenerator(
                methodNode, suspendInvocationInsnNodes, invokeInvocationInsnNodes, frames,
                monitorInstrumentationLogic, flowInstrumentationVariables).generate();

        // Apply generated code
        applyInstrumentationLogic(methodNode, flowInstrumentationInstructions, monitorInstrumentationLogic);
    }

    // Write tree model back out as class
    ClassWriter cw = new SimpleClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES, classRepo);
    classNode.accept(cw);
    return cw.toByteArray();
}

From source file:com.replaymod.pixelcam.coremod.CameraTiltCT.java

License:Apache License

private byte[] transform(byte[] bytes, String name_orientCamera) {
    ClassReader classReader = new ClassReader(bytes);
    ClassNode classNode = new ClassNode();
    classReader.accept(classNode, 0);//from  www . j ava 2s. c o  m

    boolean success = false;
    for (MethodNode m : classNode.methods) {
        if ("(F)V".equals(m.desc) && name_orientCamera.equals(m.name)) {
            inject(m.instructions.iterator());
            success = true;
        }
    }
    if (!success) {
        throw new NoSuchMethodError();
    }

    ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    classNode.accept(classWriter);
    return classWriter.toByteArray();
}

From source file:com.retroduction.carma.transformer.asm.aor.AOR_Transition.java

License:Open Source License

@Override
protected void checkNode(ClassNode classNode, MethodNode methodNode, List<Mutant> result, CRTEntry jcovInfo,
        AbstractInsnNode node) {//from   w ww  .  ja va 2s  .  c  o m

    if (node instanceof InsnNode) {

        InsnNode sourceNode = (InsnNode) node;

        if (sourceNode.getOpcode() == this.sourceInstruction) {

            InsnNode targetNode = new InsnNode(this.targetInstruction);

            methodNode.instructions.set(sourceNode, targetNode);

            ClassWriter writer = new ClassWriter(0);
            classNode.accept(writer);

            SourceCodeMapping sourceMapping = new SourceCodeMapping();
            sourceMapping.setLineStart(jcovInfo.getStartLine());
            sourceMapping.setLineEnd(jcovInfo.getEndLine());
            sourceMapping.setColumnStart(jcovInfo.getStartColumn());
            sourceMapping.setColumnEnd(jcovInfo.getEndColumn());

            Mutant mutant = new Mutant();
            mutant.setByteCode(writer.toByteArray());
            mutant.setSourceMapping(sourceMapping);
            mutant.setSurvived(true);
            mutant.setTransition(this);

            result.add(mutant);

            methodNode.instructions.set(targetNode, sourceNode);

        }

    }
}