Examples with Instruction net.runelite.asm.attributes.code.Instruction used on opensource projects

Example 46 with Instruction

use of net.runelite.asm.attributes.code.Instruction in project runelite by runelite.

the class ExprArgOrder method visit.

private void visit(InstructionContext ctx) {
    Instruction ins = ctx.getInstruction();
    if (ins instanceof IAdd || ins instanceof IMul || ins instanceof IfICmpEq || ins instanceof IfICmpNe || ins instanceof IfACmpEq || ins instanceof IfACmpNe) {
        Expression expression = new Expression(ctx);
        parseExpr(expression, ctx);
        if (!exprs.containsKey(ins)) {
            exprIns.add(ins);
            exprs.put(ins, expression);
        }
    }
}

Example 47 with Instruction

use of net.runelite.asm.attributes.code.Instruction in project runelite by runelite.

the class Frame method nextInstruction.

public void nextInstruction() {
    Instructions ins = method.getCode().getInstructions();
    List<Instruction> instructions = ins.getInstructions();
    int idx = instructions.indexOf(cur);
    assert idx != -1;
    cur = instructions.get(idx + 1);
}

Example 48 with Instruction

use of net.runelite.asm.attributes.code.Instruction in project runelite by runelite.

the class MixinInjector method injectMethods.

private void injectMethods(ClassFile mixinCf, ClassFile cf, Map<net.runelite.asm.pool.Field, Field> shadowFields) throws InjectionException {
    // Keeps mappings between methods annotated with @Copy -> the copied method within the vanilla pack
    Map<net.runelite.asm.pool.Method, CopiedMethod> copiedMethods = new HashMap<>();
    // Handle the copy mixins first, so all other mixins know of the copies
    for (Method method : mixinCf.getMethods()) {
        Annotation copyAnnotation = method.getAnnotations().find(COPY);
        if (copyAnnotation == null) {
            continue;
        }
        String deobMethodName = (String) copyAnnotation.getElement().getValue();
        ClassFile deobCf = inject.toDeobClass(cf);
        Method deobMethod = findDeobMethod(deobCf, deobMethodName, method.getDescriptor());
        if (deobMethod == null) {
            throw new InjectionException("Failed to find the deob method " + deobMethodName + " for mixin " + mixinCf);
        }
        if (method.isStatic() != deobMethod.isStatic()) {
            throw new InjectionException("Mixin method " + method + " should be " + (deobMethod.isStatic() ? "static" : "non-static"));
        }
        // Find the vanilla class where the method to copy is in
        String obClassName = DeobAnnotations.getObfuscatedName(deobMethod.getClassFile().getAnnotations());
        ClassFile obCf = inject.getVanilla().findClass(obClassName);
        assert obCf != null : "unable to find vanilla class from obfuscated name " + obClassName;
        String obMethodName = DeobAnnotations.getObfuscatedName(deobMethod.getAnnotations());
        Signature obMethodSignature = DeobAnnotations.getObfuscatedSignature(deobMethod);
        if (obMethodName == null) {
            obMethodName = deobMethod.getName();
        }
        if (obMethodSignature == null) {
            obMethodSignature = deobMethod.getDescriptor();
        }
        Method obMethod = obCf.findMethod(obMethodName, obMethodSignature);
        if (obMethod == null) {
            throw new InjectionException("Failed to find the ob method " + obMethodName + " for mixin " + mixinCf);
        }
        if (method.getDescriptor().size() > obMethod.getDescriptor().size()) {
            throw new InjectionException("Mixin methods cannot have more parameters than their corresponding ob method");
        }
        Method copy = new Method(cf, "copy$" + deobMethodName, obMethodSignature);
        moveCode(copy, obMethod.getCode());
        copy.setAccessFlags(obMethod.getAccessFlags());
        copy.setPublic();
        copy.getExceptions().getExceptions().addAll(obMethod.getExceptions().getExceptions());
        copy.getAnnotations().getAnnotations().addAll(obMethod.getAnnotations().getAnnotations());
        cf.addMethod(copy);
        /*
				If the desc for the mixin method and the desc for the ob method
				are the same in length, assume that the mixin method is taking
				care of the garbage parameter itself.
			 */
        boolean hasGarbageValue = method.getDescriptor().size() != obMethod.getDescriptor().size() && deobMethod.getDescriptor().size() < obMethodSignature.size();
        copiedMethods.put(method.getPoolMethod(), new CopiedMethod(copy, hasGarbageValue));
        logger.debug("Injected copy of {} to {}", obMethod, copy);
    }
    // Handle the rest of the mixin types
    for (Method method : mixinCf.getMethods()) {
        boolean isClinit = "<clinit>".equals(method.getName());
        boolean isInit = "<init>".equals(method.getName());
        boolean hasInject = method.getAnnotations().find(INJECT) != null;
        // You can't annotate clinit, so its always injected
        if ((hasInject && isInit) || isClinit) {
            if (!"()V".equals(method.getDescriptor().toString())) {
                throw new InjectionException("Injected constructors cannot have arguments");
            }
            Method[] originalMethods = cf.getMethods().stream().filter(n -> n.getName().equals(method.getName())).toArray(Method[]::new);
            // If there isn't a <clinit> already just inject ours, otherwise rename it
            // This is always true for <init>
            String name = method.getName();
            if (originalMethods.length > 0) {
                name = "rl$$" + (isInit ? "init" : "clinit");
            }
            String numberlessName = name;
            for (int i = 1; cf.findMethod(name, method.getDescriptor()) != null; i++) {
                name = numberlessName + i;
            }
            Method copy = new Method(cf, name, method.getDescriptor());
            moveCode(copy, method.getCode());
            copy.setAccessFlags(method.getAccessFlags());
            copy.setPrivate();
            assert method.getExceptions().getExceptions().isEmpty();
            // Remove the call to the superclass's ctor
            if (isInit) {
                Instructions instructions = copy.getCode().getInstructions();
                ListIterator<Instruction> listIter = instructions.getInstructions().listIterator();
                for (; listIter.hasNext(); ) {
                    Instruction instr = listIter.next();
                    if (instr instanceof InvokeSpecial) {
                        InvokeSpecial invoke = (InvokeSpecial) instr;
                        assert invoke.getMethod().getName().equals("<init>");
                        listIter.remove();
                        int pops = invoke.getMethod().getType().getArguments().size() + 1;
                        for (int i = 0; i < pops; i++) {
                            listIter.add(new Pop(instructions));
                        }
                        break;
                    }
                }
            }
            setOwnersToTargetClass(mixinCf, cf, copy, shadowFields, copiedMethods);
            cf.addMethod(copy);
            // Call our method at the return point of the matching method(s)
            for (Method om : originalMethods) {
                Instructions instructions = om.getCode().getInstructions();
                ListIterator<Instruction> listIter = instructions.getInstructions().listIterator();
                for (; listIter.hasNext(); ) {
                    Instruction instr = listIter.next();
                    if (instr instanceof ReturnInstruction) {
                        listIter.previous();
                        if (isInit) {
                            listIter.add(new ALoad(instructions, 0));
                            listIter.add(new InvokeSpecial(instructions, copy.getPoolMethod()));
                        } else if (isClinit) {
                            listIter.add(new InvokeStatic(instructions, copy.getPoolMethod()));
                        }
                        listIter.next();
                    }
                }
            }
            logger.debug("Injected mixin method {} to {}", copy, cf);
        } else if (hasInject) {
            // Make sure the method doesn't invoke copied methods
            for (Instruction i : method.getCode().getInstructions().getInstructions()) {
                if (i instanceof InvokeInstruction) {
                    InvokeInstruction ii = (InvokeInstruction) i;
                    if (copiedMethods.containsKey(ii.getMethod())) {
                        throw new InjectionException("Injected methods cannot invoke copied methods");
                    }
                }
            }
            Method copy = new Method(cf, method.getName(), method.getDescriptor());
            moveCode(copy, method.getCode());
            copy.setAccessFlags(method.getAccessFlags());
            copy.setPublic();
            assert method.getExceptions().getExceptions().isEmpty();
            setOwnersToTargetClass(mixinCf, cf, copy, shadowFields, copiedMethods);
            cf.addMethod(copy);
            logger.debug("Injected mixin method {} to {}", copy, cf);
        } else if (method.getAnnotations().find(REPLACE) != null) {
            Annotation replaceAnnotation = method.getAnnotations().find(REPLACE);
            String deobMethodName = (String) replaceAnnotation.getElement().getValue();
            ClassFile deobCf = inject.toDeobClass(cf);
            Method deobMethod = findDeobMethod(deobCf, deobMethodName, method.getDescriptor());
            if (deobMethod == null) {
                throw new InjectionException("Failed to find the deob method " + deobMethodName + " for mixin " + mixinCf);
            }
            if (method.isStatic() != deobMethod.isStatic()) {
                throw new InjectionException("Mixin method " + method + " should be " + (deobMethod.isStatic() ? "static" : "non-static"));
            }
            String obMethodName = DeobAnnotations.getObfuscatedName(deobMethod.getAnnotations());
            Signature obMethodSignature = DeobAnnotations.getObfuscatedSignature(deobMethod);
            // Deob signature is the same as ob signature
            if (obMethodName == null) {
                obMethodName = deobMethod.getName();
            }
            if (obMethodSignature == null) {
                obMethodSignature = deobMethod.getDescriptor();
            }
            // Find the vanilla class where the method to copy is in
            String obClassName = DeobAnnotations.getObfuscatedName(deobMethod.getClassFile().getAnnotations());
            ClassFile obCf = inject.getVanilla().findClass(obClassName);
            Method obMethod = obCf.findMethod(obMethodName, obMethodSignature);
            assert obMethod != null : "obfuscated method " + obMethodName + obMethodSignature + " does not exist";
            if (method.getDescriptor().size() > obMethod.getDescriptor().size()) {
                throw new InjectionException("Mixin methods cannot have more parameters than their corresponding ob method");
            }
            Type returnType = method.getDescriptor().getReturnValue();
            Type deobReturnType = inject.apiTypeToDeobfuscatedType(returnType);
            if (!returnType.equals(deobReturnType)) {
                ClassFile deobReturnTypeClassFile = inject.getDeobfuscated().findClass(deobReturnType.getInternalName());
                if (deobReturnTypeClassFile != null) {
                    ClassFile obReturnTypeClass = inject.toObClass(deobReturnTypeClassFile);
                    Instructions instructions = method.getCode().getInstructions();
                    ListIterator<Instruction> listIter = instructions.getInstructions().listIterator();
                    for (; listIter.hasNext(); ) {
                        Instruction instr = listIter.next();
                        if (instr instanceof ReturnInstruction) {
                            listIter.previous();
                            CheckCast checkCast = new CheckCast(instructions);
                            checkCast.setType(new Type(obReturnTypeClass.getName()));
                            listIter.add(checkCast);
                            listIter.next();
                        }
                    }
                }
            }
            moveCode(obMethod, method.getCode());
            boolean hasGarbageValue = method.getDescriptor().size() != obMethod.getDescriptor().size() && deobMethod.getDescriptor().size() < obMethodSignature.size();
            if (hasGarbageValue) {
                int garbageIndex = obMethod.isStatic() ? obMethod.getDescriptor().size() - 1 : obMethod.getDescriptor().size();
                /*
						If the mixin method doesn't have the garbage parameter,
						the compiler will have produced code that uses the garbage
						parameter's local variable index for other things,
						so we'll have to add 1 to all loads/stores to indices
						that are >= garbageIndex.
					 */
                shiftLocalIndices(obMethod.getCode().getInstructions(), garbageIndex);
            }
            setOwnersToTargetClass(mixinCf, cf, obMethod, shadowFields, copiedMethods);
            logger.debug("Replaced method {} with mixin method {}", obMethod, method);
        }
    }
}

Example 49 with Instruction

use of net.runelite.asm.attributes.code.Instruction in project runelite by runelite.

the class InjectConstruct method injectConstruct.

public void injectConstruct(ClassFile targetClass, java.lang.reflect.Method apiMethod) throws InjectionException {
    logger.info("Injecting construct for {}", apiMethod);
    assert targetClass.findMethod(apiMethod.getName()) == null;
    Class<?> typeToConstruct = apiMethod.getReturnType();
    ClassFile vanillaClass = inject.findVanillaForInterface(typeToConstruct);
    if (vanillaClass == null) {
        throw new InjectionException("Unable to find vanilla class which implements interface " + typeToConstruct);
    }
    Signature sig = inject.javaMethodToSignature(apiMethod);
    Signature constructorSig = new Signature.Builder().addArguments(Stream.of(apiMethod.getParameterTypes()).map(arg -> {
        ClassFile vanilla = inject.findVanillaForInterface(arg);
        if (vanilla != null) {
            return new Type("L" + vanilla.getName() + ";");
        }
        return Inject.classToType(arg);
    }).collect(Collectors.toList())).setReturnType(Type.VOID).build();
    Method vanillaConstructor = vanillaClass.findMethod("<init>", constructorSig);
    if (vanillaConstructor == null) {
        throw new InjectionException("Unable to find constructor for " + vanillaClass.getName() + ".<init>" + constructorSig);
    }
    Method setterMethod = new Method(targetClass, apiMethod.getName(), sig);
    setterMethod.setAccessFlags(ACC_PUBLIC);
    targetClass.addMethod(setterMethod);
    Code code = new Code(setterMethod);
    setterMethod.setCode(code);
    Instructions instructions = code.getInstructions();
    List<Instruction> ins = instructions.getInstructions();
    ins.add(new New(instructions, vanillaClass.getPoolClass()));
    ins.add(new Dup(instructions));
    int idx = 1;
    int parameter = 0;
    for (Type type : vanillaConstructor.getDescriptor().getArguments()) {
        Instruction load = inject.createLoadForTypeIndex(instructions, type, idx);
        idx += type.getSize();
        ins.add(load);
        Type paramType = sig.getTypeOfArg(parameter);
        if (!type.equals(paramType)) {
            CheckCast checkCast = new CheckCast(instructions);
            checkCast.setType(type);
            ins.add(checkCast);
        }
        ++parameter;
    }
    ins.add(new InvokeSpecial(instructions, vanillaConstructor.getPoolMethod()));
    ins.add(new Return(instructions));
}

Example 50 with Instruction

use of net.runelite.asm.attributes.code.Instruction in project runelite by runelite.

the class InjectHook method run.

public void run() {
    Execution e = new Execution(inject.getVanilla());
    e.populateInitialMethods();
    Set<Instruction> done = new HashSet<>();
    Set<Instruction> doneIh = new HashSet<>();
    e.addExecutionVisitor((InstructionContext ic) -> {
        Instruction i = ic.getInstruction();
        Instructions ins = i.getInstructions();
        Code code = ins.getCode();
        Method method = code.getMethod();
        if (method.getName().equals(CLINIT)) {
            return;
        }
        if (!(i instanceof SetFieldInstruction)) {
            return;
        }
        if (!done.add(i)) {
            return;
        }
        SetFieldInstruction sfi = (SetFieldInstruction) i;
        Field fieldBeingSet = sfi.getMyField();
        if (fieldBeingSet == null) {
            return;
        }
        HookInfo hookInfo = hooked.get(fieldBeingSet);
        if (hookInfo == null) {
            return;
        }
        String hookName = hookInfo.fieldName;
        assert hookName != null;
        logger.trace("Found injection location for hook {} at instruction {}", hookName, sfi);
        ++injectedHooks;
        Instruction objectInstruction = new AConstNull(ins);
        StackContext objectStackContext = null;
        if (sfi instanceof PutField) {
            // Object being set on
            StackContext objectStack = ic.getPops().get(1);
            objectStackContext = objectStack;
        }
        int idx = ins.getInstructions().indexOf(sfi);
        assert idx != -1;
        try {
            // idx + 1 to insert after the set
            injectCallback(ins, idx + 1, hookInfo, null, objectStackContext);
        } catch (InjectionException ex) {
            throw new RuntimeException(ex);
        }
    });
    // these look like:
    // getfield
    // iload_0
    // iconst_0
    // iastore
    e.addExecutionVisitor((InstructionContext ic) -> {
        Instruction i = ic.getInstruction();
        Instructions ins = i.getInstructions();
        Code code = ins.getCode();
        Method method = code.getMethod();
        if (method.getName().equals(CLINIT)) {
            return;
        }
        if (!(i instanceof ArrayStore)) {
            return;
        }
        if (!doneIh.add(i)) {
            return;
        }
        ArrayStore as = (ArrayStore) i;
        Field fieldBeingSet = as.getMyField(ic);
        if (fieldBeingSet == null) {
            return;
        }
        HookInfo hookInfo = hooked.get(fieldBeingSet);
        if (hookInfo == null) {
            return;
        }
        String hookName = hookInfo.fieldName;
        // assume this is always at index 1
        StackContext index = ic.getPops().get(1);
        StackContext arrayReference = ic.getPops().get(2);
        InstructionContext arrayReferencePushed = arrayReference.getPushed();
        StackContext objectStackContext = null;
        if (arrayReferencePushed.getInstruction().getType() == InstructionType.GETFIELD) {
            StackContext objectReference = arrayReferencePushed.getPops().get(0);
            objectStackContext = objectReference;
        }
        // inject hook after 'i'
        logger.info("Found array injection location for hook {} at instruction {}", hookName, i);
        ++injectedHooks;
        int idx = ins.getInstructions().indexOf(i);
        assert idx != -1;
        try {
            injectCallback(ins, idx + 1, hookInfo, index, objectStackContext);
        } catch (InjectionException ex) {
            throw new RuntimeException(ex);
        }
    });
    e.run();
}