Esempio n. 1
0
 public Value naryOperation(final AbstractInsnNode insn, final List values)
     throws AnalyzerException {
   int opcode = insn.getOpcode();
   if (opcode == MULTIANEWARRAY) {
     for (int i = 0; i < values.size(); ++i) {
       if (!BasicValue.INT_VALUE.equals(values.get(i))) {
         throw new AnalyzerException(insn, null, BasicValue.INT_VALUE, (Value) values.get(i));
       }
     }
   } else {
     int i = 0;
     int j = 0;
     if (opcode != INVOKESTATIC && opcode != INVOKEDYNAMIC) {
       Type owner = Type.getObjectType(((MethodInsnNode) insn).owner);
       if (!isSubTypeOf((Value) values.get(i++), newValue(owner))) {
         throw new AnalyzerException(insn, "Method owner", newValue(owner), (Value) values.get(0));
       }
     }
     Type[] args = Type.getArgumentTypes(((MethodInsnNode) insn).desc);
     while (i < values.size()) {
       Value expected = newValue(args[j++]);
       Value encountered = (Value) values.get(i++);
       if (!isSubTypeOf(encountered, expected)) {
         throw new AnalyzerException(insn, "Argument " + j, expected, encountered);
       }
     }
   }
   return super.naryOperation(insn, values);
 }
Esempio n. 2
0
 public Value ternaryOperation(
     final AbstractInsnNode insn, final Value value1, final Value value2, final Value value3)
     throws AnalyzerException {
   Value expected1;
   Value expected3;
   switch (insn.getOpcode()) {
     case IASTORE:
       expected1 = newValue(Type.getType("[I"));
       expected3 = BasicValue.INT_VALUE;
       break;
     case BASTORE:
       if (isSubTypeOf(value1, newValue(Type.getType("[Z")))) {
         expected1 = newValue(Type.getType("[Z"));
       } else {
         expected1 = newValue(Type.getType("[B"));
       }
       expected3 = BasicValue.INT_VALUE;
       break;
     case CASTORE:
       expected1 = newValue(Type.getType("[C"));
       expected3 = BasicValue.INT_VALUE;
       break;
     case SASTORE:
       expected1 = newValue(Type.getType("[S"));
       expected3 = BasicValue.INT_VALUE;
       break;
     case LASTORE:
       expected1 = newValue(Type.getType("[J"));
       expected3 = BasicValue.LONG_VALUE;
       break;
     case FASTORE:
       expected1 = newValue(Type.getType("[F"));
       expected3 = BasicValue.FLOAT_VALUE;
       break;
     case DASTORE:
       expected1 = newValue(Type.getType("[D"));
       expected3 = BasicValue.DOUBLE_VALUE;
       break;
     case AASTORE:
       expected1 = value1;
       expected3 = BasicValue.REFERENCE_VALUE;
       break;
     default:
       throw new Error("Internal error.");
   }
   if (!isSubTypeOf(value1, expected1)) {
     throw new AnalyzerException(
         insn, "First argument", "a " + expected1 + " array reference", value1);
   } else if (!BasicValue.INT_VALUE.equals(value2)) {
     throw new AnalyzerException(insn, "Second argument", BasicValue.INT_VALUE, value2);
   } else if (!isSubTypeOf(value3, expected3)) {
     throw new AnalyzerException(insn, "Third argument", expected3, value3);
   }
   return null;
 }
Esempio n. 3
0
 public Value unaryOperation(final AbstractInsnNode insn, final Value value)
     throws AnalyzerException {
   Value expected;
   switch (insn.getOpcode()) {
     case INEG:
     case IINC:
     case I2F:
     case I2L:
     case I2D:
     case I2B:
     case I2C:
     case I2S:
     case IFEQ:
     case IFNE:
     case IFLT:
     case IFGE:
     case IFGT:
     case IFLE:
     case TABLESWITCH:
     case LOOKUPSWITCH:
     case IRETURN:
     case NEWARRAY:
     case ANEWARRAY:
       expected = BasicValue.INT_VALUE;
       break;
     case FNEG:
     case F2I:
     case F2L:
     case F2D:
     case FRETURN:
       expected = BasicValue.FLOAT_VALUE;
       break;
     case LNEG:
     case L2I:
     case L2F:
     case L2D:
     case LRETURN:
       expected = BasicValue.LONG_VALUE;
       break;
     case DNEG:
     case D2I:
     case D2F:
     case D2L:
     case DRETURN:
       expected = BasicValue.DOUBLE_VALUE;
       break;
     case GETFIELD:
       expected = newValue(Type.getObjectType(((FieldInsnNode) insn).owner));
       break;
     case CHECKCAST:
       if (!((BasicValue) value).isReference()) {
         throw new AnalyzerException(insn, null, "an object reference", value);
       }
       return super.unaryOperation(insn, value);
     case ARRAYLENGTH:
       if (!isArrayValue(value)) {
         throw new AnalyzerException(insn, null, "an array reference", value);
       }
       return super.unaryOperation(insn, value);
     case ARETURN:
     case ATHROW:
     case INSTANCEOF:
     case MONITORENTER:
     case MONITOREXIT:
     case IFNULL:
     case IFNONNULL:
       if (!((BasicValue) value).isReference()) {
         throw new AnalyzerException(insn, null, "an object reference", value);
       }
       return super.unaryOperation(insn, value);
     case PUTSTATIC:
       expected = newValue(Type.getType(((FieldInsnNode) insn).desc));
       break;
     default:
       throw new Error("Internal error.");
   }
   if (!isSubTypeOf(value, expected)) {
     throw new AnalyzerException(insn, null, expected, value);
   }
   return super.unaryOperation(insn, value);
 }
Esempio n. 4
0
 public Value binaryOperation(final AbstractInsnNode insn, final Value value1, final Value value2)
     throws AnalyzerException {
   Value expected1;
   Value expected2;
   switch (insn.getOpcode()) {
     case IALOAD:
       expected1 = newValue(Type.getType("[I"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case BALOAD:
       if (isSubTypeOf(value1, newValue(Type.getType("[Z")))) {
         expected1 = newValue(Type.getType("[Z"));
       } else {
         expected1 = newValue(Type.getType("[B"));
       }
       expected2 = BasicValue.INT_VALUE;
       break;
     case CALOAD:
       expected1 = newValue(Type.getType("[C"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case SALOAD:
       expected1 = newValue(Type.getType("[S"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case LALOAD:
       expected1 = newValue(Type.getType("[J"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case FALOAD:
       expected1 = newValue(Type.getType("[F"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case DALOAD:
       expected1 = newValue(Type.getType("[D"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case AALOAD:
       expected1 = newValue(Type.getType("[Ljava/lang/Object;"));
       expected2 = BasicValue.INT_VALUE;
       break;
     case IADD:
     case ISUB:
     case IMUL:
     case IDIV:
     case IREM:
     case ISHL:
     case ISHR:
     case IUSHR:
     case IAND:
     case IOR:
     case IXOR:
     case IF_ICMPEQ:
     case IF_ICMPNE:
     case IF_ICMPLT:
     case IF_ICMPGE:
     case IF_ICMPGT:
     case IF_ICMPLE:
       expected1 = BasicValue.INT_VALUE;
       expected2 = BasicValue.INT_VALUE;
       break;
     case FADD:
     case FSUB:
     case FMUL:
     case FDIV:
     case FREM:
     case FCMPL:
     case FCMPG:
       expected1 = BasicValue.FLOAT_VALUE;
       expected2 = BasicValue.FLOAT_VALUE;
       break;
     case LADD:
     case LSUB:
     case LMUL:
     case LDIV:
     case LREM:
     case LAND:
     case LOR:
     case LXOR:
     case LCMP:
       expected1 = BasicValue.LONG_VALUE;
       expected2 = BasicValue.LONG_VALUE;
       break;
     case LSHL:
     case LSHR:
     case LUSHR:
       expected1 = BasicValue.LONG_VALUE;
       expected2 = BasicValue.INT_VALUE;
       break;
     case DADD:
     case DSUB:
     case DMUL:
     case DDIV:
     case DREM:
     case DCMPL:
     case DCMPG:
       expected1 = BasicValue.DOUBLE_VALUE;
       expected2 = BasicValue.DOUBLE_VALUE;
       break;
     case IF_ACMPEQ:
     case IF_ACMPNE:
       expected1 = BasicValue.REFERENCE_VALUE;
       expected2 = BasicValue.REFERENCE_VALUE;
       break;
     case PUTFIELD:
       FieldInsnNode fin = (FieldInsnNode) insn;
       expected1 = newValue(Type.getObjectType(fin.owner));
       expected2 = newValue(Type.getType(fin.desc));
       break;
     default:
       throw new Error("Internal error.");
   }
   if (!isSubTypeOf(value1, expected1)) {
     throw new AnalyzerException(insn, "First argument", expected1, value1);
   } else if (!isSubTypeOf(value2, expected2)) {
     throw new AnalyzerException(insn, "Second argument", expected2, value2);
   }
   if (insn.getOpcode() == AALOAD) {
     return getElementValue(value1);
   } else {
     return super.binaryOperation(insn, value1, value2);
   }
 }