Java Opcodes.IF_ICMPEQ属性代码示例

private static If.Type ifType(int opcode) {
  switch (opcode) {
    case Opcodes.IFEQ:
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ACMPEQ:
      return If.Type.EQ;
    case Opcodes.IFNE:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ACMPNE:
      return If.Type.NE;
    case Opcodes.IFLT:
    case Opcodes.IF_ICMPLT:
      return If.Type.LT;
    case Opcodes.IFGE:
    case Opcodes.IF_ICMPGE:
      return If.Type.GE;
    case Opcodes.IFGT:
    case Opcodes.IF_ICMPGT:
      return If.Type.GT;
    case Opcodes.IFLE:
    case Opcodes.IF_ICMPLE:
      return If.Type.LE;
    default:
      throw new Unreachable("Unexpected If instruction opcode: " + opcode);
  }
}
 

private int[] getJumpTargets(JumpInsnNode jump) {
  switch (jump.getOpcode()) {
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
      return new int[]{getOffset(jump.label), getOffset(jump.getNext())};
    case Opcodes.GOTO:
      return new int[]{getOffset(jump.label)};
    case Opcodes.JSR: {
      throw new Unreachable("JSR should be handled by the ASM jsr inliner");
    }
    default:
      throw new Unreachable("Unexpected opcode in jump instruction: " + jump);
  }
}
 

/**
 * Imports branch instructions, both conditional and unconditional.
 *
 * @param opcode Opcode.
 * @param label  Destination of branch.
 */
@Override
public void visitJumpInsn(final int opcode, final Label label) {
  BasicBlock section = getBasicBlock(label);
    
  switch(opcode) {
    // Unconditional Branch
    case Opcodes.GOTO: finishBlock(section); setCurrent(null); break;
    
    // Zero Test
    case Opcodes.IFEQ: createZeroCondition(Condition.Operator.EQ, section); break;
    case Opcodes.IFNE: createZeroCondition(Condition.Operator.NE, section); break;
    case Opcodes.IFLT: createZeroCondition(Condition.Operator.LT, section); break;
    case Opcodes.IFGE: createZeroCondition(Condition.Operator.GE, section); break;
    case Opcodes.IFGT: createZeroCondition(Condition.Operator.GT, section); break;
    case Opcodes.IFLE: createZeroCondition(Condition.Operator.LE, section); break;
    
    // Integer Comparison
    case Opcodes.IF_ICMPEQ: createCondition(Condition.Operator.EQ, section); break;
    case Opcodes.IF_ICMPNE: createCondition(Condition.Operator.NE, section); break;
    case Opcodes.IF_ICMPLT: createCondition(Condition.Operator.LT, section); break;
    case Opcodes.IF_ICMPGE: createCondition(Condition.Operator.GE, section); break;
    case Opcodes.IF_ICMPGT: createCondition(Condition.Operator.GT, section); break;
    case Opcodes.IF_ICMPLE: createCondition(Condition.Operator.LE, section); break;

    // Reference Comparisons
    case Opcodes.IF_ACMPEQ: createCondition(Condition.Operator.EQ, section); break;
    case Opcodes.IF_ACMPNE: createCondition(Condition.Operator.NE, section); break;
    case Opcodes.IFNULL:    createNullCondition(Condition.Operator.EQ, section); break;
    case Opcodes.IFNONNULL: createNullCondition(Condition.Operator.NE, section); break;
    
    // TODO: JSR (paired with RET)
    case Opcodes.JSR: System.err.println("visitJumpInsn: JSR");
  }
}
 

public static Truthness getForValueComparison(int firstValue, int secondValue, int opcode) {

        double a = firstValue;
        double b = secondValue;

        switch (opcode) {
            case Opcodes.IF_ICMPEQ: // ie, a == b
                return new Truthness(
                        1d - Truthness.normalizeValue(Math.abs(a - b)),
                        a != b ? 1d : 0d
                );

            case Opcodes.IF_ICMPNE: // ie, a != b
                return getForValueComparison(firstValue, secondValue, Opcodes.IF_ICMPEQ).invert();

            case Opcodes.IF_ICMPLT: // ie, a < b
                return new Truthness(
                        a < b ? 1d : 1d / (1.1d + a - b) ,
                        a >= b ? 1d : 1d / (1.1d + b - a)
                );

            case Opcodes.IF_ICMPGE: // ie, a >= b  ->  ! (a < b)
                return getForValueComparison(firstValue, secondValue, Opcodes.IF_ICMPLT).invert();

            case Opcodes.IF_ICMPLE: // ie, a <= b  ->  b >= a -> ! (b < a)
                return getForValueComparison(secondValue, firstValue, Opcodes.IF_ICMPLT).invert();

            case Opcodes.IF_ICMPGT: // ie, a > b  ->  b < a
                return getForValueComparison(secondValue, firstValue, Opcodes.IF_ICMPLT);

            default:
                throw new IllegalArgumentException("Cannot handle opcode " + opcode);
        }
    }
 

@Test
public void test_IF_ICMPEQ_pos(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness t = getForValueComparison(5, 5, code);
    assertTrue(t.isTrue());
    assertFalse(t.isFalse());
}
 

@Test
public void test_IF_ICMPEQ_neg(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness t = getForValueComparison(-8, -8, code);
    assertTrue(t.isTrue());
    assertFalse(t.isFalse());
}
 

@Test
public void test_IF_ICMPEQ_0(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness t = getForValueComparison(0, 0, code);
    assertTrue(t.isTrue());
    assertFalse(t.isFalse());
}
 

@Test
public void test_IF_ICMPEQ_dif(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness t = getForValueComparison(2, 4, code);
    assertFalse(t.isTrue());
    assertTrue(t.isFalse());
}
 

@Test
public void test_IF_ICMPEQ_dif_incr(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness a = getForValueComparison(3, 5, code);
    assertTrue(a.isFalse());

    Truthness b = getForValueComparison(7, 8, code);
    assertTrue(b.isFalse());

    assertTrue(b.getOfTrue() > a.getOfTrue());
}
 

@Test
public void test_IF_ICMPEQ_dif_spec(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness a = getForValueComparison(-3, 5, code);
    assertTrue(a.isFalse());

    Truthness b = getForValueComparison(-1, 6, code);
    assertTrue(b.isFalse());

    assertTrue(b.getOfTrue() > a.getOfTrue());
}
 

@Test
public void test_IF_ICMPEQ_dif_negPos(){
    // x == y
    int code = Opcodes.IF_ICMPEQ;

    Truthness a = getForValueComparison(-3, -50, code);
    assertTrue(a.isFalse());

    Truthness b = getForValueComparison(10, 6, code);
    assertTrue(b.isFalse());

    assertTrue(b.getOfTrue() > a.getOfTrue());
}
 

@Override
public void visitJumpInsn(final int opcode, final Label label) {
    switch (opcode) {
    case Opcodes.IFEQ:
        ifeq(label);
        break;
    case Opcodes.IFNE:
        ifne(label);
        break;
    case Opcodes.IFLT:
        iflt(label);
        break;
    case Opcodes.IFGE:
        ifge(label);
        break;
    case Opcodes.IFGT:
        ifgt(label);
        break;
    case Opcodes.IFLE:
        ifle(label);
        break;
    case Opcodes.IF_ICMPEQ:
        ificmpeq(label);
        break;
    case Opcodes.IF_ICMPNE:
        ificmpne(label);
        break;
    case Opcodes.IF_ICMPLT:
        ificmplt(label);
        break;
    case Opcodes.IF_ICMPGE:
        ificmpge(label);
        break;
    case Opcodes.IF_ICMPGT:
        ificmpgt(label);
        break;
    case Opcodes.IF_ICMPLE:
        ificmple(label);
        break;
    case Opcodes.IF_ACMPEQ:
        ifacmpeq(label);
        break;
    case Opcodes.IF_ACMPNE:
        ifacmpne(label);
        break;
    case Opcodes.GOTO:
        goTo(label);
        break;
    case Opcodes.JSR:
        jsr(label);
        break;
    case Opcodes.IFNULL:
        ifnull(label);
        break;
    case Opcodes.IFNONNULL:
        ifnonnull(label);
        break;
    default:
        throw new IllegalArgumentException();
    }
}
 

/**
 * Generates the instructions to jump to a label based on the comparison of
 * the top two stack values.
 * 
 * @param type
 *            the type of the top two stack values.
 * @param mode
 *            how these values must be compared. One of EQ, NE, LT, GE, GT,
 *            LE.
 * @param label
 *            where to jump if the comparison result is <tt>true</tt>.
 */
public void ifCmp(final Type type, final int mode, final Label label) {
    switch (type.getSort()) {
    case Type.LONG:
        mv.visitInsn(Opcodes.LCMP);
        break;
    case Type.DOUBLE:
        mv.visitInsn(mode == GE || mode == GT ? Opcodes.DCMPL
                : Opcodes.DCMPG);
        break;
    case Type.FLOAT:
        mv.visitInsn(mode == GE || mode == GT ? Opcodes.FCMPL
                : Opcodes.FCMPG);
        break;
    case Type.ARRAY:
    case Type.OBJECT:
        switch (mode) {
        case EQ:
            mv.visitJumpInsn(Opcodes.IF_ACMPEQ, label);
            return;
        case NE:
            mv.visitJumpInsn(Opcodes.IF_ACMPNE, label);
            return;
        }
        throw new IllegalArgumentException("Bad comparison for type "
                + type);
    default:
        int intOp = -1;
        switch (mode) {
        case EQ:
            intOp = Opcodes.IF_ICMPEQ;
            break;
        case NE:
            intOp = Opcodes.IF_ICMPNE;
            break;
        case GE:
            intOp = Opcodes.IF_ICMPGE;
            break;
        case LT:
            intOp = Opcodes.IF_ICMPLT;
            break;
        case LE:
            intOp = Opcodes.IF_ICMPLE;
            break;
        case GT:
            intOp = Opcodes.IF_ICMPGT;
            break;
        }
        mv.visitJumpInsn(intOp, label);
        return;
    }
    mv.visitJumpInsn(mode, label);
}