public boolean isInstanceofRedundant(InstanceofInstruction instruction) {
   return !myUsefulInstanceofs.contains(instruction)
       && !instruction.isConditionConst()
       && myReachable.contains(instruction);
 }
Exemple #2
0
  private int decodeBytecodeInstruction(int index, int stackLen, byte[] stackWords)
      throws InvalidBytecodeException {
    int opcode = code[index] & 0xFF;

    Instruction i = simpleInstructions[opcode];
    if (i != null) {
      decoded.add(i);
      return index + 1;
    }

    boolean wide = false;

    while (true) {
      index++;

      switch (opcode) {
        case OP_nop:
          break;
        case OP_bipush:
          i = ConstantInstruction.make(code[index]);
          index++;
          break;
        case OP_sipush:
          i = ConstantInstruction.make(decodeShort(index));
          index += 2;
          break;
        case OP_ldc:
          i = makeConstantPoolLoad(code[index] & 0xFF);
          index++;
          break;
        case OP_ldc_w:
          i = makeConstantPoolLoad(decodeShort(index));
          index += 2;
          break;
        case OP_ldc2_w:
          i = makeConstantPoolLoad(decodeShort(index));
          index += 2;
          break;
        case OP_iload:
        case OP_lload:
        case OP_fload:
        case OP_dload:
        case OP_aload:
          i =
              LoadInstruction.make(
                  indexedTypes[opcode - OP_iload],
                  wide ? decodeUShort(index) : (code[index] & 0xFF));
          index += wide ? 2 : 1;
          break;
        case OP_istore:
        case OP_lstore:
        case OP_fstore:
        case OP_dstore:
        case OP_astore:
          i =
              StoreInstruction.make(
                  indexedTypes[opcode - OP_istore],
                  wide ? decodeUShort(index) : (code[index] & 0xFF));
          index += wide ? 2 : 1;
          break;
        case OP_pop2:
          i = PopInstruction.make(elemCount(stackWords, stackLen - 1));
          break;
        case OP_dup_x2:
          i = DupInstruction.make(1, elemCount(stackWords, stackLen - 2));
          break;
        case OP_dup2:
          i = DupInstruction.make(elemCount(stackWords, stackLen - 1), 0);
          break;
        case OP_dup2_x1:
          i = DupInstruction.make(elemCount(stackWords, stackLen - 1), 1);
          break;
        case OP_dup2_x2:
          i =
              DupInstruction.make(
                  elemCount(stackWords, stackLen - 1), elemCount(stackWords, stackLen - 2));
          break;
        case OP_iinc:
          {
            int v = wide ? decodeUShort(index) : (code[index] & 0xFF);
            int c = wide ? decodeShort(index + 2) : code[index + 1];

            decoded.add(LoadInstruction.make(TYPE_int, v));
            decoded.add(ConstantInstruction.make(c));
            decoded.add(BinaryOpInstruction.make(TYPE_int, Operator.ADD));
            i = StoreInstruction.make(TYPE_int, v);
            index += wide ? 4 : 2;
            break;
          }
        case OP_ifeq:
        case OP_ifne:
        case OP_iflt:
        case OP_ifle:
        case OP_ifgt:
        case OP_ifge:
          decoded.add(makeZero);
          i =
              ConditionalBranchInstruction.make(
                  TYPE_int,
                  ConditionalBranchInstruction.Operator.values()[opcode - OP_ifeq],
                  (index - 1) + decodeShort(index));
          index += 2;
          break;
        case OP_if_icmpeq:
        case OP_if_icmpne:
        case OP_if_icmplt:
        case OP_if_icmple:
        case OP_if_icmpgt:
        case OP_if_icmpge:
          i = ConditionalBranchInstruction.make((short) opcode, (index - 1) + decodeShort(index));
          index += 2;
          break;
        case OP_if_acmpeq:
        case OP_if_acmpne:
          i =
              ConditionalBranchInstruction.make(
                  TYPE_Object,
                  ConditionalBranchInstruction.Operator.values()[opcode - OP_if_acmpeq],
                  (index - 1) + decodeShort(index));
          index += 2;
          break;
        case OP_goto:
          i = GotoInstruction.make((index - 1) + decodeShort(index));
          index += 2;
          break;
        case OP_jsr:
          {
            index += 2;
            break;
          }
        case OP_jsr_w:
          {
            index += 4;
            break;
          }
        case OP_ret:
          int v = wide ? decodeUShort(index) : (code[index] & 0xFF);
          i = GotoInstruction.make(-1 - v);

          if (retInfo == null) {
            throw new InvalidBytecodeException("'ret' outside of subroutine");
          }
          retInfo[index - (wide ? 2 : 1)] = new RetInfo(-1, v, stackLen, stackWords);

          index += wide ? 2 : 1;
          break;
        case OP_tableswitch:
          {
            int start = index - 1;
            while ((index & 3) != 0) {
              index++;
            }
            int def = start + decodeInt(index);
            int low = decodeInt(index + 4);
            int high = decodeInt(index + 8);
            int[] t = new int[(high - low + 1) * 2];

            for (int j = 0; j < t.length; j += 2) {
              t[j] = j / 2 + low;
              t[j + 1] = start + decodeInt(index + 12 + j * 2);
            }
            i = SwitchInstruction.make(t, def);
            index += 12 + (high - low + 1) * 4;
            break;
          }
        case OP_lookupswitch:
          {
            int start = index - 1;
            while ((index & 3) != 0) {
              index++;
            }
            int def = start + decodeInt(index);
            int n = decodeInt(index + 4);
            int[] t = new int[n * 2];

            for (int j = 0; j < t.length; j += 2) {
              t[j] = decodeInt(index + 8 + j * 4);
              t[j + 1] = start + decodeInt(index + 12 + j * 4);
            }
            i = SwitchInstruction.make(t, def);
            index += 8 + n * 8;
            break;
          }
        case OP_getstatic:
        case OP_getfield:
          {
            int f = decodeUShort(index);
            i = GetInstruction.make(constantPool, f, opcode == OP_getstatic);
            index += 2;
            break;
          }
        case OP_putstatic:
        case OP_putfield:
          {
            int f = decodeUShort(index);
            i = PutInstruction.make(constantPool, f, opcode == OP_putstatic);
            index += 2;
            break;
          }
        case OP_invokevirtual:
        case OP_invokespecial:
        case OP_invokestatic:
          {
            int m = decodeUShort(index);
            i = InvokeInstruction.make(constantPool, m, opcode);
            index += 2;
            break;
          }
        case OP_invokeinterface:
          {
            int m = decodeUShort(index);
            i = InvokeInstruction.make(constantPool, m, opcode);
            index += 4;
            break;
          }
        case OP_new:
          i = NewInstruction.make(constantPool.getConstantPoolClassType(decodeUShort(index)), 0);
          index += 2;
          break;
        case OP_newarray:
          i = NewInstruction.make(Util.makeArray(getPrimitiveType(code[index])), 1);
          index++;
          break;
        case OP_anewarray:
          i =
              NewInstruction.make(
                  Util.makeArray(constantPool.getConstantPoolClassType(decodeUShort(index))), 1);
          index += 2;
          break;
        case OP_checkcast:
          i = CheckCastInstruction.make(constantPool.getConstantPoolClassType(decodeUShort(index)));
          index += 2;
          break;
        case OP_instanceof:
          i =
              InstanceofInstruction.make(
                  constantPool.getConstantPoolClassType(decodeUShort(index)));
          index += 2;
          break;
        case OP_wide:
          wide = true;
          opcode = code[index] & 0xFF;
          continue;
        case OP_multianewarray:
          i =
              NewInstruction.make(
                  constantPool.getConstantPoolClassType(decodeUShort(index)),
                  code[index + 2] & 0xFF);
          index += 3;
          break;
        case OP_ifnull:
        case OP_ifnonnull:
          decoded.add(ConstantInstruction.make(TYPE_Object, null));
          i =
              ConditionalBranchInstruction.make(
                  TYPE_Object,
                  ConditionalBranchInstruction.Operator.values()[opcode - OP_ifnull],
                  (index - 1) + decodeShort(index));
          index += 2;
          break;
        case OP_goto_w:
          i = GotoInstruction.make((index - 1) + decodeInt(index));
          index += 4;
          break;
        default:
          throw new InvalidBytecodeException("Unknown opcode " + opcode);
      }

      break;
    }

    if (i != null) {
      decoded.add(i);
    }

    return index;
  }