2397 lines
49 KiB
C
2397 lines
49 KiB
C
uint32_t decode_print_instruction(const uint8_t * code, uint32_t pc)
|
|
{
|
|
switch (code[pc]) {
|
|
case 0: // nop
|
|
{
|
|
printf("%4d: nop \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 1: // aconst_null
|
|
{
|
|
printf("%4d: aconst_null \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 2: // iconst_m1
|
|
{
|
|
printf("%4d: iconst_m1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 3: // iconst_0
|
|
{
|
|
printf("%4d: iconst_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 4: // iconst_1
|
|
{
|
|
printf("%4d: iconst_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 5: // iconst_2
|
|
{
|
|
printf("%4d: iconst_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 6: // iconst_3
|
|
{
|
|
printf("%4d: iconst_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 7: // iconst_4
|
|
{
|
|
printf("%4d: iconst_4 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 8: // iconst_5
|
|
{
|
|
printf("%4d: iconst_5 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 9: // lconst_0
|
|
{
|
|
printf("%4d: lconst_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 10: // lconst_1
|
|
{
|
|
printf("%4d: lconst_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 11: // fconst_0
|
|
{
|
|
printf("%4d: fconst_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 12: // fconst_1
|
|
{
|
|
printf("%4d: fconst_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 13: // fconst_2
|
|
{
|
|
printf("%4d: fconst_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 14: // dconst_0
|
|
{
|
|
printf("%4d: dconst_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 15: // dconst_1
|
|
{
|
|
printf("%4d: dconst_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 16: // bipush
|
|
{
|
|
int32_t byte = _s1(&code[pc + 1]);
|
|
printf("%4d: bipush %d\n", pc, byte);
|
|
return pc + 2;
|
|
}
|
|
case 17: // sipush
|
|
{
|
|
int32_t byte = _s2(&code[pc + 1]);
|
|
printf("%4d: sipush %d\n", pc, byte);
|
|
return pc + 3;
|
|
}
|
|
case 18: // ldc
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: ldc %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 19: // ldc_w
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: ldc_w %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 20: // ldc2_w
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: ldc2_w %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 21: // iload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: iload %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 22: // lload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: lload %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 23: // fload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: fload %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 24: // dload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: dload %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 25: // aload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: aload %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 26: // iload_0
|
|
{
|
|
printf("%4d: iload_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 27: // iload_1
|
|
{
|
|
printf("%4d: iload_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 28: // iload_2
|
|
{
|
|
printf("%4d: iload_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 29: // iload_3
|
|
{
|
|
printf("%4d: iload_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 30: // lload_0
|
|
{
|
|
printf("%4d: lload_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 31: // lload_1
|
|
{
|
|
printf("%4d: lload_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 32: // lload_2
|
|
{
|
|
printf("%4d: lload_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 33: // lload_3
|
|
{
|
|
printf("%4d: lload_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 34: // fload_0
|
|
{
|
|
printf("%4d: fload_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 35: // fload_1
|
|
{
|
|
printf("%4d: fload_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 36: // fload_2
|
|
{
|
|
printf("%4d: fload_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 37: // fload_3
|
|
{
|
|
printf("%4d: fload_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 38: // dload_0
|
|
{
|
|
printf("%4d: dload_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 39: // dload_1
|
|
{
|
|
printf("%4d: dload_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 40: // dload_2
|
|
{
|
|
printf("%4d: dload_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 41: // dload_3
|
|
{
|
|
printf("%4d: dload_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 42: // aload_0
|
|
{
|
|
printf("%4d: aload_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 43: // aload_1
|
|
{
|
|
printf("%4d: aload_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 44: // aload_2
|
|
{
|
|
printf("%4d: aload_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 45: // aload_3
|
|
{
|
|
printf("%4d: aload_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 46: // iaload
|
|
{
|
|
printf("%4d: iaload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 47: // laload
|
|
{
|
|
printf("%4d: laload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 48: // faload
|
|
{
|
|
printf("%4d: faload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 49: // daload
|
|
{
|
|
printf("%4d: daload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 50: // aaload
|
|
{
|
|
printf("%4d: aaload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 51: // baload
|
|
{
|
|
printf("%4d: baload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 52: // caload
|
|
{
|
|
printf("%4d: caload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 53: // saload
|
|
{
|
|
printf("%4d: saload \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 54: // istore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: istore %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 55: // lstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: lstore %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 56: // fstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: fstore %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 57: // dstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: dstore %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 58: // astore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: astore %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 59: // istore_0
|
|
{
|
|
printf("%4d: istore_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 60: // istore_1
|
|
{
|
|
printf("%4d: istore_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 61: // istore_2
|
|
{
|
|
printf("%4d: istore_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 62: // istore_3
|
|
{
|
|
printf("%4d: istore_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 63: // lstore_0
|
|
{
|
|
printf("%4d: lstore_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 64: // lstore_1
|
|
{
|
|
printf("%4d: lstore_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 65: // lstore_2
|
|
{
|
|
printf("%4d: lstore_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 66: // lstore_3
|
|
{
|
|
printf("%4d: lstore_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 67: // fstore_0
|
|
{
|
|
printf("%4d: fstore_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 68: // fstore_1
|
|
{
|
|
printf("%4d: fstore_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 69: // fstore_2
|
|
{
|
|
printf("%4d: fstore_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 70: // fstore_3
|
|
{
|
|
printf("%4d: fstore_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 71: // dstore_0
|
|
{
|
|
printf("%4d: dstore_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 72: // dstore_1
|
|
{
|
|
printf("%4d: dstore_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 73: // dstore_2
|
|
{
|
|
printf("%4d: dstore_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 74: // dstore_3
|
|
{
|
|
printf("%4d: dstore_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 75: // astore_0
|
|
{
|
|
printf("%4d: astore_0 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 76: // astore_1
|
|
{
|
|
printf("%4d: astore_1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 77: // astore_2
|
|
{
|
|
printf("%4d: astore_2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 78: // astore_3
|
|
{
|
|
printf("%4d: astore_3 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 79: // iastore
|
|
{
|
|
printf("%4d: iastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 80: // lastore
|
|
{
|
|
printf("%4d: lastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 81: // fastore
|
|
{
|
|
printf("%4d: fastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 82: // dastore
|
|
{
|
|
printf("%4d: dastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 83: // aastore
|
|
{
|
|
printf("%4d: aastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 84: // bastore
|
|
{
|
|
printf("%4d: bastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 85: // castore
|
|
{
|
|
printf("%4d: castore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 86: // sastore
|
|
{
|
|
printf("%4d: sastore \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 87: // pop
|
|
{
|
|
printf("%4d: pop \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 88: // pop2
|
|
{
|
|
printf("%4d: pop2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 89: // dup
|
|
{
|
|
printf("%4d: dup \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 90: // dup_x1
|
|
{
|
|
printf("%4d: dup_x1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 91: // dup_x2
|
|
{
|
|
printf("%4d: dup_x2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 92: // dup2
|
|
{
|
|
printf("%4d: dup2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 93: // dup2_x1
|
|
{
|
|
printf("%4d: dup2_x1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 94: // dup2_x2
|
|
{
|
|
printf("%4d: dup2_x2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 95: // swap
|
|
{
|
|
printf("%4d: swap \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 96: // iadd
|
|
{
|
|
printf("%4d: iadd \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 97: // ladd
|
|
{
|
|
printf("%4d: ladd \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 98: // fadd
|
|
{
|
|
printf("%4d: fadd \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 99: // dadd
|
|
{
|
|
printf("%4d: dadd \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 100: // isub
|
|
{
|
|
printf("%4d: isub \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 101: // lsub
|
|
{
|
|
printf("%4d: lsub \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 102: // fsub
|
|
{
|
|
printf("%4d: fsub \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 103: // dsub
|
|
{
|
|
printf("%4d: dsub \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 104: // imul
|
|
{
|
|
printf("%4d: imul \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 105: // lmul
|
|
{
|
|
printf("%4d: lmul \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 106: // fmul
|
|
{
|
|
printf("%4d: fmul \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 107: // dmul
|
|
{
|
|
printf("%4d: dmul \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 108: // idiv
|
|
{
|
|
printf("%4d: idiv \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 109: // ldiv
|
|
{
|
|
printf("%4d: ldiv \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 110: // fdiv
|
|
{
|
|
printf("%4d: fdiv \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 111: // ddiv
|
|
{
|
|
printf("%4d: ddiv \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 112: // irem
|
|
{
|
|
printf("%4d: irem \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 113: // lrem
|
|
{
|
|
printf("%4d: lrem \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 114: // frem
|
|
{
|
|
printf("%4d: frem \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 115: // drem
|
|
{
|
|
printf("%4d: drem \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 116: // ineg
|
|
{
|
|
printf("%4d: ineg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 117: // lneg
|
|
{
|
|
printf("%4d: lneg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 118: // fneg
|
|
{
|
|
printf("%4d: fneg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 119: // dneg
|
|
{
|
|
printf("%4d: dneg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 120: // ishl
|
|
{
|
|
printf("%4d: ishl \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 121: // lshl
|
|
{
|
|
printf("%4d: lshl \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 122: // ishr
|
|
{
|
|
printf("%4d: ishr \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 123: // lshr
|
|
{
|
|
printf("%4d: lshr \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 124: // iushr
|
|
{
|
|
printf("%4d: iushr \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 125: // lushr
|
|
{
|
|
printf("%4d: lushr \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 126: // iand
|
|
{
|
|
printf("%4d: iand \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 127: // land
|
|
{
|
|
printf("%4d: land \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 128: // ior
|
|
{
|
|
printf("%4d: ior \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 129: // lor
|
|
{
|
|
printf("%4d: lor \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 130: // ixor
|
|
{
|
|
printf("%4d: ixor \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 131: // lxor
|
|
{
|
|
printf("%4d: lxor \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 132: // iinc
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
int32_t _const = _s1(&code[pc + 2]);
|
|
printf("%4d: iinc %u, %d\n", pc, index, _const);
|
|
return pc + 3;
|
|
}
|
|
case 133: // i2l
|
|
{
|
|
printf("%4d: i2l \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 134: // i2f
|
|
{
|
|
printf("%4d: i2f \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 135: // i2d
|
|
{
|
|
printf("%4d: i2d \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 136: // l2i
|
|
{
|
|
printf("%4d: l2i \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 137: // l2f
|
|
{
|
|
printf("%4d: l2f \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 138: // l2d
|
|
{
|
|
printf("%4d: l2d \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 139: // f2i
|
|
{
|
|
printf("%4d: f2i \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 140: // f2l
|
|
{
|
|
printf("%4d: f2l \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 141: // f2d
|
|
{
|
|
printf("%4d: f2d \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 142: // d2i
|
|
{
|
|
printf("%4d: d2i \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 143: // d2l
|
|
{
|
|
printf("%4d: d2l \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 144: // d2f
|
|
{
|
|
printf("%4d: d2f \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 145: // i2b
|
|
{
|
|
printf("%4d: i2b \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 146: // i2c
|
|
{
|
|
printf("%4d: i2c \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 147: // i2s
|
|
{
|
|
printf("%4d: i2s \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 148: // lcmp
|
|
{
|
|
printf("%4d: lcmp \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 149: // fcmpl
|
|
{
|
|
printf("%4d: fcmpl \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 150: // fcmpg
|
|
{
|
|
printf("%4d: fcmpg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 151: // dcmpl
|
|
{
|
|
printf("%4d: dcmpl \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 152: // dcmpg
|
|
{
|
|
printf("%4d: dcmpg \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 153: // ifeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifeq %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 154: // ifne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifne %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 155: // iflt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: iflt %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 156: // ifge
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifge %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 157: // ifgt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifgt %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 158: // ifle
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifle %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 159: // if_icmpeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmpeq %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 160: // if_icmpne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmpne %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 161: // if_icmplt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmplt %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 162: // if_icmpge
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmpge %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 163: // if_icmpgt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmpgt %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 164: // if_icmple
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_icmple %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 165: // if_acmpeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_acmpeq %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 166: // if_acmpne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: if_acmpne %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 167: // goto
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: goto %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 168: // jsr
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: jsr %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 169: // ret
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
printf("%4d: ret %u\n", pc, index);
|
|
return pc + 2;
|
|
}
|
|
case 170: // tableswitch
|
|
{
|
|
TABLESWITCH_ARGS;
|
|
printf("%4d: tableswitch {\n", pc);
|
|
TABLESWITCH_PRINT_ARGS();
|
|
printf("}\n\n");
|
|
return TABLESWITCH_NEXT_PC;
|
|
}
|
|
case 171: // lookupswitch
|
|
{
|
|
LOOKUPSWITCH_ARGS;
|
|
printf("%4d: lookupswitch {\n", pc);
|
|
LOOKUPSWITCH_PRINT_ARGS();
|
|
printf("}\n\n");
|
|
return LOOKUPSWITCH_NEXT_PC;
|
|
}
|
|
case 172: // ireturn
|
|
{
|
|
printf("%4d: ireturn \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 173: // lreturn
|
|
{
|
|
printf("%4d: lreturn \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 174: // freturn
|
|
{
|
|
printf("%4d: freturn \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 175: // dreturn
|
|
{
|
|
printf("%4d: dreturn \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 176: // areturn
|
|
{
|
|
printf("%4d: areturn \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 177: // return
|
|
{
|
|
printf("%4d: return \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 178: // getstatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: getstatic %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 179: // putstatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: putstatic %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 180: // getfield
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: getfield %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 181: // putfield
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: putfield %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 182: // invokevirtual
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: invokevirtual %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 183: // invokespecial
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: invokespecial %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 184: // invokestatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: invokestatic %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 185: // invokeinterface
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
uint32_t count = _u1(&code[pc + 3]);
|
|
printf("%4d: invokeinterface %u, %u\n", pc, index, count);
|
|
return pc + 5;
|
|
}
|
|
case 186: // invokedynamic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: invokedynamic %u\n", pc, index);
|
|
return pc + 5;
|
|
}
|
|
case 187: // new
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: new %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 188: // newarray
|
|
{
|
|
uint32_t atype = _u1(&code[pc + 1]);
|
|
printf("%4d: newarray %u\n", pc, atype);
|
|
return pc + 2;
|
|
}
|
|
case 189: // anewarray
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: anewarray %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 190: // arraylength
|
|
{
|
|
printf("%4d: arraylength \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 191: // athrow
|
|
{
|
|
printf("%4d: athrow \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 192: // checkcast
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: checkcast %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 193: // instanceof
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
printf("%4d: instanceof %u\n", pc, index);
|
|
return pc + 3;
|
|
}
|
|
case 194: // monitorenter
|
|
{
|
|
printf("%4d: monitorenter \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 195: // monitorexit
|
|
{
|
|
printf("%4d: monitorexit \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 196: // wide
|
|
{
|
|
WIDE_ARGS;
|
|
printf("%4d: wide {", pc);
|
|
WIDE_PRINT_ARGS();
|
|
printf("}\n");
|
|
return WIDE_NEXT_PC;
|
|
}
|
|
case 197: // multianewarray
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
uint32_t dimensions = _u1(&code[pc + 3]);
|
|
printf("%4d: multianewarray %u, %u\n", pc, index, dimensions);
|
|
return pc + 4;
|
|
}
|
|
case 198: // ifnull
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifnull %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 199: // ifnonnull
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: ifnonnull %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 200: // goto_w
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
printf("%4d: goto_w %d\n", pc, branch);
|
|
return pc + 3;
|
|
}
|
|
case 201: // jsr_w
|
|
{
|
|
int32_t branch = _s4(&code[pc + 1]);
|
|
printf("%4d: jsr_w %d\n", pc, branch);
|
|
return pc + 5;
|
|
}
|
|
case 202: // breakpoint
|
|
{
|
|
printf("%4d: breakpoint \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 254: // impdep1
|
|
{
|
|
printf("%4d: impdep1 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
case 255: // impdep2
|
|
{
|
|
printf("%4d: impdep2 \n", pc);
|
|
return pc + 1;
|
|
}
|
|
default:
|
|
{
|
|
assert(false);
|
|
return pc;
|
|
}
|
|
}
|
|
}
|
|
void decode_execute_instruction(struct vm * vm, const uint8_t * code, uint32_t pc)
|
|
{
|
|
switch (code[pc]) {
|
|
case 0: // nop
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_nop(vm);
|
|
break;
|
|
}
|
|
case 1: // aconst_null
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aconst_null(vm);
|
|
break;
|
|
}
|
|
case 2: // iconst_m1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_m1(vm);
|
|
break;
|
|
}
|
|
case 3: // iconst_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_0(vm);
|
|
break;
|
|
}
|
|
case 4: // iconst_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_1(vm);
|
|
break;
|
|
}
|
|
case 5: // iconst_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_2(vm);
|
|
break;
|
|
}
|
|
case 6: // iconst_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_3(vm);
|
|
break;
|
|
}
|
|
case 7: // iconst_4
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_4(vm);
|
|
break;
|
|
}
|
|
case 8: // iconst_5
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iconst_5(vm);
|
|
break;
|
|
}
|
|
case 9: // lconst_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lconst_0(vm);
|
|
break;
|
|
}
|
|
case 10: // lconst_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lconst_1(vm);
|
|
break;
|
|
}
|
|
case 11: // fconst_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fconst_0(vm);
|
|
break;
|
|
}
|
|
case 12: // fconst_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fconst_1(vm);
|
|
break;
|
|
}
|
|
case 13: // fconst_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fconst_2(vm);
|
|
break;
|
|
}
|
|
case 14: // dconst_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dconst_0(vm);
|
|
break;
|
|
}
|
|
case 15: // dconst_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dconst_1(vm);
|
|
break;
|
|
}
|
|
case 16: // bipush
|
|
{
|
|
int32_t byte = _s1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_bipush(vm, byte);
|
|
break;
|
|
}
|
|
case 17: // sipush
|
|
{
|
|
int32_t byte = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_sipush(vm, byte);
|
|
break;
|
|
}
|
|
case 18: // ldc
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_ldc(vm, index);
|
|
break;
|
|
}
|
|
case 19: // ldc_w
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ldc_w(vm, index);
|
|
break;
|
|
}
|
|
case 20: // ldc2_w
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ldc2_w(vm, index);
|
|
break;
|
|
}
|
|
case 21: // iload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_iload(vm, index);
|
|
break;
|
|
}
|
|
case 22: // lload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_lload(vm, index);
|
|
break;
|
|
}
|
|
case 23: // fload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_fload(vm, index);
|
|
break;
|
|
}
|
|
case 24: // dload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_dload(vm, index);
|
|
break;
|
|
}
|
|
case 25: // aload
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_aload(vm, index);
|
|
break;
|
|
}
|
|
case 26: // iload_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iload_0(vm);
|
|
break;
|
|
}
|
|
case 27: // iload_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iload_1(vm);
|
|
break;
|
|
}
|
|
case 28: // iload_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iload_2(vm);
|
|
break;
|
|
}
|
|
case 29: // iload_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iload_3(vm);
|
|
break;
|
|
}
|
|
case 30: // lload_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lload_0(vm);
|
|
break;
|
|
}
|
|
case 31: // lload_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lload_1(vm);
|
|
break;
|
|
}
|
|
case 32: // lload_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lload_2(vm);
|
|
break;
|
|
}
|
|
case 33: // lload_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lload_3(vm);
|
|
break;
|
|
}
|
|
case 34: // fload_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fload_0(vm);
|
|
break;
|
|
}
|
|
case 35: // fload_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fload_1(vm);
|
|
break;
|
|
}
|
|
case 36: // fload_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fload_2(vm);
|
|
break;
|
|
}
|
|
case 37: // fload_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fload_3(vm);
|
|
break;
|
|
}
|
|
case 38: // dload_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dload_0(vm);
|
|
break;
|
|
}
|
|
case 39: // dload_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dload_1(vm);
|
|
break;
|
|
}
|
|
case 40: // dload_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dload_2(vm);
|
|
break;
|
|
}
|
|
case 41: // dload_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dload_3(vm);
|
|
break;
|
|
}
|
|
case 42: // aload_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aload_0(vm);
|
|
break;
|
|
}
|
|
case 43: // aload_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aload_1(vm);
|
|
break;
|
|
}
|
|
case 44: // aload_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aload_2(vm);
|
|
break;
|
|
}
|
|
case 45: // aload_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aload_3(vm);
|
|
break;
|
|
}
|
|
case 46: // iaload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iaload(vm);
|
|
break;
|
|
}
|
|
case 47: // laload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_laload(vm);
|
|
break;
|
|
}
|
|
case 48: // faload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_faload(vm);
|
|
break;
|
|
}
|
|
case 49: // daload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_daload(vm);
|
|
break;
|
|
}
|
|
case 50: // aaload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aaload(vm);
|
|
break;
|
|
}
|
|
case 51: // baload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_baload(vm);
|
|
break;
|
|
}
|
|
case 52: // caload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_caload(vm);
|
|
break;
|
|
}
|
|
case 53: // saload
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_saload(vm);
|
|
break;
|
|
}
|
|
case 54: // istore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_istore(vm, index);
|
|
break;
|
|
}
|
|
case 55: // lstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_lstore(vm, index);
|
|
break;
|
|
}
|
|
case 56: // fstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_fstore(vm, index);
|
|
break;
|
|
}
|
|
case 57: // dstore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_dstore(vm, index);
|
|
break;
|
|
}
|
|
case 58: // astore
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_astore(vm, index);
|
|
break;
|
|
}
|
|
case 59: // istore_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_istore_0(vm);
|
|
break;
|
|
}
|
|
case 60: // istore_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_istore_1(vm);
|
|
break;
|
|
}
|
|
case 61: // istore_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_istore_2(vm);
|
|
break;
|
|
}
|
|
case 62: // istore_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_istore_3(vm);
|
|
break;
|
|
}
|
|
case 63: // lstore_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lstore_0(vm);
|
|
break;
|
|
}
|
|
case 64: // lstore_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lstore_1(vm);
|
|
break;
|
|
}
|
|
case 65: // lstore_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lstore_2(vm);
|
|
break;
|
|
}
|
|
case 66: // lstore_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lstore_3(vm);
|
|
break;
|
|
}
|
|
case 67: // fstore_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fstore_0(vm);
|
|
break;
|
|
}
|
|
case 68: // fstore_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fstore_1(vm);
|
|
break;
|
|
}
|
|
case 69: // fstore_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fstore_2(vm);
|
|
break;
|
|
}
|
|
case 70: // fstore_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fstore_3(vm);
|
|
break;
|
|
}
|
|
case 71: // dstore_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dstore_0(vm);
|
|
break;
|
|
}
|
|
case 72: // dstore_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dstore_1(vm);
|
|
break;
|
|
}
|
|
case 73: // dstore_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dstore_2(vm);
|
|
break;
|
|
}
|
|
case 74: // dstore_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dstore_3(vm);
|
|
break;
|
|
}
|
|
case 75: // astore_0
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_astore_0(vm);
|
|
break;
|
|
}
|
|
case 76: // astore_1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_astore_1(vm);
|
|
break;
|
|
}
|
|
case 77: // astore_2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_astore_2(vm);
|
|
break;
|
|
}
|
|
case 78: // astore_3
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_astore_3(vm);
|
|
break;
|
|
}
|
|
case 79: // iastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iastore(vm);
|
|
break;
|
|
}
|
|
case 80: // lastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lastore(vm);
|
|
break;
|
|
}
|
|
case 81: // fastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fastore(vm);
|
|
break;
|
|
}
|
|
case 82: // dastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dastore(vm);
|
|
break;
|
|
}
|
|
case 83: // aastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_aastore(vm);
|
|
break;
|
|
}
|
|
case 84: // bastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_bastore(vm);
|
|
break;
|
|
}
|
|
case 85: // castore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_castore(vm);
|
|
break;
|
|
}
|
|
case 86: // sastore
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_sastore(vm);
|
|
break;
|
|
}
|
|
case 87: // pop
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_pop(vm);
|
|
break;
|
|
}
|
|
case 88: // pop2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_pop2(vm);
|
|
break;
|
|
}
|
|
case 89: // dup
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup(vm);
|
|
break;
|
|
}
|
|
case 90: // dup_x1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup_x1(vm);
|
|
break;
|
|
}
|
|
case 91: // dup_x2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup_x2(vm);
|
|
break;
|
|
}
|
|
case 92: // dup2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup2(vm);
|
|
break;
|
|
}
|
|
case 93: // dup2_x1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup2_x1(vm);
|
|
break;
|
|
}
|
|
case 94: // dup2_x2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dup2_x2(vm);
|
|
break;
|
|
}
|
|
case 95: // swap
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_swap(vm);
|
|
break;
|
|
}
|
|
case 96: // iadd
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iadd(vm);
|
|
break;
|
|
}
|
|
case 97: // ladd
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ladd(vm);
|
|
break;
|
|
}
|
|
case 98: // fadd
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fadd(vm);
|
|
break;
|
|
}
|
|
case 99: // dadd
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dadd(vm);
|
|
break;
|
|
}
|
|
case 100: // isub
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_isub(vm);
|
|
break;
|
|
}
|
|
case 101: // lsub
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lsub(vm);
|
|
break;
|
|
}
|
|
case 102: // fsub
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fsub(vm);
|
|
break;
|
|
}
|
|
case 103: // dsub
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dsub(vm);
|
|
break;
|
|
}
|
|
case 104: // imul
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_imul(vm);
|
|
break;
|
|
}
|
|
case 105: // lmul
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lmul(vm);
|
|
break;
|
|
}
|
|
case 106: // fmul
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fmul(vm);
|
|
break;
|
|
}
|
|
case 107: // dmul
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dmul(vm);
|
|
break;
|
|
}
|
|
case 108: // idiv
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_idiv(vm);
|
|
break;
|
|
}
|
|
case 109: // ldiv
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ldiv(vm);
|
|
break;
|
|
}
|
|
case 110: // fdiv
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fdiv(vm);
|
|
break;
|
|
}
|
|
case 111: // ddiv
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ddiv(vm);
|
|
break;
|
|
}
|
|
case 112: // irem
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_irem(vm);
|
|
break;
|
|
}
|
|
case 113: // lrem
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lrem(vm);
|
|
break;
|
|
}
|
|
case 114: // frem
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_frem(vm);
|
|
break;
|
|
}
|
|
case 115: // drem
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_drem(vm);
|
|
break;
|
|
}
|
|
case 116: // ineg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ineg(vm);
|
|
break;
|
|
}
|
|
case 117: // lneg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lneg(vm);
|
|
break;
|
|
}
|
|
case 118: // fneg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fneg(vm);
|
|
break;
|
|
}
|
|
case 119: // dneg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dneg(vm);
|
|
break;
|
|
}
|
|
case 120: // ishl
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ishl(vm);
|
|
break;
|
|
}
|
|
case 121: // lshl
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lshl(vm);
|
|
break;
|
|
}
|
|
case 122: // ishr
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ishr(vm);
|
|
break;
|
|
}
|
|
case 123: // lshr
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lshr(vm);
|
|
break;
|
|
}
|
|
case 124: // iushr
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iushr(vm);
|
|
break;
|
|
}
|
|
case 125: // lushr
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lushr(vm);
|
|
break;
|
|
}
|
|
case 126: // iand
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_iand(vm);
|
|
break;
|
|
}
|
|
case 127: // land
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_land(vm);
|
|
break;
|
|
}
|
|
case 128: // ior
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ior(vm);
|
|
break;
|
|
}
|
|
case 129: // lor
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lor(vm);
|
|
break;
|
|
}
|
|
case 130: // ixor
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ixor(vm);
|
|
break;
|
|
}
|
|
case 131: // lxor
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lxor(vm);
|
|
break;
|
|
}
|
|
case 132: // iinc
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
int32_t _const = _s1(&code[pc + 2]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_iinc(vm, index, _const);
|
|
break;
|
|
}
|
|
case 133: // i2l
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2l(vm);
|
|
break;
|
|
}
|
|
case 134: // i2f
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2f(vm);
|
|
break;
|
|
}
|
|
case 135: // i2d
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2d(vm);
|
|
break;
|
|
}
|
|
case 136: // l2i
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_l2i(vm);
|
|
break;
|
|
}
|
|
case 137: // l2f
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_l2f(vm);
|
|
break;
|
|
}
|
|
case 138: // l2d
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_l2d(vm);
|
|
break;
|
|
}
|
|
case 139: // f2i
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_f2i(vm);
|
|
break;
|
|
}
|
|
case 140: // f2l
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_f2l(vm);
|
|
break;
|
|
}
|
|
case 141: // f2d
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_f2d(vm);
|
|
break;
|
|
}
|
|
case 142: // d2i
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_d2i(vm);
|
|
break;
|
|
}
|
|
case 143: // d2l
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_d2l(vm);
|
|
break;
|
|
}
|
|
case 144: // d2f
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_d2f(vm);
|
|
break;
|
|
}
|
|
case 145: // i2b
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2b(vm);
|
|
break;
|
|
}
|
|
case 146: // i2c
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2c(vm);
|
|
break;
|
|
}
|
|
case 147: // i2s
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_i2s(vm);
|
|
break;
|
|
}
|
|
case 148: // lcmp
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lcmp(vm);
|
|
break;
|
|
}
|
|
case 149: // fcmpl
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fcmpl(vm);
|
|
break;
|
|
}
|
|
case 150: // fcmpg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_fcmpg(vm);
|
|
break;
|
|
}
|
|
case 151: // dcmpl
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dcmpl(vm);
|
|
break;
|
|
}
|
|
case 152: // dcmpg
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dcmpg(vm);
|
|
break;
|
|
}
|
|
case 153: // ifeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifeq(vm, branch);
|
|
break;
|
|
}
|
|
case 154: // ifne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifne(vm, branch);
|
|
break;
|
|
}
|
|
case 155: // iflt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_iflt(vm, branch);
|
|
break;
|
|
}
|
|
case 156: // ifge
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifge(vm, branch);
|
|
break;
|
|
}
|
|
case 157: // ifgt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifgt(vm, branch);
|
|
break;
|
|
}
|
|
case 158: // ifle
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifle(vm, branch);
|
|
break;
|
|
}
|
|
case 159: // if_icmpeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmpeq(vm, branch);
|
|
break;
|
|
}
|
|
case 160: // if_icmpne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmpne(vm, branch);
|
|
break;
|
|
}
|
|
case 161: // if_icmplt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmplt(vm, branch);
|
|
break;
|
|
}
|
|
case 162: // if_icmpge
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmpge(vm, branch);
|
|
break;
|
|
}
|
|
case 163: // if_icmpgt
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmpgt(vm, branch);
|
|
break;
|
|
}
|
|
case 164: // if_icmple
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_icmple(vm, branch);
|
|
break;
|
|
}
|
|
case 165: // if_acmpeq
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_acmpeq(vm, branch);
|
|
break;
|
|
}
|
|
case 166: // if_acmpne
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_if_acmpne(vm, branch);
|
|
break;
|
|
}
|
|
case 167: // goto
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_goto(vm, branch);
|
|
break;
|
|
}
|
|
case 168: // jsr
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_jsr(vm, branch);
|
|
break;
|
|
}
|
|
case 169: // ret
|
|
{
|
|
uint32_t index = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_ret(vm, index);
|
|
break;
|
|
}
|
|
case 170: // tableswitch
|
|
{
|
|
TABLESWITCH_ARGS;
|
|
vm->current_frame->next_pc = TABLESWITCH_NEXT_PC;
|
|
op_tableswitch(vm, defaultbyte, lowbyte, highbyte, table);
|
|
break;
|
|
}
|
|
case 171: // lookupswitch
|
|
{
|
|
LOOKUPSWITCH_ARGS;
|
|
vm->current_frame->next_pc = LOOKUPSWITCH_NEXT_PC;
|
|
op_lookupswitch(vm, defaultbyte, npairs, table);
|
|
break;
|
|
}
|
|
case 172: // ireturn
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_ireturn(vm);
|
|
break;
|
|
}
|
|
case 173: // lreturn
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_lreturn(vm);
|
|
break;
|
|
}
|
|
case 174: // freturn
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_freturn(vm);
|
|
break;
|
|
}
|
|
case 175: // dreturn
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_dreturn(vm);
|
|
break;
|
|
}
|
|
case 176: // areturn
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_areturn(vm);
|
|
break;
|
|
}
|
|
case 177: // return
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_return(vm);
|
|
break;
|
|
}
|
|
case 178: // getstatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_getstatic(vm, index);
|
|
break;
|
|
}
|
|
case 179: // putstatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_putstatic(vm, index);
|
|
break;
|
|
}
|
|
case 180: // getfield
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_getfield(vm, index);
|
|
break;
|
|
}
|
|
case 181: // putfield
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_putfield(vm, index);
|
|
break;
|
|
}
|
|
case 182: // invokevirtual
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_invokevirtual(vm, index);
|
|
break;
|
|
}
|
|
case 183: // invokespecial
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_invokespecial(vm, index);
|
|
break;
|
|
}
|
|
case 184: // invokestatic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_invokestatic(vm, index);
|
|
break;
|
|
}
|
|
case 185: // invokeinterface
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
uint32_t count = _u1(&code[pc + 3]);
|
|
vm->current_frame->next_pc = pc + 5;
|
|
op_invokeinterface(vm, index, count);
|
|
break;
|
|
}
|
|
case 186: // invokedynamic
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 5;
|
|
op_invokedynamic(vm, index);
|
|
break;
|
|
}
|
|
case 187: // new
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_new(vm, index);
|
|
break;
|
|
}
|
|
case 188: // newarray
|
|
{
|
|
uint32_t atype = _u1(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 2;
|
|
op_newarray(vm, atype);
|
|
break;
|
|
}
|
|
case 189: // anewarray
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_anewarray(vm, index);
|
|
break;
|
|
}
|
|
case 190: // arraylength
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_arraylength(vm);
|
|
break;
|
|
}
|
|
case 191: // athrow
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_athrow(vm);
|
|
break;
|
|
}
|
|
case 192: // checkcast
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_checkcast(vm, index);
|
|
break;
|
|
}
|
|
case 193: // instanceof
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_instanceof(vm, index);
|
|
break;
|
|
}
|
|
case 194: // monitorenter
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_monitorenter(vm);
|
|
break;
|
|
}
|
|
case 195: // monitorexit
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_monitorexit(vm);
|
|
break;
|
|
}
|
|
case 196: // wide
|
|
{
|
|
WIDE_ARGS;
|
|
WIDE_IMPL();
|
|
break;
|
|
}
|
|
case 197: // multianewarray
|
|
{
|
|
uint32_t index = _u2(&code[pc + 1]);
|
|
uint32_t dimensions = _u1(&code[pc + 3]);
|
|
vm->current_frame->next_pc = pc + 4;
|
|
op_multianewarray(vm, index, dimensions);
|
|
break;
|
|
}
|
|
case 198: // ifnull
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifnull(vm, branch);
|
|
break;
|
|
}
|
|
case 199: // ifnonnull
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_ifnonnull(vm, branch);
|
|
break;
|
|
}
|
|
case 200: // goto_w
|
|
{
|
|
int32_t branch = _s2(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 3;
|
|
op_goto_w(vm, branch);
|
|
break;
|
|
}
|
|
case 201: // jsr_w
|
|
{
|
|
int32_t branch = _s4(&code[pc + 1]);
|
|
vm->current_frame->next_pc = pc + 5;
|
|
op_jsr_w(vm, branch);
|
|
break;
|
|
}
|
|
case 202: // breakpoint
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_breakpoint(vm);
|
|
break;
|
|
}
|
|
case 254: // impdep1
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_impdep1(vm);
|
|
break;
|
|
}
|
|
case 255: // impdep2
|
|
{
|
|
vm->current_frame->next_pc = pc + 1;
|
|
op_impdep2(vm);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|