Java Opcodes.IFLT属性代码示例

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);
  }
}
 

/**
 * This are values compared against 0, like {@code value < 0}
 *
 * @return
 */
public static Truthness getForSingleValueJump(int value, int opcode) {

    switch (opcode) {
        case Opcodes.IFEQ: // ie, val == 0
            return getForValueComparison(value, 0, Opcodes.IF_ICMPEQ);

        case Opcodes.IFNE: // ie val != 0  ->  ! (val == 0)
            return getForSingleValueJump(value, Opcodes.IFEQ).invert();

        case Opcodes.IFLT: // ie, val < 0
            return getForValueComparison(value, 0, Opcodes.IF_ICMPLT);

        case Opcodes.IFGE: // ie, val >= 0  -> ! (val < 0)
            return getForSingleValueJump(value, Opcodes.IFLT).invert();

        case Opcodes.IFLE: // ie, val <= 0  ->  0 >= val  -> ! (0 < val)
            return getForValueComparison(0, value, Opcodes.IF_ICMPLT).invert();

        case Opcodes.IFGT: // ie, val > 0  ->  0 < val
            return getForValueComparison(0, value, Opcodes.IF_ICMPLT);

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

@Test
public void test_IFLT_pos(){
    //val < 0
    int code = Opcodes.IFLT;

    Truthness t3 = getForSingleValueJump(3, code);
    assertFalse(t3.isTrue());
    assertTrue(t3.isFalse());

    Truthness t5 = getForSingleValueJump(5, code);
    assertFalse(t5.isTrue());
    assertTrue(t5.isFalse());

    Truthness t12 = getForSingleValueJump(12, code);
    assertFalse(t12.isTrue());
    assertTrue(t12.isFalse());

    assertTrue(t5.getOfTrue() < t3.getOfTrue());
    assertTrue(t5.getOfTrue() > t12.getOfTrue());
}
 

@Test
public void test_IFLT_neg(){
    //val < 0
    int code = Opcodes.IFLT;

    Truthness tm3 = getForSingleValueJump(-3, code);
    assertTrue(tm3.isTrue());
    assertFalse(tm3.isFalse());

    Truthness tm5 = getForSingleValueJump(-5, code);
    assertTrue(tm5.isTrue());
    assertFalse(tm5.isFalse());

    Truthness tm12 = getForSingleValueJump(-12, code);
    assertTrue(tm12.isTrue());
    assertFalse(tm12.isFalse());

    assertTrue(tm5.getOfFalse() < tm3.getOfFalse());
    assertTrue(tm5.getOfFalse() > tm12.getOfFalse());
}
 

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");
  }
}
 

@Test
public void test_IFLT_m10(){
    //val < 0
    int code = Opcodes.IFLT;

    Truthness t0 = getForSingleValueJump(-10, code);
    assertTrue(t0.isTrue());
    assertFalse(t0.isFalse());
}
 

@Test
public void test_IFLT_0() {
    //val < 0
    int code = Opcodes.IFLT;

    Truthness tm3 = getForSingleValueJump(0, code);
    assertFalse(tm3.isTrue());
    assertTrue(tm3.isFalse());
}
 

@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();
    }
}