private void updateState(IntInsnNode insn) { switch (insn.getOpcode()) { case Opcodes.BIPUSH: case Opcodes.SIPUSH: { state.push(Type.INT_TYPE); break; } case Opcodes.NEWARRAY: { String desc = arrayTypeDesc(insn.operand); Type type = Type.getType(desc); state.pop(); state.push(type); break; } default: throw new Unreachable("Unexpected IntInsn opcode: " + insn.getOpcode()); } }
private void build(IntInsnNode insn, IRBuilder builder) { switch (insn.getOpcode()) { case Opcodes.BIPUSH: case Opcodes.SIPUSH: { int dest = state.push(Type.INT_TYPE); builder.addIntConst(dest, insn.operand); break; } case Opcodes.NEWARRAY: { String desc = arrayTypeDesc(insn.operand); Type type = Type.getType(desc); DexType dexType = application.getTypeFromDescriptor(desc); int count = state.pop(Type.INT_TYPE).register; int array = state.push(type); builder.addNewArrayEmpty(array, count, dexType); break; } default: throw new Unreachable("Unexpected IntInsn opcode: " + insn.getOpcode()); } }
@Override public BasicValue newOperation(AbstractInsnNode insnNode) throws AnalyzerException { switch (insnNode.getOpcode()) { case ICONST_0: return new IntegerConstantBasicValue(Type.INT_TYPE, 0); case ICONST_1: return new IntegerConstantBasicValue(Type.INT_TYPE, 1); case ICONST_2: return new IntegerConstantBasicValue(Type.INT_TYPE, 2); case ICONST_3: return new IntegerConstantBasicValue(Type.INT_TYPE, 3); case ICONST_4: return new IntegerConstantBasicValue(Type.INT_TYPE, 4); case ICONST_5: return new IntegerConstantBasicValue(Type.INT_TYPE, 5); case BIPUSH: case SIPUSH: return new IntegerConstantBasicValue(Type.INT_TYPE, ((IntInsnNode)insnNode).operand); case Opcodes.LDC: { Object constant = ((LdcInsnNode)insnNode).cst; if (constant instanceof Integer) { return new IntegerConstantBasicValue(Type.INT_TYPE, (Integer)constant); } else { return super.newOperation(insnNode); } } default: return super.newOperation(insnNode); } }
@Override public void transform(ClassNode clazz, MethodNode method, InsnMatcher matcher) { AbstractInsnNode[] match = Iterators.getOnlyElement(matcher.match("BIPUSH ISTORE", m -> { IntInsnNode push = (IntInsnNode) m[0]; if (push.operand != 50) { return false; } VarInsnNode store = (VarInsnNode) m[1]; LocalVariableNode node = AsmUtils.getLocalVariable(method, store.var, store); return node != null && node.name.equals("resource") && node.desc.equals("I"); })); method.instructions.remove(match[0]); method.instructions.remove(match[1]); }
public static AbstractInsnNode loadInt(int i) { switch (i) { case -1: return new InsnNode(ICONST_M1); case 0: return new InsnNode(ICONST_0); case 1: return new InsnNode(ICONST_1); case 2: return new InsnNode(ICONST_2); case 3: return new InsnNode(ICONST_3); case 4: return new InsnNode(ICONST_4); case 5: return new InsnNode(ICONST_5); default: { if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) return new IntInsnNode(BIPUSH, i); else if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE) return new IntInsnNode(SIPUSH, i); else return new LdcInsnNode(i); } } }
public static boolean insnEqual(AbstractInsnNode node1, AbstractInsnNode node2) { if (node1.getType() != node2.getType()) { return false; } else 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; } }
@Override public void handle(AbstractInsnNode node) throws IncorrectNodeException { super.handle(node); LOG.debug(logNode(node)); checkType(node, IntInsnNode.class); ExpressionStack stack = mState.getActiveStack(); int opCode = node.getOpcode(); switch (opCode) { case Opcodes.BIPUSH: stack.push(new PrimaryExpression(opCode, ((IntInsnNode) node).operand, DataType.BYTE)); break; case Opcodes.SIPUSH: stack.push(new PrimaryExpression(opCode, ((IntInsnNode) node).operand, DataType.SHORT)); break; case Opcodes.NEWARRAY: stack.push(new ArrayCreationExpression(opCode, ((IntInsnNode) node).operand)); break; } }
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; } }
public static AbstractInsnNode getPushInstruction(int value) { if (value == -1) { return new InsnNode(Opcodes.ICONST_M1); } else if (value == 0) { return new InsnNode(Opcodes.ICONST_0); } else if (value == 1) { return new InsnNode(Opcodes.ICONST_1); } else if (value == 2) { return new InsnNode(Opcodes.ICONST_2); } else if (value == 3) { return new InsnNode(Opcodes.ICONST_3); } else if (value == 4) { return new InsnNode(Opcodes.ICONST_4); } else if (value == 5) { return new InsnNode(Opcodes.ICONST_5); } else if ((value >= -128) && (value <= 127)) { return new IntInsnNode(Opcodes.BIPUSH, value); } else if ((value >= -32768) && (value <= 32767)) { return new IntInsnNode(Opcodes.SIPUSH, value); } else { return new LdcInsnNode(value); } }
private void transformMethod( MethodNode method ) { for ( int i = 0; i < method.instructions.size(); ++i ) { AbstractInsnNode ins = method.instructions.get( i ); if ( ins.getOpcode() == BIPUSH ) { IntInsnNode node = ( IntInsnNode ) ins; // "Remove" 32 page title limit if ( node.operand == 16 ) { TextFormattingLog.info( "Found value 32, assuming it to be the title limit." ); node.setOpcode( SIPUSH ); node.operand = Short.MAX_VALUE; } } } }
public static Integer getIntConstOperand (final AbstractInsnNode insn) { final int opcode = insn.getOpcode(); if (Opcodes.ICONST_M1 <= opcode && opcode <= Opcodes.ICONST_5) { // The opcodes from ICONST_M1 to ICONST_5 are consecutive. return opcode - Opcodes.ICONST_0; } else if (opcode == Opcodes.BIPUSH || opcode == Opcodes.SIPUSH) { return ((IntInsnNode) insn).operand; } else if (opcode == Opcodes.LDC) { final LdcInsnNode ldc = (LdcInsnNode) insn; if (ldc.cst instanceof Integer) { return (Integer) ldc.cst; } } // Not an integer literal load instruction. return null; }
public static int getRevision(ClassNode node){ ListIterator<MethodNode> mnIt = node.methods.listIterator(); while(mnIt.hasNext()){ MethodNode mn = mnIt.next(); if(mn.name.equals("init")){ ListIterator<AbstractInsnNode> abIn = mn.instructions.iterator(); while(abIn.hasNext()){ AbstractInsnNode ain = abIn.next(); if(ain instanceof IntInsnNode){ if(((IntInsnNode) ain).operand == 765){ ain = ain.getNext(); if(ain instanceof IntInsnNode) if(((IntInsnNode) ain).operand == 503) return ((IntInsnNode)ain.getNext()).operand; } } } } } return -1; }
private AbstractInsnNode loadIntegerConstant(int c) { if (c == -1) return new InsnNode(Opcodes.ICONST_M1); if (c == 0) return new InsnNode(Opcodes.ICONST_0); if (c == 1) return new InsnNode(Opcodes.ICONST_1); if (c == 2) return new InsnNode(Opcodes.ICONST_2); if (c == 3) return new InsnNode(Opcodes.ICONST_3); if (c == 4) return new InsnNode(Opcodes.ICONST_4); if (c == 5) return new InsnNode(Opcodes.ICONST_5); if (Byte.MIN_VALUE <= c && c <= Byte.MAX_VALUE) return new IntInsnNode(Opcodes.BIPUSH, c); if (Short.MIN_VALUE <= c && c <= Short.MAX_VALUE) return new IntInsnNode(Opcodes.SIPUSH, c); return new LdcInsnNode(c); }
private Integer statusCodeFor(MethodInsnNode node) { if (node.name.equals("noContent")) { return 204; } if (node.name.equals("with")) { AbstractInsnNode previous = node.getPrevious(); if (previous instanceof IntInsnNode) { return ((IntInsnNode) previous).operand; } if (previous instanceof FieldInsnNode) { String owner = ((FieldInsnNode) previous).owner.replace("/", "."); if (owner.equals(Status.class.getName())) { String statusName = ((FieldInsnNode) previous).name; return Try.apply(() -> Status.class.getDeclaredField(statusName).get(null)) .map(it -> ((Status) it).value()) .orElse(null); } } } return null; }
private AbstractInsnNode getIntConstInsn(final int value) { switch (value) { case -1: return new InsnNode(ICONST_M1); case 0: return new InsnNode(ICONST_0); case 1: return new InsnNode(ICONST_1); case 2: return new InsnNode(ICONST_2); case 3: return new InsnNode(ICONST_3); case 4: return new InsnNode(ICONST_4); case 5: return new InsnNode(ICONST_5); default: if ((byte)value == value) return new IntInsnNode(BIPUSH, value); else if ((short)value == value) return new IntInsnNode(SIPUSH, value); else return new LdcInsnNode(Integer.valueOf(value)); } }
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 AbstractInsnNode getIntInsnNode(final Number newNumber) { switch (newNumber.intValue()) { case CONST_M1: return new InsnNode(Opcodes.ICONST_M1); case CONST_0: return new InsnNode(Opcodes.ICONST_0); case CONST_1: return new InsnNode(Opcodes.ICONST_1); case CONST_2: return new InsnNode(Opcodes.ICONST_2); case CONST_3: return new InsnNode(Opcodes.ICONST_3); case CONST_4: return new InsnNode(Opcodes.ICONST_4); case CONST_5: return new InsnNode(Opcodes.ICONST_5); default: if (newNumber.intValue() >= CONST_LOW_INT && newNumber.intValue() <= CONST_HIGH_INT) { return new IntInsnNode(getopcodePush(newNumber.intValue()), newNumber.intValue()); } return new LdcInsnNode(newNumber); } }
/** * Adds the array to the last created method. * * @param desc * the desc * @param length * the length * @return the class node builder */ public ClassNodeBuilder addArray(final String desc, final int... length) { if (isInterface) { return this; } final Type elementType = Type.getType(desc).getElementType(); if (length.length == 1) { addInsn(NodeHelper.getInsnNodeFor(Integer.valueOf(length[0]))); if (elementType.getDescriptor().startsWith("L")) { addInsn(new TypeInsnNode(Opcodes.ANEWARRAY, elementType.getInternalName())); } else { addInsn(new IntInsnNode(Opcodes.NEWARRAY, getSort(elementType))); } } else { for (final int currentLength : length) { addInsn(NodeHelper.getInsnNodeFor(Integer.valueOf(currentLength))); } addInsn(new MultiANewArrayInsnNode(desc, length.length)); } addInsn(new VarInsnNode(Opcodes.ASTORE, methodVarIndex)); lastMethodVarIndex = methodVarIndex; lastVarElementType = elementType; methodVarIndex++; return this; }
/** * Adds the given operation. * * @param opcode * the opcode * @param args * the args * @return the class node builder */ public ClassNodeBuilder add(final int opcode, final Object... args) { if (opcode == IINC) { return addInsn(new IincInsnNode((Integer) args[0], (Integer) args[1])); } if (opcode >= NOP && opcode <= DCONST_1 || opcode >= POP && opcode <= DCMPG || opcode >= IALOAD && opcode <= SALOAD || opcode >= IASTORE && opcode <= SASTORE || opcode == ARRAYLENGTH || opcode == ATHROW) { return addInsn(new InsnNode(opcode)); } if (opcode >= BIPUSH && opcode <= SIPUSH || opcode == NEWARRAY) { return addInsn(new IntInsnNode(opcode, (Integer) args[0])); } if (opcode == LDC) { return loadConstant(args[0]); } if (opcode >= ILOAD && opcode <= ALOAD) { return addInsn(new VarInsnNode(opcode, (Integer) args[0])); } if (opcode >= ISTORE && opcode <= ASTORE) { return addInsn(new VarInsnNode(opcode, (Integer) args[0])); } if (opcode >= IFEQ && opcode <= JSR) { return jump(opcode, (LabelNode) args[0]); } return this; }
public void extractFrom(ImagineASM asm, InsnList list) { //Pair<String, String> fieldChunkProvider = asm.field("net/minecraft/world/World", "chunkProvider"); list.clear(); list.add(new IntInsnNode(ALOAD, 1)); list.add(new FieldInsnNode(GETFIELD, "ahb", "v", "Lapu;")); list.add(new InsnNode(ARETURN)); }
public static AbstractInsnNode loadInt(int i) { switch (i) { case -1: return new InsnNode(ICONST_M1); case 0: return new InsnNode(ICONST_0); case 1: return new InsnNode(ICONST_1); case 2: return new InsnNode(ICONST_2); case 3: return new InsnNode(ICONST_3); case 4: return new InsnNode(ICONST_4); case 5: return new InsnNode(ICONST_5); default: { if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) { return new IntInsnNode(BIPUSH, i); } else if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE) { return new IntInsnNode(SIPUSH, i); } else { return new LdcInsnNode(i); } } } }
private static boolean isSimpleConstant(Object previousInstructionObject) { // CHECKSTYLE:OFF final AbstractInsnNode previousInstruction = (AbstractInsnNode) previousInstructionObject; // CHECKSTYLE:ON final int opcode = previousInstruction.getOpcode(); return (opcode >= Opcodes.ACONST_NULL && opcode <= Opcodes.DCONST_1 || opcode == Opcodes.SIPUSH || opcode == Opcodes.BIPUSH) && (previousInstruction instanceof InsnNode || previousInstruction instanceof IntInsnNode); }
public static boolean matchInstruction(AbstractInsnNode ain, AbstractInsnNode ain2) { if (ain.getOpcode() != ain2.getOpcode()) return false; if (ain instanceof InsnNode) { return true; } else if (ain instanceof VarInsnNode) { return ((VarInsnNode)ain).var == ((VarInsnNode)ain2).var; } else if (ain instanceof LdcInsnNode) { return ((LdcInsnNode)ain).cst.equals(((LdcInsnNode)ain2).cst); } else if (ain instanceof IntInsnNode) { return ((IntInsnNode)ain).operand == ((IntInsnNode)ain2).operand; } else if (ain instanceof TypeInsnNode) { return ((TypeInsnNode)ain).desc.equals(((TypeInsnNode)ain2).desc); } else if (ain instanceof FieldInsnNode) { FieldInsnNode fin = (FieldInsnNode)ain; FieldInsnNode fin2 = (FieldInsnNode)ain2; return fin.owner.equals(fin2.owner) && fin.name.equals(fin2.name) && fin.desc.equals(fin2.desc); } else if (ain instanceof MethodInsnNode) { MethodInsnNode min = (MethodInsnNode)ain; MethodInsnNode min2 = (MethodInsnNode)ain2; return min.owner.equals(min2.owner) && min.name.equals(min2.name) && min.desc.equals(min2.desc) && min.itf == min2.itf; } else if (ain instanceof JumpInsnNode) { return ((JumpInsnNode)ain).label == ((JumpInsnNode)ain2).label; } else if (ain instanceof IincInsnNode) { IincInsnNode iin = (IincInsnNode)ain; IincInsnNode iin2 = (IincInsnNode)ain2; return iin.var == iin2.var && iin.incr == iin2.incr; } return false; }
public static boolean matchInstruction(AbstractInsnNode ain, int opcode, Object... args) { if (ain.getOpcode() != opcode) return false; if (ain instanceof InsnNode) { return true; } else if (ain instanceof VarInsnNode) { return args[0] instanceof Integer && ((VarInsnNode)ain).var == (Integer)args[0]; } else if (ain instanceof LdcInsnNode) { return args[0].equals(((LdcInsnNode)ain).cst); } else if (ain instanceof IntInsnNode) { return args[0] instanceof Integer && ((IntInsnNode)ain).operand == (Integer)args[0]; } else if (ain instanceof TypeInsnNode) { return args[0] instanceof String && ((TypeInsnNode)ain).desc.equals(args[0]); } else if (ain instanceof FieldInsnNode) { if (args.length != 3 || !(args[0] instanceof String) || !(args[1] instanceof String) || !(args[2] instanceof String)) return false; FieldInsnNode fin = (FieldInsnNode)ain; return fin.owner.equals(args[0]) && fin.name.equals(args[1]) && fin.desc.equals(args[2]); } else if (ain instanceof MethodInsnNode) { if (args.length != 4 || !(args[0] instanceof String) || !(args[1] instanceof String) || !(args[2] instanceof String) || !(args[3] instanceof Boolean)) return false; MethodInsnNode min = (MethodInsnNode)ain; return min.owner.equals(args[0]) && min.name.equals(args[1]) && min.desc.equals(args[2]) && min.itf == (Boolean)args[3]; } else if (ain instanceof JumpInsnNode) { return args[0] instanceof LabelNode && ((JumpInsnNode)ain).label == args[0]; } else if (ain instanceof IincInsnNode) { if (args.length != 2 || !(args[0] instanceof Integer) || !(args[1] instanceof Integer)) return false; IincInsnNode iin = (IincInsnNode)ain; return iin.var == (Integer)args[0] && iin.incr == (Integer)args[1]; } return false; }
@Override public AbstractInsnNode tryMatch(InstructionMatcher matcher, AbstractInsnNode now) { if (now.getOpcode() == Opcodes.NEWARRAY && now instanceof IntInsnNode) { if (this.sorts.contains(((IntInsnNode) now).operand)) { return now.getNext(); } } return null; }
public static InsnList methodCall(final ImagineMethod img, String owner, final String methodName, boolean staticForward, final boolean needReturn) { if (!staticForward || owner == null) { owner = img.mAsm.getActualName(); } owner = ImagineASM.toDesc(owner); final ImagineDesc desc = ImagineDesc.parse(img.mMethod.desc); if (!needReturn) { desc.returnType(ImagineDesc.SubDesc.create(Type.VOID_TYPE, 0)); } final InsnList instructions = new InsnList(); if (!img.isStatic()) { staticForward = true; instructions.add((AbstractInsnNode)new IntInsnNode(25, 0)); } int i = img.isStatic() ? 0 : 1; for (final ImagineDesc.SubDesc sub : desc.parameters()) { instructions.add((AbstractInsnNode)new IntInsnNode(sub.opcodeLoad(), i++)); } if (staticForward && !img.isStatic()) { desc.first(Type.getType("L" + ImagineASM.toDesc(img.mAsm.getActualName()) + ";"), 0); } final MethodDesc method = img.mAsm.mapMethod(owner, methodName, desc.toString()); instructions.add((AbstractInsnNode)new MethodInsnNode(staticForward ? 184 : 185, (String)((Pair<String, Y>)method).first(), (String)((Pair<X, String>)method).second(), (String)((Triple<X, Y, String>)method).third(), false)); if (needReturn) { instructions.add((AbstractInsnNode)new InsnNode(desc.returnOpcode())); } return instructions; }
static AbstractInsnNode getIntNode(int value) { if (value <= 5 && -1 <= value) return new InsnNode(ICONST_M1 + value + 1); if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) return new IntInsnNode(BIPUSH, value); if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) return new IntInsnNode(SIPUSH, value); return new LdcInsnNode(value); }
public static void intInsnNode(ListIterator<AbstractInsnNode> iterator, int i) { if (i >=0 && i < 6) { // int ICONST_0 = 3; // - // int ICONST_1 = 4; // - // int ICONST_2 = 5; // - // int ICONST_3 = 6; // - // int ICONST_4 = 7; // - // int ICONST_5 = 8; // - iterator.add(new InsnNode(Opcodes.ICONST_0 + i)); } else { iterator.add(new IntInsnNode(Opcodes.BIPUSH, i)); } }
public static String extract(BasicExpr expr) { AbstractInsnNode insn = expr.insn(); if (insn instanceof IntInsnNode) { int operand = ((IntInsnNode) insn).operand; return Integer.toString(operand); } else if (insn instanceof LdcInsnNode) { Object ldc = ((LdcInsnNode) insn).cst; return (ldc == null ? "null" : ldc.toString()); } return EMPTY_STRING; }
/** * Retrieves this expression's instruction as an IntInsnNode. * * @return This expression's instruction as an IntInsnNode. */ public IntInsnNode asIntInsn() { if (!intInsn) { throw new IllegalStateException("Instruction is not an IntInsnNode"); } return (IntInsnNode) insn; }
@Override protected void add(@NonNull AbstractInsnNode from, @NonNull AbstractInsnNode to) { if (from.getType() == AbstractInsnNode.JUMP_INSN && from.getPrevious() != null && from.getPrevious().getType() == AbstractInsnNode.INT_INSN) { IntInsnNode intNode = (IntInsnNode) from.getPrevious(); if (intNode.getPrevious() != null && isSdkVersionLookup(intNode.getPrevious())) { JumpInsnNode jumpNode = (JumpInsnNode) from; int api = intNode.operand; boolean isJumpEdge = to == jumpNode.label; boolean includeEdge; switch (from.getOpcode()) { case Opcodes.IF_ICMPNE: includeEdge = api < mRequiredApi || isJumpEdge; break; case Opcodes.IF_ICMPLE: includeEdge = api < mRequiredApi - 1 || isJumpEdge; break; case Opcodes.IF_ICMPLT: includeEdge = api < mRequiredApi || isJumpEdge; break; case Opcodes.IF_ICMPGE: includeEdge = api < mRequiredApi || !isJumpEdge; break; case Opcodes.IF_ICMPGT: includeEdge = api < mRequiredApi - 1 || !isJumpEdge; break; default: // unexpected comparison for int API level includeEdge = true; } if (!includeEdge) { return; } } } super.add(from, to); }
/** * 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 static AbstractInsnNode newPushNode(int operand) { if (operand <= 5) { return new InsnNode(ICONST_0 + operand); } else if (operand <= Byte.MAX_VALUE) { return new IntInsnNode(BIPUSH, operand); } else if (operand <= Short.MAX_VALUE) { return new IntInsnNode(SIPUSH, operand); } else { return new LdcInsnNode(operand); } }
@Override protected AbstractInsnNode transformIntInsnNode(MethodNode mn, IntInsnNode intInsnNode) { if (intInsnNode.operand == Opcodes.T_BOOLEAN) { intInsnNode.operand = Opcodes.T_INT; } return intInsnNode; }
private Object getValue(AbstractInsnNode constant) { switch (constant.getOpcode()) { case Opcodes.LDC: return ((LdcInsnNode) constant).cst; case Opcodes.ICONST_0: return 0; case Opcodes.ICONST_1: return 1; case Opcodes.ICONST_2: return 2; case Opcodes.ICONST_3: return 3; case Opcodes.ICONST_4: return 4; case Opcodes.ICONST_5: return 5; case Opcodes.ICONST_M1: return -1; case Opcodes.LCONST_0: return 0L; case Opcodes.LCONST_1: return 1L; case Opcodes.DCONST_0: return 0.0; case Opcodes.DCONST_1: return 1.0; case Opcodes.FCONST_0: return 0.0F; case Opcodes.FCONST_1: return 1.0F; case Opcodes.FCONST_2: return 2.0F; case Opcodes.SIPUSH: return ((IntInsnNode) constant).operand; case Opcodes.BIPUSH: return ((IntInsnNode) constant).operand; default: throw new RuntimeException("Unknown constant: " + constant.getOpcode()); } }