Java Code Examples for org.objectweb.asm.tree.AbstractInsnNode#FIELD_INSN
The following examples show how to use
org.objectweb.asm.tree.AbstractInsnNode#FIELD_INSN .
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 File: OpcodeFormatting.java From Cafebabe with GNU General Public License v3.0 | 5 votes |
|
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.MULTIANEWARRAY_INSN:
MultiANewArrayInsnNode mnin = (MultiANewArrayInsnNode) ain;
return s + " " + mnin.dims + " " + mnin.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;
}
Example 2
| Source File: SuperClassRedirection.java From Stark with Apache License 2.0 | 5 votes |
|
public static void redirect(ClassNode classNode) {
if (SUPER_REDIRECT_MAP.keySet().contains(classNode.superName)) {
if (SUPER_REDIRECT_MAP.values().contains(classNode.name)) {
return;
}
String originSuper = classNode.superName;
String redirectSuper = SUPER_REDIRECT_MAP.get(classNode.superName);
classNode.superName = redirectSuper;
for (MethodNode methodNode : (List<MethodNode>) classNode.methods) {
AbstractInsnNode insn = methodNode.instructions.getFirst();
while (insn != null) {
switch (insn.getType()) {
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fieldInsnNode = (FieldInsnNode) insn;
if (fieldInsnNode.owner.equals(originSuper)) {
fieldInsnNode.owner = redirectSuper;
}
break;
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode methodInsnNode = (MethodInsnNode) insn;
if (methodInsnNode.owner.equals(originSuper)) {
methodInsnNode.owner = redirectSuper;
}
break;
case AbstractInsnNode.INVOKE_DYNAMIC_INSN:
break;
}
insn = insn.getNext();
}
}
}
}
Example 3
| Source File: CorrelationMapper.java From zelixkiller with GNU General Public License v3.0 | 5 votes |
|
/**
* Get's a member's class types from its description. Best for methods.
*
* @param member
* @param map
* @return
*/
private static List<MappedClass> getTypesFromMember(MappedMember member, Map<String, MappedClass> map) {
List<String> names = RegexUtils.matchDescriptionClasses(member.getDesc());
if (member.isMethod()) {
for (AbstractInsnNode ain : member.getMethodNode().instructions.toArray()) {
if (ain.getType() == AbstractInsnNode.METHOD_INSN) {
MethodInsnNode min = (MethodInsnNode) ain;
names.addAll(RegexUtils.matchDescriptionClasses(min.desc));
names.add(min.owner);
} else if (ain.getType() == AbstractInsnNode.FIELD_INSN) {
FieldInsnNode fin = (FieldInsnNode) ain;
names.addAll(RegexUtils.matchDescriptionClasses(fin.desc));
names.add(fin.owner);
} else if (ain.getType() == AbstractInsnNode.TYPE_INSN) {
TypeInsnNode tin = (TypeInsnNode) ain;
names.addAll(RegexUtils.matchDescriptionClasses(tin.desc));
} else if (ain.getType() == AbstractInsnNode.LDC_INSN) {
LdcInsnNode ldc = (LdcInsnNode) ain;
if (ldc.cst instanceof Type) {
Type t = (Type) ldc.cst;
names.add(t.getClassName().replace(".", "/"));
}
}
}
}
if (names.size() == 0) {
return null;
}
List<MappedClass> classes = new ArrayList<MappedClass>();
for (String name : names) {
if (!map.containsKey(name)) {
continue;
}
classes.add(map.get(name));
}
return classes;
}
Example 4
| Source File: ReferenceUtils.java From zelixkiller with GNU General Public License v3.0 | 5 votes |
|
/**
* Finds references to the class in the given method.
*
* @param target
* @param method
* @return
*/
public static List<Reference> getReferences(ClassNode target, ClassNode inThisNode, MethodNode method) {
String targetDesc = target.name;
List<Reference> references = new ArrayList<Reference>();
for (AbstractInsnNode ain : method.instructions.toArray()) {
switch (ain.getType()) {
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode min = (MethodInsnNode) ain;
if (min.desc.contains(targetDesc) || min.owner.contains(targetDesc)) {
references.add(new Reference(inThisNode, method, ain));
}
break;
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fin = (FieldInsnNode) ain;
if (fin.desc.contains(targetDesc) || fin.owner.contains(targetDesc)) {
references.add(new Reference(inThisNode, method, ain));
}
break;
case AbstractInsnNode.TYPE_INSN:
TypeInsnNode tin = (TypeInsnNode) ain;
if (tin.desc.contains(targetDesc)) {
references.add(new Reference(inThisNode, method, ain));
}
break;
}
}
return references;
}
Example 5
| Source File: ReferenceUtils.java From zelixkiller with GNU General Public License v3.0 | 5 votes |
|
/**
* 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 6
| Source File: OpUtils.java From zelixkiller with GNU General Public License v3.0 | 5 votes |
|
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;
}
Example 7
| Source File: LintDriver.java From javaide with GNU General Public License v3.0 | 5 votes |
|
/**
* Returns whether the given issue is suppressed in the given method.
*
* @param issue the issue to be checked, or null to just check for "all"
* @param classNode the class containing the issue
* @param method the method containing the issue
* @param instruction the instruction within the method, if any
* @return true if there is a suppress annotation covering the specific
* issue on this method
*/
public boolean isSuppressed(
@Nullable Issue issue,
@NonNull ClassNode classNode,
@NonNull MethodNode method,
@Nullable AbstractInsnNode instruction) {
if (method.invisibleAnnotations != null) {
@SuppressWarnings("unchecked")
List<AnnotationNode> annotations = method.invisibleAnnotations;
return isSuppressed(issue, annotations);
}
// Initializations of fields end up placed in generated methods (<init>
// for members and <clinit> for static fields).
if (instruction != null && method.name.charAt(0) == '<') {
AbstractInsnNode next = LintUtils.getNextInstruction(instruction);
if (next != null && next.getType() == AbstractInsnNode.FIELD_INSN) {
FieldInsnNode fieldRef = (FieldInsnNode) next;
FieldNode field = findField(classNode, fieldRef.owner, fieldRef.name);
if (field != null && isSuppressed(issue, field)) {
return true;
}
} else if (classNode.outerClass != null && classNode.outerMethod == null
&& isAnonymousClass(classNode)) {
if (isSuppressed(issue, classNode)) {
return true;
}
}
}
return false;
}
Example 8
| Source File: OpUtils.java From JByteMod-Beta with GNU General Public License v2.0 | 5 votes |
|
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.MULTIANEWARRAY_INSN:
MultiANewArrayInsnNode mnin = (MultiANewArrayInsnNode) ain;
return s + " " + mnin.dims + " " + mnin.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;
}
Example 9
| Source File: InsnComparator.java From TFC2 with GNU General Public License v3.0 | 5 votes |
|
/**
* 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;
}
}
Example 10
| Source File: Colors.java From Cafebabe with GNU General Public License v3.0 | 4 votes |
|
public static String getColor(int type, int opcode) {
switch (opcode) {
case ATHROW:
case IRETURN:
case LRETURN:
case FRETURN:
case DRETURN:
case ARETURN:
case RETURN:
return "#4d0000";
case ACONST_NULL:
case ICONST_M1:
case ICONST_0:
case ICONST_1:
case ICONST_2:
case ICONST_3:
case ICONST_4:
case ICONST_5:
case LCONST_0:
case LCONST_1:
case FCONST_0:
case FCONST_1:
case FCONST_2:
case DCONST_0:
case DCONST_1:
return "#005733";
}
switch (type) {
case AbstractInsnNode.FIELD_INSN:
return "#44004d";
case AbstractInsnNode.METHOD_INSN:
return "#14004d";
case AbstractInsnNode.INT_INSN:
case AbstractInsnNode.LDC_INSN:
return "#004d40";
case AbstractInsnNode.VAR_INSN:
return "#6a3e3e";
case AbstractInsnNode.JUMP_INSN:
return "#003d4d";
case AbstractInsnNode.TYPE_INSN:
return "#474d00";
default:
return "#000";
}
}
Example 11
| Source File: InstrUtils.java From JByteMod-Beta with GNU General Public License v2.0 | 4 votes |
|
public static String toString(AbstractInsnNode ain) {
String opc = TextUtils.toBold(OpUtils.getOpcodeText(ain.getOpcode()).toLowerCase()) + " ";
switch (ain.getType()) {
case AbstractInsnNode.LABEL:
opc = TextUtils.toLight("label " + OpUtils.getLabelIndex((LabelNode) ain));
break;
case AbstractInsnNode.LINE:
opc = TextUtils.toLight("line " + ((LineNumberNode) ain).line);
break;
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fin = (FieldInsnNode) ain;
opc += getDisplayType(TextUtils.escape(fin.desc), true) + " " + getDisplayClassRed(TextUtils.escape(fin.owner))
+ "." + fin.name;
break;
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode min = (MethodInsnNode) ain;
if (min.desc.contains(")")) {
opc += getDisplayType(min.desc.split("\\)")[1], true);
} else {
opc += min.desc;
}
opc += " " + getDisplayClassRed(TextUtils.escape(min.owner)) + "." + TextUtils.escape(min.name) + "("
+ getDisplayArgs(TextUtils.escape(min.desc)) + ")";
break;
case AbstractInsnNode.VAR_INSN:
VarInsnNode vin = (VarInsnNode) ain;
opc += vin.var;
break;
case AbstractInsnNode.TYPE_INSN:
TypeInsnNode tin = (TypeInsnNode) ain;
String esc = TextUtils.escape(tin.desc);
if (esc.endsWith(";") && esc.startsWith("L")) {
opc += TextUtils.addTag(esc, "font color=" + primColor.getString());
} else {
opc += getDisplayClass(esc);
}
break;
case AbstractInsnNode.MULTIANEWARRAY_INSN:
MultiANewArrayInsnNode mnin = (MultiANewArrayInsnNode) ain;
opc += mnin.dims + " " + getDisplayType(TextUtils.escape(mnin.desc), true);
break;
case AbstractInsnNode.JUMP_INSN:
JumpInsnNode jin = (JumpInsnNode) ain;
opc += OpUtils.getLabelIndex(jin.label);
break;
case AbstractInsnNode.LDC_INSN:
LdcInsnNode ldc = (LdcInsnNode) ain;
opc += TextUtils.addTag(ldc.cst.getClass().getSimpleName(), "font color=" + primColor.getString()) + " ";
if (ldc.cst instanceof String)
opc += TextUtils.addTag("\"" + TextUtils.escape(ldc.cst.toString()) + "\"", "font color=#559955");
else {
opc += ldc.cst.toString();
}
break;
case AbstractInsnNode.INT_INSN:
opc += OpUtils.getIntValue(ain);
break;
case AbstractInsnNode.IINC_INSN:
IincInsnNode iinc = (IincInsnNode) ain;
opc += iinc.var + " " + iinc.incr;
break;
case AbstractInsnNode.FRAME:
FrameNode fn = (FrameNode) ain;
opc = TextUtils
.toLight(OpUtils.getFrameType(fn.type).toLowerCase() + " " + fn.local.size() + " " + fn.stack.size());
break;
case AbstractInsnNode.TABLESWITCH_INSN:
TableSwitchInsnNode tsin = (TableSwitchInsnNode) ain;
if (tsin.dflt != null) {
opc += TextUtils.addTag("L" + OpUtils.getLabelIndex(tsin.dflt), "font color=" + secColor.getString());
}
if (tsin.labels.size() < 20) {
for (LabelNode l : tsin.labels) {
opc += " " + TextUtils.addTag("L" + OpUtils.getLabelIndex(l), "font color=" + primColor.getString());
}
} else {
opc += " " + TextUtils.addTag(tsin.labels.size() + " cases", "font color=" + primColor.getString());
}
break;
case AbstractInsnNode.INVOKE_DYNAMIC_INSN:
InvokeDynamicInsnNode idin = (InvokeDynamicInsnNode) ain;
Object[] arr = idin.bsmArgs;
if (arr.length > 1) {
Object o = arr[1];
if (o instanceof Handle) {
Handle h = (Handle) o;
opc += getDisplayType(h.getDesc().split("\\)")[1], true) + " "
+ getDisplayClassRed(TextUtils.escape(h.getOwner())) + "." + TextUtils.escape(h.getName()) + "("
+ getDisplayArgs(TextUtils.escape(h.getDesc())) + ")";
}
} else {
opc += TextUtils.addTag(TextUtils.escape(idin.name), "font color=" + primColor.getString()) + " "
+ TextUtils.escape(idin.desc);
}
break;
}
return opc;
}
Example 12
| Source File: InstrUtils.java From JByteMod-Beta with GNU General Public License v2.0 | 4 votes |
|
public static String toEasyString(AbstractInsnNode ain) {
String opc = OpUtils.getOpcodeText(ain.getOpcode()).toLowerCase() + " ";
switch (ain.getType()) {
case AbstractInsnNode.LABEL:
opc = "label " + OpUtils.getLabelIndex((LabelNode) ain);
break;
case AbstractInsnNode.LINE:
opc = "line " + ((LineNumberNode) ain).line;
break;
case AbstractInsnNode.FIELD_INSN:
FieldInsnNode fin = (FieldInsnNode) ain;
opc += getDisplayType(fin.desc, false) + " " + getDisplayClassEasy(fin.owner) + "." + fin.name;
break;
case AbstractInsnNode.METHOD_INSN:
MethodInsnNode min = (MethodInsnNode) ain;
opc += getDisplayType(min.desc.split("\\)")[1], false) + " " + getDisplayClassEasy(min.owner) + "." + min.name
+ "(" + getDisplayArgsEasy(min.desc) + ")";
break;
case AbstractInsnNode.VAR_INSN:
VarInsnNode vin = (VarInsnNode) ain;
opc += vin.var;
break;
case AbstractInsnNode.MULTIANEWARRAY_INSN:
MultiANewArrayInsnNode mnin = (MultiANewArrayInsnNode) ain;
opc += mnin.dims + " " + getDisplayType(mnin.desc, false);
break;
case AbstractInsnNode.TYPE_INSN:
TypeInsnNode tin = (TypeInsnNode) ain;
String esc = tin.desc;
if (esc.endsWith(";") && esc.startsWith("L")) {
opc += esc;
} else {
opc += getDisplayClassEasy(esc);
}
break;
case AbstractInsnNode.JUMP_INSN:
JumpInsnNode jin = (JumpInsnNode) ain;
opc += OpUtils.getLabelIndex(jin.label);
break;
case AbstractInsnNode.LDC_INSN:
LdcInsnNode ldc = (LdcInsnNode) ain;
opc += ldc.cst.getClass().getSimpleName() + " ";
if (ldc.cst instanceof String)
opc += "\"" + ldc.cst.toString() + "\"";
else {
opc += ldc.cst.toString();
}
break;
case AbstractInsnNode.INT_INSN:
opc += OpUtils.getIntValue(ain);
break;
case AbstractInsnNode.IINC_INSN:
IincInsnNode iinc = (IincInsnNode) ain;
opc += iinc.var + " " + iinc.incr;
break;
case AbstractInsnNode.FRAME:
FrameNode fn = (FrameNode) ain;
opc = OpUtils.getOpcodeText(fn.type).toLowerCase() + " " + fn.local.size() + " " + fn.stack.size();
break;
case AbstractInsnNode.TABLESWITCH_INSN:
TableSwitchInsnNode tsin = (TableSwitchInsnNode) ain;
if (tsin.dflt != null) {
opc += "L" + OpUtils.getLabelIndex(tsin.dflt);
}
if (tsin.labels.size() < 20) {
for (LabelNode l : tsin.labels) {
opc += " " + "L" + OpUtils.getLabelIndex(l);
}
} else {
opc += " " + tsin.labels.size() + " cases";
}
break;
case AbstractInsnNode.INVOKE_DYNAMIC_INSN:
InvokeDynamicInsnNode idin = (InvokeDynamicInsnNode) ain;
opc += idin.name + " " + idin.desc;
break;
}
return opc;
}
Example 13
| Source File: ReferenceTask.java From JByteMod-Beta with GNU General Public License v2.0 | 4 votes |
|
@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;
}
Example 14
| Source File: StaticAnalysis.java From hottub with GNU General Public License v2.0 | 4 votes |
|
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;
}
