org.objectweb.asm.tree.MethodNode Java Examples

The following examples show how to use org.objectweb.asm.tree.MethodNode. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source Project: CodeChickenCore   Author: Chicken-Bones   File: DefaultImplementationTransformer.java    License: MIT License 6 votes vote down vote up
public boolean patch(ClassNode cnode) {
	LinkedList<String> names = new LinkedList<String>();
	for(MethodNode method : cnode.methods) {
		ObfMapping m = new ObfMapping(cnode.name, method.name, method.desc).toRuntime();
		names.add(m.s_name+m.s_desc);
	}

	boolean changed = false;
	for(MethodNode impl : impls) {
		if(names.contains(impl.name+impl.desc))
			continue;
		
		MethodNode copy = new MethodNode(impl.access, impl.name, impl.desc, 
				impl.signature, impl.exceptions == null ? null : impl.exceptions.toArray(new String[0]));
		ASMHelper.copy(impl, copy);
		cnode.methods.add(impl);
		changed = true;
	}
	return changed;
}
 
Example #2
Source Project: Diorite   Author: Diorite   File: Transformer.java    License: MIT License 6 votes vote down vote up
private void addGlobalInjectInvokes()
{
    MethodNode codeBefore = new MethodNode();
    MethodNode codeAfter = new MethodNode();
    this.fillMethodInvokes(codeBefore, codeAfter, this.classData);
    for (Entry<MethodNode, TransformerInitMethodData> initEntry : this.inits.entrySet())
    {
        MethodNode init = initEntry.getKey();
        TransformerInitMethodData initPair = initEntry.getValue();
        MethodInsnNode superInvoke = initPair.superInvoke;

        if (codeAfter.instructions.size() > 0)
        {
            for (InsnNode node : initPair.returns)
            {
                init.instructions.insertBefore(node, codeAfter.instructions);
            }
        }
        if (codeBefore.instructions.size() > 0)
        {
            init.instructions.insert(superInvoke, codeBefore.instructions);
        }
    }
}
 
Example #3
Source Project: ForgeHax   Author: fr1kin   File: EntityPlayerSPPatch.java    License: MIT License 6 votes vote down vote up
@Inject(description = "Add hook to disable pushing out of blocks")
public void inject(MethodNode main) {
  AbstractInsnNode preNode = main.instructions.getFirst();
  AbstractInsnNode postNode =
    ASMHelper.findPattern(main.instructions.getFirst(), new int[]{ICONST_0, IRETURN}, "xx");
  
  Objects.requireNonNull(preNode, "Find pattern failed for pre node");
  Objects.requireNonNull(postNode, "Find pattern failed for post node");
  
  LabelNode endJump = new LabelNode();
  
  InsnList insnPre = new InsnList();
  insnPre.add(ASMHelper.call(INVOKESTATIC, TypesHook.Methods.ForgeHaxHooks_onPushOutOfBlocks));
  insnPre.add(new JumpInsnNode(IFNE, endJump));
  
  main.instructions.insertBefore(preNode, insnPre);
  main.instructions.insertBefore(postNode, endJump);
}
 
Example #4
Source Project: custom-bytecode-analyzer   Author: fergarrui   File: CustomMethodVisitor.java    License: GNU General Public License v3.0 6 votes vote down vote up
private boolean isParameterAnnotationFound(List<Annotation> annotationRules, MethodNode methodNode) {
  boolean annotationFound = true;
  List<AnnotationNode> allParameterAnnotations = new ArrayList<>();
  List<AnnotationNode>[] visibleParameterAnnotations = methodNode.visibleParameterAnnotations;
  if (visibleParameterAnnotations != null && visibleParameterAnnotations.length != 0) {
    addIfNotNull(allParameterAnnotations, visibleParameterAnnotations);
  }
  List<AnnotationNode>[] inVisibleParameterAnnotations = methodNode.invisibleParameterAnnotations;
  if (inVisibleParameterAnnotations != null && inVisibleParameterAnnotations.length != 0) {
    addIfNotNull(allParameterAnnotations, inVisibleParameterAnnotations);
  }
  if (annotationRules != null && !annotationRules.isEmpty()) {
    for (Annotation annotationRule : annotationRules) {
      annotationFound &= RuleHelper.containsAnnotation(annotationRule, allParameterAnnotations);
    }
  }

  return annotationFound;
}
 
Example #5
Source Project: AnoleFix   Author: dodola   File: IncrementalChangeVisitor.java    License: MIT License 6 votes vote down vote up
/**
 * Returns the actual method access right or a best guess if we don't have access to the
 * method definition.
 *
 * @param owner the method owner class
 * @param name  the method name
 * @param desc  the method signature
 * @return the {@link AccessRight} for that method.
 */
private AccessRight getMethodAccessRight(String owner, String name, String desc) {
    AccessRight accessRight;
    if (owner.equals(visitedClassName)) {
        MethodNode methodByName = getMethodByName(name, desc);
        if (methodByName == null) {
            // we did not find the method invoked on ourselves, which mean that it really
            // is a parent class method invocation and we just don't have access to it.
            // the most restrictive access right in that case is protected.
            return AccessRight.PROTECTED;
        }
        accessRight = AccessRight.fromNodeAccess(methodByName.access);
    } else {
        // we are accessing another class method, and since we make all protected and
        // package-private methods public, we can safely assume it is public.
        accessRight = AccessRight.PUBLIC;
    }
    return accessRight;
}
 
Example #6
Source Project: bazel   Author: bazelbuild   File: NioBufferRefConverterTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void methodOfNioBufferWithCovariantTypes_afterDesugar(
    @AsmNode(className = "NioBufferInvocations", memberName = "getByteBufferPosition", round = 1)
        MethodNode after) {
  ImmutableList<AbstractInsnNode> methodInvocations =
      Arrays.stream(after.instructions.toArray())
          .filter(insnNode -> insnNode.getType() == METHOD_INSN)
          .collect(toImmutableList());

  assertThat(methodInvocations).hasSize(1);
  MethodInsnNode methodInsnNode = (MethodInsnNode) Iterables.getOnlyElement(methodInvocations);

  assertThat(methodInsnNode.owner).isEqualTo("java/nio/ByteBuffer");
  assertThat(methodInsnNode.name).isEqualTo("position");
  assertThat(methodInsnNode.desc).isEqualTo("(I)Ljava/nio/Buffer;");

  TypeInsnNode typeInsnNode = (TypeInsnNode) methodInsnNode.getNext();
  assertThat(typeInsnNode.getOpcode()).isEqualTo(Opcodes.CHECKCAST);
  assertThat(typeInsnNode.desc).isEqualTo("java/nio/ByteBuffer");

  assertThat(typeInsnNode.getNext().getOpcode()).isEqualTo(Opcodes.ARETURN);
}
 
Example #7
Source Project: pinpoint   Author: naver   File: ASMClassNodeAdapter.java    License: Apache License 2.0 6 votes vote down vote up
public void addGetterMethod(final String methodName, final ASMFieldNodeAdapter fieldNode) {
    Assert.requireNonNull(methodName, "methodName");
    Assert.requireNonNull(fieldNode, "fieldNode");


    // no argument is ().
    final String desc = "()" + fieldNode.getDesc();
    final MethodNode methodNode = new MethodNode(Opcodes.ACC_PUBLIC, methodName, desc, null, null);
    final InsnList instructions = getInsnList(methodNode);
    // load this.
    instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    // get fieldNode.
    instructions.add(new FieldInsnNode(Opcodes.GETFIELD, classNode.name, fieldNode.getName(), fieldNode.getDesc()));
    // return of type.
    final Type type = Type.getType(fieldNode.getDesc());
    instructions.add(new InsnNode(type.getOpcode(Opcodes.IRETURN)));

    addMethodNode0(methodNode);
}
 
Example #8
Source Project: CodeChickenLib   Author: TheCBProject   File: MCStripTransformer.java    License: GNU Lesser General Public License v2.1 6 votes vote down vote up
public static byte[] transform(byte[] bytes) {
    ClassNode cnode = ASMHelper.createClassNode(bytes, ClassReader.EXPAND_FRAMES);

    boolean changed = false;
    Iterator<MethodNode> it = cnode.methods.iterator();
    while (it.hasNext()) {
        MethodNode mnode = it.next();
        ReferenceDetector r = new ReferenceDetector();
        mnode.accept(new RemappingMethodAdapter(mnode.access, mnode.desc, new MethodVisitor(Opcodes.ASM4) {
        }, r));
        if (r.found) {
            it.remove();
            changed = true;
        }
    }
    if (changed) {
        bytes = ASMHelper.createBytes(cnode, 0);
    }
    return bytes;
}
 
Example #9
Source Project: ForgeHax   Author: fr1kin   File: BlockPatch.java    License: MIT License 6 votes vote down vote up
@Inject(description = "Changes in layer code so that we can change it")
public void inject(MethodNode main) {
  AbstractInsnNode node =
    ASMHelper.findPattern(main.instructions.getFirst(), new int[]{INVOKEVIRTUAL}, "x");
  
  Objects.requireNonNull(node, "Find pattern failed for node");
  
  InsnList insnList = new InsnList();
  
  // starting after INVOKEVIRTUAL on Block.getBlockLayer()
  
  insnList.add(new VarInsnNode(ASTORE, 3)); // store the result from getBlockLayer()
  insnList.add(new VarInsnNode(ALOAD, 0)); // push this
  insnList.add(new VarInsnNode(ALOAD, 1)); // push block state
  insnList.add(new VarInsnNode(ALOAD, 3)); // push this.getBlockLayer() result
  insnList.add(
    new VarInsnNode(ALOAD, 2)); // push the block layer of the block we are comparing to
  insnList.add(
    ASMHelper.call(INVOKESTATIC, TypesHook.Methods.ForgeHaxHooks_onRenderBlockInLayer));
  // now our result is on the stack
  
  main.instructions.insert(node, insnList);
}
 
Example #10
Source Project: ForgeHax   Author: fr1kin   File: RenderBoatPatch.java    License: MIT License 6 votes vote down vote up
@Inject(description = "Add hook to set boat yaw when it's rendered")
public void inject(MethodNode main) {
  
  InsnList insnList = new InsnList();
  
  insnList.add(new VarInsnNode(ALOAD, 1)); // load the boat entity
  insnList.add(new VarInsnNode(FLOAD, 8)); // load the boat yaw
  insnList.add(
    ASMHelper.call(
      INVOKESTATIC,
      TypesHook.Methods
        .ForgeHaxHooks_onRenderBoat)); // fire the event and get the value(player
  // rotationYaw) returned by the method in
  // ForgeHaxHooks
  insnList.add(new VarInsnNode(FSTORE, 8)); // store it in entityYaw
  
  main.instructions.insert(insnList); // insert code at the top of the method
}
 
Example #11
Source Project: JByteMod-Beta   Author: GraxCode   File: MyCodeList.java    License: GNU General Public License v2.0 6 votes vote down vote up
protected void duplicate(MethodNode mn, AbstractInsnNode ain) {
  try {
    if (ain instanceof LabelNode) {
      mn.instructions.insert(ain, new LabelNode());
      OpUtils.clearLabelCache();
    } else if (ain instanceof JumpInsnNode) {
      mn.instructions.insert(ain, new JumpInsnNode(ain.getOpcode(), ((JumpInsnNode) ain).label));
    } else {
      mn.instructions.insert(ain, ain.clone(new HashMap<>()));
    }
    MyCodeList.this.loadInstructions(mn);

  } catch (Exception e1) {
    new ErrorDisplay(e1);
  }
}
 
Example #12
Source Project: ForgeHax   Author: fr1kin   File: ChunkRenderDispatcherPatch.java    License: MIT License 6 votes vote down vote up
@Inject(description = "Insert hook before buffer is uploaded")
public void inject(MethodNode main) {
  AbstractInsnNode node =
    ASMHelper.findPattern(
      main.instructions.getFirst(),
      new int[]{
        INVOKESTATIC, IFEQ, 0x00, 0x00, ALOAD,
      },
      "xx??x");
  
  Objects.requireNonNull(node, "Find pattern failed for node");
  
  InsnList insnList = new InsnList();
  insnList.add(new VarInsnNode(ALOAD, 3));
  insnList.add(new VarInsnNode(ALOAD, 2));
  insnList.add(ASMHelper.call(INVOKESTATIC, TypesHook.Methods.ForgeHaxHooks_onChunkUploaded));
  
  main.instructions.insertBefore(node, insnList);
}
 
Example #13
Source Project: zelixkiller   Author: GraxCode   File: ReflectionObfuscationVMT11.java    License: GNU General Public License v3.0 6 votes vote down vote up
@Override
public void transform(JarArchive ja, ClassNode node) {
	if (twoLongType) {
		// init surroundings before decryption
		Outer: for (ClassNode cn : ja.getClasses().values()) {
			for (MethodNode mn : cn.methods) {
				for (AbstractInsnNode ain : mn.instructions.toArray()) {
					if (ain.getOpcode() == INVOKESPECIAL) {
						MethodInsnNode min = (MethodInsnNode) ain;
						if (min.owner.equals(node.name) && min.name.equals("<init>")) {
							try {
								Class.forName(cn.name.replace("/", "."), true, vm);
							} catch (ClassNotFoundException e) {
							}
							continue Outer;
						}
					}
				}
			}
		}
	}
	node.methods.forEach(mn -> removeDynamicCalls(node, mn));
}
 
Example #14
Source Project: javaide   Author: tranleduy2000   File: ClickableViewAccessibilityDetector.java    License: GNU General Public License v3.0 6 votes vote down vote up
@SuppressWarnings("unchecked") // ASM API
public static void scanForAndCheckSetOnTouchListenerCalls(
        ClassContext context,
        ClassNode classNode) {
    List<MethodNode> methods = classNode.methods;
    for (MethodNode methodNode : methods) {
        ListIterator<AbstractInsnNode> iterator = methodNode.instructions.iterator();
        while (iterator.hasNext()) {
            AbstractInsnNode abstractInsnNode = iterator.next();
            if (abstractInsnNode.getType() == AbstractInsnNode.METHOD_INSN) {
                MethodInsnNode methodInsnNode = (MethodInsnNode) abstractInsnNode;
                if (methodInsnNode.name.equals(SET_ON_TOUCH_LISTENER)
                        && methodInsnNode.desc.equals(SET_ON_TOUCH_LISTENER_SIG)) {
                    checkSetOnTouchListenerCall(context, methodNode, methodInsnNode);
                }
            }
        }
    }
}
 
Example #15
Source Project: Mixin   Author: SpongePowered   File: MixinPostProcessor.java    License: MIT License 6 votes vote down vote up
/**
 * "Pass through" a synthetic inner class. Transforms package-private
 * members in the class into public so that they are accessible from their
 * new home in the target class
 */
private void processSyntheticInner(ClassNode classNode) {
    classNode.access |= Opcodes.ACC_PUBLIC;
    
    for (FieldNode field : classNode.fields) {
        if ((field.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) {
            field.access |= Opcodes.ACC_PUBLIC;
        }
    }

    for (MethodNode method : classNode.methods) {
        if ((method.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) {
            method.access |= Opcodes.ACC_PUBLIC;
        }
    }
}
 
Example #16
Source Project: Aceso   Author: meili   File: IncrementalSupportVisitor.java    License: Apache License 2.0 5 votes vote down vote up
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                                 String[] exceptions) {
    AcesoProguardMap.instance().putMethod(visitedClassName, IncrementalTool.getMtdSig(name, desc));
    access = IncrementalTool.transformAccessForInstantRun(access);

    MethodVisitor defaultVisitor = super.visitMethod(access, name, desc, signature, exceptions);
    MethodNode method = getMethodByNameInClass(name, desc, classNode);
    // does the method use blacklisted APIs.
    boolean hasIncompatibleChange = InstantRunMethodVerifier.verifyMethod(method);

    if (hasIncompatibleChange || disableRedirectionForClass
            || !isAccessCompatibleWithInstantRun(access)
            || name.equals(ByteCodeUtils.CLASS_INITIALIZER)) {
        return defaultVisitor;
    } else {
        ArrayList<Type> args = new ArrayList<Type>(Arrays.asList(Type.getArgumentTypes(desc)));
        boolean isStatic = (access & Opcodes.ACC_STATIC) != 0;
        if (!isStatic) {
            args.add(0, Type.getType(Object.class));
        }

        ISMethodVisitor mv = new ISMethodVisitor(defaultVisitor, access, name, desc);
        if (name.equals(ByteCodeUtils.CONSTRUCTOR)) {

        } else {
            mv.addRedirection(new MethodRedirection(
                    new LabelNode(mv.getStartLabel()),
                    visitedClassName,
                    name,
                    desc,
                    args,
                    Type.getReturnType(desc), isStatic));
        }
        method.accept(mv);
        return null;
    }
}
 
Example #17
Source Project: SkyblockAddons   Author: BiscuitDevelopment   File: SoundManagerTransformer.java    License: MIT License 5 votes vote down vote up
@Override
public void transform(ClassNode classNode, String name) {
    for (MethodNode methodNode : classNode.methods) {
        if (TransformerMethod.playSound.matches(methodNode)) {

            // Objective:
            // Find: this.getNormalizedVolume(p_sound, soundpoolentry, soundcategory);
            // Replace method with: SoundManagerHook.getNormalizedVolume(this, p_sound, soundpoolentry, soundcategory);

            Iterator<AbstractInsnNode> iterator = methodNode.instructions.iterator();
            while (iterator.hasNext()) {
                AbstractInsnNode abstractNode = iterator.next();
                if (abstractNode instanceof MethodInsnNode) {
                    MethodInsnNode methodInsnNode = (MethodInsnNode)abstractNode;
                    if (nameMatches(methodInsnNode.owner, TransformerClass.SoundManager.getNameRaw()) && TransformerMethod.getNormalizedVolume.matches(methodInsnNode)) {
                        methodNode.instructions.insertBefore(abstractNode, new MethodInsnNode(Opcodes.INVOKESTATIC, "codes/biscuit/skyblockaddons/asm/hooks/SoundManagerHook", "getNormalizedVolume",
                                "("+TransformerClass.SoundManager.getName()+TransformerClass.ISound.getName()+TransformerClass.SoundPoolEntry.getName()+TransformerClass.SoundCategory.getName()+")F",
                                false)); // Add SoundManagerHook.getNormalizedVolume(this, p_sound, soundpoolentry, soundcategory);

                        iterator.remove(); // Remove the old method call.
                        break;
                    }
                }
            }
            break;
        }
    }
}
 
Example #18
Source Project: pinpoint   Author: naver   File: ASMMethodNodeAdapterAddDelegatorTest.java    License: Apache License 2.0 5 votes vote down vote up
private MethodNode findMethodNode(final String methodName, final List<MethodNode> methodNodes) {
    for (MethodNode methodNode : methodNodes) {
        if (methodNode.name.equals(methodName)) {
            return methodNode;
        }
    }

    return null;
}
 
Example #19
Source Project: JByteMod-Beta   Author: GraxCode   File: FernflowerDecompiler.java    License: GNU General Public License v2.0 5 votes vote down vote up
public String decompile(byte[] b, MethodNode mn) {
  try {
  	//TODO decompile method only
    this.bytes = b;
    HashMap<String, Object> map = new HashMap<>();
    for (String key : options.keySet()) {
      map.put(key, JByteMod.ops.get("ff_" + key).getBoolean() ? "1" : "0");
    }
    Fernflower f = new Fernflower(this, this, map, new PrintStreamLogger(JByteMod.LOGGER));
    StructContext sc = f.getStructContext();
    StructClass cl = new StructClass(b, true, sc.getLoader());
    sc.getClasses().put(cn.name, cl);
    //instead of loading a file use custom bridge, created a few getters
    String fakePath = new File("none.class").getAbsolutePath();
    ContextUnit unit = new ContextUnit(ContextUnit.TYPE_FOLDER, null, fakePath, true, sc.getSaver(), sc.getDecompiledData());
    sc.getUnits().put(fakePath, unit);
    unit.addClass(cl, "none.class");
    sc.getLoader().addClassLink(cn.name, new LazyLoader.Link(LazyLoader.Link.CLASS, fakePath, null));

    f.decompileContext();
    return returned;
  } catch (Exception e) {
    e.printStackTrace();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    e.printStackTrace(pw);
    return sw.toString();
  }
}
 
Example #20
Source Project: maple-ir   Author: LLVM-but-worse   File: OpcodeInfo.java    License: GNU General Public License v3.0 5 votes vote down vote up
/**
 * Retrieve filtered {@link AbstractInsnNode}'s of a {@link MethodNode} and put them into an array.
 * @param m MethodNode to get instructions from.
 * @param filter Filter to filter instructions.
 * @return Filtered {@link AbstractInsnNode}'s.
 */
public static AbstractInsnNode[] getInstructions(MethodNode m, InstructionFilter filter) {
	ArrayList<AbstractInsnNode> insns = new ArrayList<AbstractInsnNode>();
	ListIterator<?> it = m.instructions.iterator();
	while (it.hasNext()) {
		AbstractInsnNode ain = (AbstractInsnNode) it.next();
		if (filter.accept(ain))
			insns.add(ain);
	}
	return insns.toArray(new AbstractInsnNode[insns.size()]);
}
 
Example #21
Source Project: zelixkiller   Author: GraxCode   File: StringObfuscationT11.java    License: GNU General Public License v3.0 5 votes vote down vote up
/**
 * Check for second decryption method (two / three params (int, int, int))
 */
private boolean hasMathMethod(ClassNode cn) {
	for (MethodNode mn : cn.methods) {
		if (InsnUtils.matches(mn.instructions, new int[] { ILOAD, ILOAD, IXOR, SIPUSH, IXOR, LDC })) {
			return true;
		}
	}
	return false;
}
 
Example #22
Source Project: NOVA-Core   Author: NOVA-Team   File: TileEntityTransformer.java    License: GNU Lesser General Public License v3.0 5 votes vote down vote up
@Override
public void transform(ClassNode cnode) {

	Game.logger().info("Transforming TileEntity class for dynamic instance injection.");

	ObfMapping obfMap = new ObfMapping("bcm", "c", "(Lfn;)Lbcm;");
	ObfMapping deobfMap = new ObfMapping("net/minecraft/tileentity/TileEntity", "createAndLoadEntity", "(Lnet/minecraft/nbt/NBTTagCompound;)Lnet/minecraft/tileentity/TileEntity;");

	MethodNode method = ASMHelper.findMethod(obfMap, cnode);

	if (method == null) {
		Game.logger().warn("Lookup {} failed. You are probably in a deobf environment.", obfMap);
		method = ASMHelper.findMethod(deobfMap, cnode);

		if (method == null) {
			throw new IllegalStateException("[NOVA] Lookup " + deobfMap + " failed!");
		}
	}

	Game.logger().info("Transforming method {}", method.name);

	ASMHelper.removeBlock(method.instructions, new InstructionComparator.InsnListSection(method.instructions, 23, 26));

	InsnList list = new InsnList();
	list.add(new VarInsnNode(ALOAD, 0));
	list.add(new VarInsnNode(ALOAD, 2));
	list.add(new MethodInsnNode(INVOKESTATIC, "nova/core/wrapper/mc/forge/v18/asm/StaticForwarder", "loadTileEntityHook", "(Lnet/minecraft/nbt/NBTTagCompound;Ljava/lang/Class;)Lnet/minecraft/tileentity/TileEntity;", false));
	list.add(new VarInsnNode(ASTORE, 1));

	method.instructions.insert(method.instructions.get(22), list);

	Game.logger().info("Injected instruction to method: {}", method.name);
}
 
Example #23
Source Project: AnoleFix   Author: dodola   File: ConstructorDelegationDetector.java    License: MIT License 5 votes vote down vote up
Constructor(VarInsnNode loadThis, int lineForLoad, MethodNode args, MethodInsnNode delegation, MethodNode body) {
    this.loadThis = loadThis;
    this.lineForLoad = lineForLoad;
    this.args = args;
    this.delegation = delegation;
    this.body = body;
}
 
Example #24
Source Project: pinpoint   Author: naver   File: ASMClassNodeAdapter.java    License: Apache License 2.0 5 votes vote down vote up
public ASMMethodNodeAdapter addDelegatorMethod(final ASMMethodNodeAdapter superMethodNode) {
    Assert.requireNonNull(superMethodNode, "superMethodNode");

    final String[] exceptions = getSuperMethodExceptions(superMethodNode);

    final MethodNode rawMethodNode = new MethodNode(superMethodNode.getAccess(), superMethodNode.getName(), superMethodNode.getDesc(), superMethodNode.getSignature(), exceptions);
    final ASMMethodNodeAdapter methodNode = new ASMMethodNodeAdapter(getInternalName(), rawMethodNode);
    methodNode.addDelegator(superMethodNode.getDeclaringClassInternalName());
    addMethodNode0(methodNode.getMethodNode());

    return methodNode;
}
 
Example #25
Source Project: spring-graalvm-native   Author: spring-projects-experimental   File: Type.java    License: Apache License 2.0 5 votes vote down vote up
private boolean hasAnnotation(MethodNode mn, String lAnnotationDescriptor, boolean checkMetaUsage) {
	if (checkMetaUsage) {
		return findMetaAnnotationUsage(toAnnotations(mn.visibleAnnotations), lAnnotationDescriptor);
	} else {
		List<AnnotationNode> vAnnotations = mn.visibleAnnotations;
		if (vAnnotations != null) {
			for (AnnotationNode an : vAnnotations) {
				if (an.desc.equals(lAnnotationDescriptor)) {
					return true;
				}
			}
		}
	}
	return false;
}
 
Example #26
Source Project: zelixkiller   Author: GraxCode   File: ReferenceUtils.java    License: GNU General Public License v3.0 5 votes vote down vote up
/**
 * Finds references to the class's field in the given method.
 * 
 * @param target
 * @param targetField
 * @param method
 * @return
 */
public static List<Reference> getReferences(ClassNode target, FieldNode targetField, ClassNode inThisNode, MethodNode method) {
	List<Reference> references = new ArrayList<Reference>();
	for (AbstractInsnNode ain : method.instructions.toArray()) {
		if (ain.getType() == AbstractInsnNode.FIELD_INSN) {
			FieldInsnNode fin = (FieldInsnNode) ain;
			if (fin.owner.contains(target.name) && fin.name.equals(targetField.name) && fin.desc.equals(targetField.desc)) {
				references.add(new Reference(inThisNode, method, ain));
			}
		}
	}
	return references;
}
 
Example #27
Source Project: obfuscator   Author: alpheratzteam   File: ASMUtil.java    License: MIT License 5 votes vote down vote up
public static MethodNode findMethod(@NotNull ClassNode classNode, String name, String desc) {
    return classNode.methods
            .stream()
            .filter(methodNode -> name.equals(methodNode.name) && desc.equals(methodNode.desc))
            .findAny()
            .orElse(null);
}
 
Example #28
Source Project: javaide   Author: tranleduy2000   File: ApiDetector.java    License: GNU General Public License v3.0 5 votes vote down vote up
private static void report(final ClassContext context, String message, AbstractInsnNode node,
        MethodNode method, String patternStart, String patternEnd, SearchHints hints) {
    int lineNumber = node != null ? ClassContext.findLineNumber(node) : -1;

    // If looking for a constructor, the string we'll see in the source is not the
    // method name (<init>) but the class name
    if (patternStart != null && patternStart.equals(CONSTRUCTOR_NAME)
            && node instanceof MethodInsnNode) {
        if (hints != null) {
            hints = hints.matchConstructor();
        }
        patternStart = ((MethodInsnNode) node).owner;
    }

    if (patternStart != null) {
        int index = patternStart.lastIndexOf('$');
        if (index != -1) {
            patternStart = patternStart.substring(index + 1);
        }
        index = patternStart.lastIndexOf('/');
        if (index != -1) {
            patternStart = patternStart.substring(index + 1);
        }
    }

    Location location = context.getLocationForLine(lineNumber, patternStart, patternEnd,
            hints);
    context.report(UNSUPPORTED, method, node, location, message);
}
 
Example #29
Source Project: android-perftracking   Author: rakutentech   File: DetourLoader.java    License: MIT License 5 votes vote down vote up
public ArrayList<Detour> load(ClassNode cn) {
  ArrayList<Detour> detours = new ArrayList<Detour>();

  for (Object o : cn.methods) {
    MethodNode mn = (MethodNode) o;

    AnnotationNode a = getAnnotation(mn);
    if (a != null) {
      Detour detour = null;
      if (a.desc
          .equals("Lcom/rakuten/tech/mobile/perf/core/annotations/DetourConstructorParameter;")) {
        detour = constructorParameterDetour(cn, mn, a);
      } else if (a.desc.equals("Lcom/rakuten/tech/mobile/perf/core/annotations/DetourCall;")) {
        detour = callDetour(cn, mn, a);
      } else if (a.desc
          .equals("Lcom/rakuten/tech/mobile/perf/core/annotations/DetourStaticCall;")) {
        detour = staticCallDetour(cn, mn, a);
      }

      if (detour != null) {
        _log.debug("Loaded detour for " + detour.matchMethod + detour.matchDesc);
        detours.add(detour);
      }
    }
  }

  return detours;
}
 
Example #30
Source Project: javaide   Author: tranleduy2000   File: ClassContext.java    License: GNU General Public License v3.0 5 votes vote down vote up
/**
 * Finds the line number closest to the given class declaration
 *
 * @param node the method node to get a line number for
 * @return the closest line number, or -1 if not known
 */
public static int findLineNumber(@NonNull ClassNode node) {
    if (node.methods != null && !node.methods.isEmpty()) {
        MethodNode firstMethod = getFirstRealMethod(node);
        if (firstMethod != null) {
            return findLineNumber(firstMethod);
        }
    }

    return -1;
}