下面列出了org.objectweb.asm.tree.AbstractInsnNode#getType ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@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);
}
}
}
}
}
public static boolean insnEqual(AbstractInsnNode node1, AbstractInsnNode node2) {
if (node1.getOpcode() != node2.getOpcode()) {
return false;
}
switch (node2.getType()) {
case VAR_INSN:
return varInsnEqual((VarInsnNode) node1, (VarInsnNode) node2);
case TYPE_INSN:
return typeInsnEqual((TypeInsnNode) node1, (TypeInsnNode) node2);
case FIELD_INSN:
return fieldInsnEqual((FieldInsnNode) node1, (FieldInsnNode) node2);
case METHOD_INSN:
return methodInsnEqual((MethodInsnNode) node1, (MethodInsnNode) node2);
case LDC_INSN:
return ldcInsnEqual((LdcInsnNode) node1, (LdcInsnNode) node2);
case IINC_INSN:
return iincInsnEqual((IincInsnNode) node1, (IincInsnNode) node2);
case INT_INSN:
return intInsnEqual((IntInsnNode) node1, (IntInsnNode) node2);
default:
return true;
}
}
private static InsnListSection insnListMatchesL(InsnList haystack, InsnList needle, int start, HashSet<LabelNode> controlFlowLabels) {
int h = start, n = 0;
for (; h < haystack.size() && n < needle.size(); h++) {
AbstractInsnNode insn = haystack.get(h);
if (insn.getType() == 15) {
continue;
}
if (insn.getType() == 8 && !controlFlowLabels.contains(insn)) {
continue;
}
if (!insnEqual(haystack.get(h), needle.get(n))) {
return null;
}
n++;
}
if (n != needle.size()) {
return null;
}
return new InsnListSection(haystack, start, h - 1);
}
public void populateClassGraph() {
String className = Type.getObjectType(classNode.name).getClassName();
logger.debug("Creating graph for class {}" , className);
for (MethodNode methodNode : classNode.methods) {
String methodName = methodNode.name;
MethodGraph caller = new MethodGraph(className, methodName);
InsnList instructions = methodNode.instructions;
for (int i = 0; i < instructions.size(); i++) {
AbstractInsnNode insnNode = instructions.get(i);
if (insnNode.getType() == AbstractInsnNode.METHOD_INSN) {
MethodInsnNode methodInsnNode = (MethodInsnNode)insnNode;
String calledOwner = Type.getObjectType(methodInsnNode.owner).getClassName();
String calledName = methodInsnNode.name;
MethodGraph called = new MethodGraph(calledOwner, calledName);
Call call = new Call(caller, called);
if (!called.getOwner().equals("java.lang.Object") && !called.getName().equals("<init>")) {
logger.trace("Adding call graph: {}", call.toString());
GraphHolder.addCallGraph(call);
}
}
}
}
}
/**
* Finds the line number closest to the given node
*
* @param node the instruction node to get a line number for
* @return the closest line number, or -1 if not known
*/
public static int findLineNumber(@NonNull AbstractInsnNode node) {
AbstractInsnNode curr = node;
// First search backwards
while (curr != null) {
if (curr.getType() == AbstractInsnNode.LINE) {
return ((LineNumberNode) curr).line;
}
curr = curr.getPrevious();
}
// Then search forwards
curr = node;
while (curr != null) {
if (curr.getType() == AbstractInsnNode.LINE) {
return ((LineNumberNode) curr).line;
}
curr = curr.getNext();
}
return -1;
}
private static InsnListSection insnListMatchesL(InsnList haystack, InsnList needle, int start, HashSet<LabelNode> controlFlowLabels) {
int h = start, n = 0;
for (; h < haystack.size() && n < needle.size(); h++) {
AbstractInsnNode insn = haystack.get(h);
if (insn.getType() == 15) {
continue;
}
if (insn.getType() == 8 && !controlFlowLabels.contains(insn)) {
continue;
}
if (!insnEqual(haystack.get(h), needle.get(n))) {
return null;
}
n++;
}
if (n != needle.size()) {
return null;
}
return new InsnListSection(haystack, start, h - 1);
}
public static boolean insnEqual(AbstractInsnNode node1, AbstractInsnNode node2) {
if (node1.getOpcode() != node2.getOpcode()) {
return false;
}
switch (node2.getType()) {
case VAR_INSN:
return varInsnEqual((VarInsnNode) node1, (VarInsnNode) node2);
case TYPE_INSN:
return typeInsnEqual((TypeInsnNode) node1, (TypeInsnNode) node2);
case FIELD_INSN:
return fieldInsnEqual((FieldInsnNode) node1, (FieldInsnNode) node2);
case METHOD_INSN:
return methodInsnEqual((MethodInsnNode) node1, (MethodInsnNode) node2);
case LDC_INSN:
return ldcInsnEqual((LdcInsnNode) node1, (LdcInsnNode) node2);
case IINC_INSN:
return iincInsnEqual((IincInsnNode) node1, (IincInsnNode) node2);
case INT_INSN:
return intInsnEqual((IntInsnNode) node1, (IntInsnNode) node2);
default:
return true;
}
}
private static InsnListSection insnListMatchesL(InsnList haystack, InsnList needle, int start, HashSet<LabelNode> controlFlowLabels) {
int h = start, n = 0;
for (; h < haystack.size() && n < needle.size(); h++) {
AbstractInsnNode insn = haystack.get(h);
if (insn.getType() == 15) {
continue;
}
if (insn.getType() == 8 && !controlFlowLabels.contains(insn)) {
continue;
}
if (!insnEqual(haystack.get(h), needle.get(n))) {
return null;
}
n++;
}
if (n != needle.size()) {
return null;
}
return new InsnListSection(haystack, start, h - 1);
}
/**
* Respects {@link #INT_WILDCARD} and {@link #WILDCARD} instruction properties.
* Always returns true if {@code a} and {@code b} are label, line number, or frame instructions.
*
* @return Whether or not the given instructions are equivalent.
*/
public boolean areInsnsEqual(AbstractInsnNode a, AbstractInsnNode b)
{
if (a == b)
return true;
if (a == null || b == null)
return false;
if (a.equals(b))
return true;
if (a.getOpcode() != b.getOpcode())
return false;
switch (a.getType())
{
case AbstractInsnNode.VAR_INSN:
return areVarInsnsEqual((VarInsnNode) a, (VarInsnNode) b);
case AbstractInsnNode.TYPE_INSN:
return areTypeInsnsEqual((TypeInsnNode) a, (TypeInsnNode) b);
case AbstractInsnNode.FIELD_INSN:
return areFieldInsnsEqual((FieldInsnNode) a, (FieldInsnNode) b);
case AbstractInsnNode.METHOD_INSN:
return areMethodInsnsEqual((MethodInsnNode) a, (MethodInsnNode) b);
case AbstractInsnNode.LDC_INSN:
return areLdcInsnsEqual((LdcInsnNode) a, (LdcInsnNode) b);
case AbstractInsnNode.IINC_INSN:
return areIincInsnsEqual((IincInsnNode) a, (IincInsnNode) b);
case AbstractInsnNode.INT_INSN:
return areIntInsnsEqual((IntInsnNode) a, (IntInsnNode) b);
default:
return true;
}
}
private boolean isJumpBlock(Block b) {
for (AbstractInsnNode ain : b.getNodes()) {
int type = ain.getType();
if (type != AbstractInsnNode.LABEL && type != AbstractInsnNode.LINE && type != AbstractInsnNode.FRAME && type != AbstractInsnNode.JUMP_INSN) {
return false;
}
}
return true;
}
private ClassNode reconstructStackMapFrames(ClassNode classNode) {
// Remove stackmap frames from method
for (MethodNode methodNode : classNode.methods) {
if (methodNode.instructions == null) {
continue;
}
AbstractInsnNode insn = methodNode.instructions.getFirst();
while (insn != null) {
AbstractInsnNode nextInsn = insn.getNext();
if (insn.getType() == AbstractInsnNode.FRAME) {
methodNode.instructions.remove(insn);
}
insn = nextInsn;
}
}
// Write out the class (recomputes stackmap frames)
ClassWriter cw = new SimpleClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES, classRepo);
classNode.accept(cw);
byte[] temp = cw.toByteArray();
// Read the class back in
ClassReader cr = new ClassReader(temp);
ClassNode newClassNode = new SimpleClassNode();
cr.accept(newClassNode, 0);
// Return the class with newly computed stackmap frames
return newClassNode;
}
@Override
public String toString() {
if (text == null) {
StringBuilder sb = new StringBuilder();
for (AbstractInsnNode ain : nodes) {
if(ain.getType() == AbstractInsnNode.FRAME) {
continue;
}
sb.append(InstructionFormatting.nodeToString(mn, ain));
sb.append("\n");
}
text = sb.toString();
}
return text;
}
/**
* Finds references to the class's method in the given method.
*
* @param target
* @param targetMethod
* @param method
* @return
*/
public static List<Reference> getReferences(ClassNode target, MethodNode targetMethod, ClassNode inThisNode, MethodNode method) {
List<Reference> references = new ArrayList<Reference>();
for (AbstractInsnNode ain : method.instructions.toArray()) {
if (ain.getType() == AbstractInsnNode.METHOD_INSN) {
MethodInsnNode min = (MethodInsnNode) ain;
if (min.owner.contains(target.name) && min.name.equals(targetMethod.name) && min.desc.equals(targetMethod.desc)) {
references.add(new Reference(inThisNode, method, ain));
}
}
}
return references;
}
public static String toString(AbstractInsnNode ain) {
String s = getOpcodeText(ain.getOpcode());
switch (ain.getType()) {
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fin = (FieldInsnNode) ain;
return s + " " + fin.owner + "#" + fin.name + " " + fin.desc;
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode min = (MethodInsnNode) ain;
return s + " " + min.owner + "#" + min.name + min.desc;
case AbstractInsnNode.VAR_INSN:
VarInsnNode vin = (VarInsnNode) ain;
return s + " " + vin.var;
case AbstractInsnNode.TYPE_INSN:
TypeInsnNode tin = (TypeInsnNode) ain;
return s + " " + tin.desc;
case AbstractInsnNode.JUMP_INSN:
JumpInsnNode jin = (JumpInsnNode) ain;
return s + " " + getIndex(jin.label);
case AbstractInsnNode.LDC_INSN:
LdcInsnNode ldc = (LdcInsnNode) ain;
return s + " " + ldc.cst.toString();
case AbstractInsnNode.INT_INSN:
return s + " " + getIntValue(ain);
case AbstractInsnNode.IINC_INSN:
IincInsnNode iinc = (IincInsnNode) ain;
return s + " " + iinc.var + " +" + iinc.incr;
case AbstractInsnNode.FRAME:
FrameNode fn = (FrameNode) ain;
return s + " " + getOpcodeText(fn.type) + " " + fn.local.size() + " " + fn.stack.size();
case AbstractInsnNode.LABEL:
LabelNode ln = (LabelNode) ain;
return s + " " + getIndex(ln);
}
return s;
}
@SuppressWarnings("deprecation")
private void _visitInsn(AbstractInsnNode insn) {
switch (insn.getType()) {
case 0:
visitInsn(insn.getOpcode());
break;
case 1:
IntInsnNode iinsn = (IntInsnNode) insn;
visitIntInsn(iinsn.getOpcode(), iinsn.operand);
break;
case 2:
VarInsnNode vinsn = (VarInsnNode) insn;
visitVarInsn(vinsn.getOpcode(), vinsn.var);
break;
case 3:
TypeInsnNode tinsn = (TypeInsnNode) insn;
visitTypeInsn(tinsn.getOpcode(), tinsn.desc);
break;
case 4:
FieldInsnNode finsn = (FieldInsnNode) insn;
visitFieldInsn(finsn.getOpcode(), finsn.owner, finsn.name, finsn.desc);
break;
case 5:
MethodInsnNode minsn = (MethodInsnNode) insn;
visitMethodInsn(minsn.getOpcode(), minsn.owner, minsn.name, minsn.desc);
break;
case 6:
InvokeDynamicInsnNode idinsn = (InvokeDynamicInsnNode) insn;
visitInvokeDynamicInsn(idinsn.name, idinsn.desc, idinsn.bsm, idinsn.bsmArgs);
break;
case 7:
JumpInsnNode jinsn = (JumpInsnNode) insn;
visitJumpInsn(jinsn.getOpcode(), jinsn.label.getLabel());
break;
case 8:
LabelNode linsn = (LabelNode) insn;
visitLabel(linsn.getLabel());
break;
case 9:
LdcInsnNode ldcinsn = (LdcInsnNode) insn;
visitLdcInsn(ldcinsn.cst);
break;
case 10:
IincInsnNode iiinsn = (IincInsnNode) insn;
visitIincInsn(iiinsn.var, iiinsn.incr);
break;
case 11:
TableSwitchInsnNode tsinsn = (TableSwitchInsnNode) insn;
Label[] tslables = new Label[tsinsn.labels.size()];
for (int i = 0; i < tslables.length; i++) {
tslables[i] = tsinsn.labels.get(i).getLabel();
}
visitTableSwitchInsn(tsinsn.min, tsinsn.max, tsinsn.dflt.getLabel(), tslables);
break;
case 12:
LookupSwitchInsnNode lsinsn = (LookupSwitchInsnNode) insn;
Label[] lslables = new Label[lsinsn.labels.size()];
for (int i = 0; i < lslables.length; i++) {
lslables[i] = lsinsn.labels.get(i).getLabel();
}
int[] lskeys = new int[lsinsn.keys.size()];
for (int i = 0; i < lskeys.length; i++) {
lskeys[i] = lsinsn.keys.get(i);
}
visitLookupSwitchInsn(lsinsn.dflt.getLabel(), lskeys, lslables);
break;
case 13:
MultiANewArrayInsnNode ainsn = (MultiANewArrayInsnNode) insn;
visitMultiANewArrayInsn(ainsn.desc, ainsn.dims);
break;
case 14:
FrameNode fnode = (FrameNode) insn;
switch (fnode.type) {
case -1:
case 0:
visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), fnode.stack.size(), fnode.stack.toArray());
break;
case 1:
visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), 0, null);
break;
case 2:
visitFrame(fnode.type, fnode.local.size(), null, 0, null);
break;
case 3:
visitFrame(fnode.type, 0, null, 0, null);
break;
case 4:
visitFrame(fnode.type, 0, null, 1, fnode.stack.toArray());
}
break;
case 15:
LineNumberNode lnode = (LineNumberNode) insn;
visitLineNumber(lnode.line, lnode.start.getLabel());
break;
}
}
public boolean walkMethod(ClassNode clinit_cn, MethodNode mn, HashSet<MethodNode> method_callees) {
boolean safe = true;
InsnList insns = mn.instructions;
for (int i = 0; safe && i < insns.size(); i++) {
AbstractInsnNode ain = insns.get(i);
switch (ain.getType()) {
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fin = (FieldInsnNode) ain;
safe = handleField(clinit_cn, fin);
break;
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode min = (MethodInsnNode) ain;
HashSet<MethodNode> invoke_callees = handleInvoke(clinit_cn, min);
if (invoke_callees == null) {
safe = false;
} else {
for (MethodNode callee : invoke_callees)
method_callees.add(callee);
}
break;
// deals with java.lang.invoke.MethodHandle
// I think this is like function pointer aka not safe
case AbstractInsnNode.INVOKE_DYNAMIC_INSN:
safe = false;
bad_invoke_dynamic++;
if (log_enable)
log_ln("[unsafe] class: " + clinit_cn.name + " [cause:invoke_dynamic]");
break;
case AbstractInsnNode.INSN:
// throwing things can hurt people so not safe
// most likely throw logic depends on a reference, so we should
// already handle this implicitly, but no harm in safety first
if (ain.getOpcode() == ATHROW) {
safe = false;
bad_throw++;
if (log_enable)
log_ln("[unsafe] class: " + clinit_cn.name + " [cause:throw]");
}
break;
default:
break;
}
}
return safe;
}
public ASMBlock applyLabels(InsnListSection list2) {
if(labels.isEmpty())
return new ASMBlock(list2);
Set<LabelNode> cFlowLabels1 = labels.values();
Set<LabelNode> cFlowLabels2 = InsnComparator.getControlFlowLabels(list2);
ASMBlock block = new ASMBlock(list2);
HashMap<LabelNode, LabelNode> labelMap = new HashMap<LabelNode, LabelNode>();
for(int i = 0, k = 0; i < list.size() && k < list2.size(); ) {
AbstractInsnNode insn1 = list.get(i);
if(!InsnComparator.insnImportant(insn1, cFlowLabels1)) {
i++;
continue;
}
AbstractInsnNode insn2 = list2.get(k);
if(!InsnComparator.insnImportant(insn2, cFlowLabels2)) {
k++;
continue;
}
if(insn1.getOpcode() != insn2.getOpcode())
throw new IllegalArgumentException("Lists do not match:\n"+list+"\n\n"+list2);
switch(insn1.getType()) {
case LABEL:
labelMap.put((LabelNode) insn1, (LabelNode) insn2);
break;
case JUMP_INSN:
labelMap.put(((JumpInsnNode) insn1).label, ((JumpInsnNode) insn2).label);
break;
}
i++; k++;
}
for(Entry<String, LabelNode> entry : labels.entrySet())
block.labels.put(entry.getKey(), labelMap.get(entry.getValue()));
return block;
}
@Override
protected Void doInBackground() throws Exception {
LazyListModel<SearchEntry> model = new LazyListModel<SearchEntry>();
Collection<ClassNode> values = jbm.getFile().getClasses().values();
double size = values.size();
double i = 0;
boolean exact = this.exact;
for (ClassNode cn : values) {
for (MethodNode mn : cn.methods) {
for (AbstractInsnNode ain : mn.instructions) {
if (field) {
if (ain.getType() == AbstractInsnNode.FIELD_INSN) {
FieldInsnNode fin = (FieldInsnNode) ain;
if (exact) {
if (fin.owner.equals(owner) && fin.name.equals(name) && fin.desc.equals(desc)) {
model.addElement(new SearchEntry(cn, mn, fin));
}
} else {
if (fin.owner.contains(owner) && fin.name.contains(name) && fin.desc.contains(desc)) {
model.addElement(new SearchEntry(cn, mn, fin));
}
}
}
} else {
if (ain.getType() == AbstractInsnNode.METHOD_INSN) {
MethodInsnNode min = (MethodInsnNode) ain;
if (exact) {
if (min.owner.equals(owner) && min.name.equals(name) && min.desc.equals(desc)) {
model.addElement(new SearchEntry(cn, mn, min));
}
} else {
if (min.owner.contains(owner) && min.name.contains(name) && min.desc.contains(desc)) {
model.addElement(new SearchEntry(cn, mn, min));
}
}
}
}
}
}
publish(Math.min((int) (i++ / size * 100d) + 1, 100));
}
sl.setModel(model);
publish(100);
return null;
}
private void _visitInsn(AbstractInsnNode insn) {
switch (insn.getType()) {
case 0:
visitInsn(insn.getOpcode());
break;
case 1:
IntInsnNode iinsn = (IntInsnNode) insn;
visitIntInsn(iinsn.getOpcode(), iinsn.operand);
break;
case 2:
VarInsnNode vinsn = (VarInsnNode) insn;
visitVarInsn(vinsn.getOpcode(), vinsn.var);
break;
case 3:
TypeInsnNode tinsn = (TypeInsnNode) insn;
visitTypeInsn(tinsn.getOpcode(), tinsn.desc);
break;
case 4:
FieldInsnNode finsn = (FieldInsnNode) insn;
visitFieldInsn(finsn.getOpcode(), finsn.owner, finsn.name, finsn.desc);
break;
case 5:
MethodInsnNode minsn = (MethodInsnNode) insn;
visitMethodInsn(minsn.getOpcode(), minsn.owner, minsn.name, minsn.desc);
break;
case 6:
InvokeDynamicInsnNode idinsn = (InvokeDynamicInsnNode) insn;
visitInvokeDynamicInsn(idinsn.name, idinsn.desc, idinsn.bsm, idinsn.bsmArgs);
break;
case 7:
JumpInsnNode jinsn = (JumpInsnNode) insn;
visitJumpInsn(jinsn.getOpcode(), jinsn.label.getLabel());
break;
case 8:
LabelNode linsn = (LabelNode) insn;
visitLabel(linsn.getLabel());
break;
case 9:
LdcInsnNode ldcinsn = (LdcInsnNode) insn;
visitLdcInsn(ldcinsn.cst);
break;
case 10:
IincInsnNode iiinsn = (IincInsnNode) insn;
visitIincInsn(iiinsn.var, iiinsn.incr);
break;
case 11:
TableSwitchInsnNode tsinsn = (TableSwitchInsnNode) insn;
Label[] tslables = new Label[tsinsn.labels.size()];
for (int i = 0; i < tslables.length; i++) {
tslables[i] = tsinsn.labels.get(i).getLabel();
}
visitTableSwitchInsn(tsinsn.min, tsinsn.max, tsinsn.dflt.getLabel(), tslables);
break;
case 12:
LookupSwitchInsnNode lsinsn = (LookupSwitchInsnNode) insn;
Label[] lslables = new Label[lsinsn.labels.size()];
for (int i = 0; i < lslables.length; i++) {
lslables[i] = lsinsn.labels.get(i).getLabel();
}
int[] lskeys = new int[lsinsn.keys.size()];
for (int i = 0; i < lskeys.length; i++) {
lskeys[i] = lsinsn.keys.get(i);
}
visitLookupSwitchInsn(lsinsn.dflt.getLabel(), lskeys, lslables);
break;
case 13:
MultiANewArrayInsnNode ainsn = (MultiANewArrayInsnNode) insn;
visitMultiANewArrayInsn(ainsn.desc, ainsn.dims);
break;
case 14:
FrameNode fnode = (FrameNode) insn;
switch (fnode.type) {
case -1:
case 0:
visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), fnode.stack.size(), fnode.stack.toArray());
break;
case 1:
visitFrame(fnode.type, fnode.local.size(), fnode.local.toArray(), 0, null);
break;
case 2:
visitFrame(fnode.type, fnode.local.size(), null, 0, null);
break;
case 3:
visitFrame(fnode.type, 0, null, 0, null);
break;
case 4:
visitFrame(fnode.type, 0, null, 1, fnode.stack.toArray());
}
break;
case 15:
LineNumberNode lnode = (LineNumberNode) insn;
visitLineNumber(lnode.line, lnode.start.getLabel());
break;
}
}
private static boolean isLabelOrJump(final AbstractInsnNode node)
{
return node.getType() == AbstractInsnNode.LABEL
|| node.getType() == AbstractInsnNode.JUMP_INSN;
}