Examples with IntType soot.IntType used on opensource projects

Example 16 with IntType

use of soot.IntType in project soot by Sable.

the class ASMBackendUtils method toTypeDesc.

/**
 * Convert type to JVM style type description
 * @param type Type to convert
 * @return JVM style type description
 */
public static String toTypeDesc(Type type) {
    final StringBuilder sb = new StringBuilder(1);
    type.apply(new TypeSwitch() {

        public void defaultCase(Type t) {
            throw new RuntimeException("Invalid type " + t.toString());
        }

        public void caseDoubleType(DoubleType t) {
            sb.append('D');
        }

        public void caseFloatType(FloatType t) {
            sb.append('F');
        }

        public void caseIntType(IntType t) {
            sb.append('I');
        }

        public void caseByteType(ByteType t) {
            sb.append('B');
        }

        public void caseShortType(ShortType t) {
            sb.append('S');
        }

        public void caseCharType(CharType t) {
            sb.append('C');
        }

        public void caseBooleanType(BooleanType t) {
            sb.append('Z');
        }

        public void caseLongType(LongType t) {
            sb.append('J');
        }

        public void caseArrayType(ArrayType t) {
            sb.append('[');
            t.getElementType().apply(this);
        }

        public void caseRefType(RefType t) {
            sb.append('L');
            sb.append(slashify(t.getClassName()));
            sb.append(';');
        }

        public void caseVoidType(VoidType t) {
            sb.append('V');
        }
    });
    return sb.toString();
}

Example 17 with IntType

use of soot.IntType in project soot by Sable.

the class BafASMBackend method generateInstruction.

/**
 * Emits the bytecode for a single Baf instruction
 *
 * @param mv
 *            The ASM MethodVisitor the bytecode is to be emitted to
 * @param inst
 *            The Baf instruction to be converted into bytecode
 */
protected void generateInstruction(final MethodVisitor mv, Inst inst) {
    inst.apply(new InstSwitch() {

        @Override
        public void caseReturnVoidInst(ReturnVoidInst i) {
            mv.visitInsn(Opcodes.RETURN);
        }

        @Override
        public void caseReturnInst(ReturnInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitInsn(Opcodes.ARETURN);
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.IRETURN);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.IRETURN);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.IRETURN);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DRETURN);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FRETURN);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IRETURN);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LRETURN);
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitInsn(Opcodes.ARETURN);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.IRETURN);
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitInsn(Opcodes.ARETURN);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("Invalid return type " + t.toString());
                }
            });
        }

        @Override
        public void caseNopInst(NopInst i) {
            mv.visitInsn(Opcodes.NOP);
        }

        @Override
        public void caseJSRInst(JSRInst i) {
            mv.visitJumpInsn(Opcodes.JSR, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void casePushInst(PushInst i) {
            Constant c = i.getConstant();
            if (c instanceof IntConstant) {
                int v = ((IntConstant) c).value;
                switch(v) {
                    case -1:
                        mv.visitInsn(Opcodes.ICONST_M1);
                        break;
                    case 0:
                        mv.visitInsn(Opcodes.ICONST_0);
                        break;
                    case 1:
                        mv.visitInsn(Opcodes.ICONST_1);
                        break;
                    case 2:
                        mv.visitInsn(Opcodes.ICONST_2);
                        break;
                    case 3:
                        mv.visitInsn(Opcodes.ICONST_3);
                        break;
                    case 4:
                        mv.visitInsn(Opcodes.ICONST_4);
                        break;
                    case 5:
                        mv.visitInsn(Opcodes.ICONST_5);
                        break;
                    default:
                        if (v >= Byte.MIN_VALUE && v <= Byte.MAX_VALUE) {
                            mv.visitIntInsn(Opcodes.BIPUSH, v);
                        } else if (v >= Short.MIN_VALUE && v <= Short.MAX_VALUE) {
                            mv.visitIntInsn(Opcodes.SIPUSH, v);
                        } else {
                            mv.visitLdcInsn(v);
                        }
                }
            } else if (c instanceof StringConstant) {
                mv.visitLdcInsn(((StringConstant) c).value);
            } else if (c instanceof ClassConstant) {
                mv.visitLdcInsn(org.objectweb.asm.Type.getType(((ClassConstant) c).getValue()));
            } else if (c instanceof DoubleConstant) {
                double v = ((DoubleConstant) c).value;
                /*
					 * Do not emit a DCONST_0 for negative zero, therefore we
					 * need the following check.
					 */
                if (new Double(v).equals(0.0)) {
                    mv.visitInsn(Opcodes.DCONST_0);
                } else if (v == 1) {
                    mv.visitInsn(Opcodes.DCONST_1);
                } else {
                    mv.visitLdcInsn(v);
                }
            } else if (c instanceof FloatConstant) {
                float v = ((FloatConstant) c).value;
                /*
					 * Do not emit a FCONST_0 for negative zero, therefore we
					 * need the following check.
					 */
                if (new Float(v).equals(0.0f)) {
                    mv.visitInsn(Opcodes.FCONST_0);
                } else if (v == 1) {
                    mv.visitInsn(Opcodes.FCONST_1);
                } else if (v == 2) {
                    mv.visitInsn(Opcodes.FCONST_2);
                } else {
                    mv.visitLdcInsn(v);
                }
            } else if (c instanceof LongConstant) {
                long v = ((LongConstant) c).value;
                if (v == 0) {
                    mv.visitInsn(Opcodes.LCONST_0);
                } else if (v == 1) {
                    mv.visitInsn(Opcodes.LCONST_1);
                } else {
                    mv.visitLdcInsn(v);
                }
            } else if (c instanceof NullConstant) {
                mv.visitInsn(Opcodes.ACONST_NULL);
            } else if (c instanceof MethodHandle) {
                SootMethodRef ref = ((MethodHandle) c).getMethodRef();
                int tag;
                if (ref.isStatic()) {
                    tag = Opcodes.H_INVOKESTATIC;
                } else if (ref.declaringClass().isInterface()) {
                    tag = Opcodes.H_INVOKEINTERFACE;
                } else {
                    tag = Opcodes.H_INVOKEVIRTUAL;
                }
                Handle handle = new Handle(tag, ref.declaringClass().getName(), ref.name(), ref.getSignature(), ref.declaringClass().isInnerClass());
                mv.visitLdcInsn(handle);
            } else {
                throw new RuntimeException("unsupported opcode");
            }
        }

        @Override
        public void casePopInst(PopInst i) {
            if (i.getWordCount() == 2) {
                mv.visitInsn(Opcodes.POP2);
            } else {
                mv.visitInsn(Opcodes.POP);
            }
        }

        @Override
        public void caseIdentityInst(IdentityInst i) {
            Value l = i.getLeftOp();
            Value r = i.getRightOp();
            if (r instanceof CaughtExceptionRef && l instanceof Local) {
                mv.visitVarInsn(Opcodes.ASTORE, localToSlot.get(l));
            // asm handles constant opcodes automatically here
            }
        }

        @Override
        public void caseStoreInst(StoreInst i) {
            final int slot = localToSlot.get(i.getLocal());
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitVarInsn(Opcodes.ASTORE, slot);
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitVarInsn(Opcodes.ISTORE, slot);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitVarInsn(Opcodes.ISTORE, slot);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitVarInsn(Opcodes.ISTORE, slot);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitVarInsn(Opcodes.DSTORE, slot);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitVarInsn(Opcodes.FSTORE, slot);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitVarInsn(Opcodes.ISTORE, slot);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitVarInsn(Opcodes.LSTORE, slot);
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitVarInsn(Opcodes.ASTORE, slot);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitVarInsn(Opcodes.ISTORE, slot);
                }

                @Override
                public void caseStmtAddressType(StmtAddressType t) {
                    throw new RuntimeException("JSR not supported, use recent Java compiler!");
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitVarInsn(Opcodes.ASTORE, slot);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("Invalid local type: " + t);
                }
            });
        }

        @Override
        public void caseGotoInst(GotoInst i) {
            mv.visitJumpInsn(Opcodes.GOTO, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseLoadInst(LoadInst i) {
            final int slot = localToSlot.get(i.getLocal());
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitVarInsn(Opcodes.ALOAD, slot);
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitVarInsn(Opcodes.ILOAD, slot);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitVarInsn(Opcodes.ILOAD, slot);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitVarInsn(Opcodes.ILOAD, slot);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitVarInsn(Opcodes.DLOAD, slot);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitVarInsn(Opcodes.FLOAD, slot);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitVarInsn(Opcodes.ILOAD, slot);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitVarInsn(Opcodes.LLOAD, slot);
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitVarInsn(Opcodes.ALOAD, slot);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitVarInsn(Opcodes.ILOAD, slot);
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitVarInsn(Opcodes.ALOAD, slot);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("Invalid local type: " + t);
                }
            });
        }

        @Override
        public void caseArrayWriteInst(ArrayWriteInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitInsn(Opcodes.AASTORE);
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.BASTORE);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.BASTORE);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.CASTORE);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DASTORE);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FASTORE);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IASTORE);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LASTORE);
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitInsn(Opcodes.AASTORE);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.SASTORE);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("Invalid type: " + t);
                }
            });
        }

        @Override
        public void caseArrayReadInst(ArrayReadInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitInsn(Opcodes.AALOAD);
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.BALOAD);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.BALOAD);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.CALOAD);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DALOAD);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FALOAD);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IALOAD);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LALOAD);
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitInsn(Opcodes.AALOAD);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.SALOAD);
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitInsn(Opcodes.AALOAD);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("Invalid type: " + t);
                }
            });
        }

        @Override
        public void caseIfNullInst(IfNullInst i) {
            mv.visitJumpInsn(Opcodes.IFNULL, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfNonNullInst(IfNonNullInst i) {
            mv.visitJumpInsn(Opcodes.IFNONNULL, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfEqInst(IfEqInst i) {
            mv.visitJumpInsn(Opcodes.IFEQ, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfNeInst(IfNeInst i) {
            mv.visitJumpInsn(Opcodes.IFNE, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfGtInst(IfGtInst i) {
            mv.visitJumpInsn(Opcodes.IFGT, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfGeInst(IfGeInst i) {
            mv.visitJumpInsn(Opcodes.IFGE, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfLtInst(IfLtInst i) {
            mv.visitJumpInsn(Opcodes.IFLT, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfLeInst(IfLeInst i) {
            mv.visitJumpInsn(Opcodes.IFLE, getBranchTargetLabel(i.getTarget()));
        }

        @Override
        public void caseIfCmpEqInst(final IfCmpEqInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPEQ, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIfCmpNeInst(final IfCmpNeInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseArrayType(ArrayType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseRefType(RefType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseNullType(NullType t) {
                    mv.visitJumpInsn(Opcodes.IF_ACMPNE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIfCmpGtInst(final IfCmpGtInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIfCmpGeInst(final IfCmpGeInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPGE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIfCmpLtInst(final IfCmpLtInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLT, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIfCmpLeInst(final IfCmpLeInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DCMPG);
                    mv.visitJumpInsn(Opcodes.IFLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LCMP);
                    mv.visitJumpInsn(Opcodes.IFLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitJumpInsn(Opcodes.IF_ICMPLE, getBranchTargetLabel(i.getTarget()));
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseStaticGetInst(StaticGetInst i) {
            SootFieldRef field = i.getFieldRef();
            mv.visitFieldInsn(Opcodes.GETSTATIC, slashify(field.declaringClass().getName()), field.name(), toTypeDesc(field.type()));
        }

        @Override
        public void caseStaticPutInst(StaticPutInst i) {
            SootFieldRef field = i.getFieldRef();
            mv.visitFieldInsn(Opcodes.PUTSTATIC, slashify(field.declaringClass().getName()), field.name(), toTypeDesc(field.type()));
        }

        @Override
        public void caseFieldGetInst(FieldGetInst i) {
            SootFieldRef field = i.getFieldRef();
            mv.visitFieldInsn(Opcodes.GETFIELD, slashify(field.declaringClass().getName()), field.name(), toTypeDesc(field.type()));
        }

        @Override
        public void caseFieldPutInst(FieldPutInst i) {
            SootFieldRef field = i.getFieldRef();
            mv.visitFieldInsn(Opcodes.PUTFIELD, slashify(field.declaringClass().getName()), field.name(), toTypeDesc(field.type()));
        }

        @Override
        public void caseInstanceCastInst(InstanceCastInst i) {
            Type castType = i.getCastType();
            if (castType instanceof RefType) {
                mv.visitTypeInsn(Opcodes.CHECKCAST, slashify(((RefType) castType).getClassName()));
            } else if (castType instanceof ArrayType) {
                mv.visitTypeInsn(Opcodes.CHECKCAST, toTypeDesc(castType));
            }
        }

        @Override
        public void caseInstanceOfInst(InstanceOfInst i) {
            Type checkType = i.getCheckType();
            if (checkType instanceof RefType) {
                mv.visitTypeInsn(Opcodes.INSTANCEOF, slashify(((RefType) checkType).getClassName()));
            } else if (checkType instanceof ArrayType) {
                mv.visitTypeInsn(Opcodes.INSTANCEOF, toTypeDesc(checkType));
            }
        }

        @Override
        public void casePrimitiveCastInst(PrimitiveCastInst i) {
            Type from = i.getFromType();
            final Type to = i.getToType();
            from.apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    emitIntToTypeCast();
                }

                @Override
                public void caseByteType(ByteType t) {
                    emitIntToTypeCast();
                }

                @Override
                public void caseCharType(CharType t) {
                    emitIntToTypeCast();
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    if (to.equals(IntType.v())) {
                        mv.visitInsn(Opcodes.D2I);
                    } else if (to.equals(LongType.v())) {
                        mv.visitInsn(Opcodes.D2L);
                    } else if (to.equals(FloatType.v())) {
                        mv.visitInsn(Opcodes.D2F);
                    } else {
                        throw new RuntimeException("invalid to-type from double");
                    }
                }

                @Override
                public void caseFloatType(FloatType t) {
                    if (to.equals(IntType.v())) {
                        mv.visitInsn(Opcodes.F2I);
                    } else if (to.equals(LongType.v())) {
                        mv.visitInsn(Opcodes.F2L);
                    } else if (to.equals(DoubleType.v())) {
                        mv.visitInsn(Opcodes.F2D);
                    } else {
                        throw new RuntimeException("invalid to-type from float");
                    }
                }

                @Override
                public void caseIntType(IntType t) {
                    emitIntToTypeCast();
                }

                @Override
                public void caseLongType(LongType t) {
                    if (to.equals(IntType.v())) {
                        mv.visitInsn(Opcodes.L2I);
                    } else if (to.equals(FloatType.v())) {
                        mv.visitInsn(Opcodes.L2F);
                    } else if (to.equals(DoubleType.v())) {
                        mv.visitInsn(Opcodes.L2D);
                    } else {
                        throw new RuntimeException("invalid to-type from long");
                    }
                }

                @Override
                public void caseShortType(ShortType t) {
                    emitIntToTypeCast();
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid from-type: " + t);
                }

                private void emitIntToTypeCast() {
                    if (to.equals(ByteType.v())) {
                        mv.visitInsn(Opcodes.I2B);
                    } else if (to.equals(CharType.v())) {
                        mv.visitInsn(Opcodes.I2C);
                    } else if (to.equals(ShortType.v())) {
                        mv.visitInsn(Opcodes.I2S);
                    } else if (to.equals(FloatType.v())) {
                        mv.visitInsn(Opcodes.I2F);
                    } else if (to.equals(LongType.v())) {
                        mv.visitInsn(Opcodes.I2L);
                    } else if (to.equals(DoubleType.v())) {
                        mv.visitInsn(Opcodes.I2D);
                    } else if (to.equals(IntType.v())) {
                    } else if (to.equals(BooleanType.v())) {
                    } else {
                        throw new RuntimeException("invalid to-type from int");
                    }
                }
            });
        }

        @Override
        public void caseDynamicInvokeInst(DynamicInvokeInst i) {
            SootMethodRef m = i.getMethodRef();
            SootMethodRef bsm = i.getBootstrapMethodRef();
            List<Value> args = i.getBootstrapArgs();
            final Object[] argsArray = new Object[args.size()];
            int index = 0;
            for (Value v : args) {
                final int j = index;
                v.apply(new ConstantSwitch() {

                    @Override
                    public void defaultCase(Object object) {
                        throw new RuntimeException("Unexpected constant type!");
                    }

                    @Override
                    public void caseStringConstant(StringConstant v) {
                        argsArray[j] = v.value;
                    }

                    @Override
                    public void caseNullConstant(NullConstant v) {
                        /*
							 * The Jasmin-backend throws an exception for the
							 * null-type.
							 */
                        throw new RuntimeException("Unexpected NullType as argument-type in invokedynamic!");
                    }

                    @Override
                    public void caseMethodHandle(MethodHandle handle) {
                        SootMethodRef methodRef = handle.getMethodRef();
                        argsArray[j] = new Handle(handle.tag, slashify(methodRef.declaringClass().getName()), methodRef.name(), toTypeDesc(methodRef));
                    }

                    @Override
                    public void caseLongConstant(LongConstant v) {
                        argsArray[j] = v.value;
                    }

                    @Override
                    public void caseIntConstant(IntConstant v) {
                        argsArray[j] = v.value;
                    }

                    @Override
                    public void caseFloatConstant(FloatConstant v) {
                        argsArray[j] = v.value;
                    }

                    @Override
                    public void caseDoubleConstant(DoubleConstant v) {
                        argsArray[j] = v.value;
                    }

                    @Override
                    public void caseClassConstant(ClassConstant v) {
                        argsArray[j] = org.objectweb.asm.Type.getType(v.getValue());
                    }
                });
                ++index;
            }
            mv.visitInvokeDynamicInsn(m.name(), toTypeDesc(m), new Handle(i.getHandleTag(), slashify(bsm.declaringClass().getName()), bsm.name(), toTypeDesc(bsm)), argsArray);
        }

        @Override
        public void caseStaticInvokeInst(StaticInvokeInst i) {
            SootMethodRef m = i.getMethodRef();
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, slashify(m.declaringClass().getName()), m.name(), toTypeDesc(m), m.declaringClass().isInterface() && !m.isStatic());
        }

        @Override
        public void caseVirtualInvokeInst(VirtualInvokeInst i) {
            SootMethodRef m = i.getMethodRef();
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, slashify(m.declaringClass().getName()), m.name(), toTypeDesc(m), m.declaringClass().isInterface());
        }

        @Override
        public void caseInterfaceInvokeInst(InterfaceInvokeInst i) {
            SootMethodRef m = i.getMethodRef();
            SootClass declaration = m.declaringClass();
            boolean isInterface = true;
            if (!declaration.isPhantom() && !declaration.isInterface()) {
                /*
					 * If the declaring class of a method called via
					 * invokeinterface is a phantom class we assume the
					 * declaring class to be an interface. This might not be
					 * true in general, but as of today Soot can not evaluate
					 * isInterface() for phantom classes correctly.
					 */
                isInterface = false;
            }
            mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, slashify(declaration.getName()), m.name(), toTypeDesc(m), isInterface);
        }

        @Override
        public void caseSpecialInvokeInst(SpecialInvokeInst i) {
            SootMethodRef m = i.getMethodRef();
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, slashify(m.declaringClass().getName()), m.name(), toTypeDesc(m), m.declaringClass().isInterface());
        }

        @Override
        public void caseThrowInst(ThrowInst i) {
            mv.visitInsn(Opcodes.ATHROW);
        }

        @Override
        public void caseAddInst(AddInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.IADD);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.IADD);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.IADD);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DADD);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FADD);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IADD);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LADD);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.IADD);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseAndInst(AndInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LAND);
            } else {
                mv.visitInsn(Opcodes.IAND);
            }
        }

        @Override
        public void caseOrInst(OrInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LOR);
            } else {
                mv.visitInsn(Opcodes.IOR);
            }
        }

        @Override
        public void caseXorInst(XorInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LXOR);
            } else {
                mv.visitInsn(Opcodes.IXOR);
            }
        }

        @Override
        public void caseArrayLengthInst(ArrayLengthInst i) {
            mv.visitInsn(Opcodes.ARRAYLENGTH);
        }

        @Override
        public void caseCmpInst(CmpInst i) {
            mv.visitInsn(Opcodes.LCMP);
        }

        @Override
        public void caseCmpgInst(CmpgInst i) {
            if (i.getOpType().equals(FloatType.v())) {
                mv.visitInsn(Opcodes.FCMPG);
            } else {
                mv.visitInsn(Opcodes.DCMPG);
            }
        }

        @Override
        public void caseCmplInst(CmplInst i) {
            if (i.getOpType().equals(FloatType.v())) {
                mv.visitInsn(Opcodes.FCMPL);
            } else {
                mv.visitInsn(Opcodes.DCMPL);
            }
        }

        @Override
        public void caseDivInst(DivInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.IDIV);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.IDIV);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.IDIV);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DDIV);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FDIV);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IDIV);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LDIV);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.IDIV);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseIncInst(IncInst i) {
            if (i.getUseBoxes().get(0).getValue() != i.getDefBoxes().get(0).getValue()) {
                throw new RuntimeException("iinc def and use boxes don't match");
            }
            if (i.getConstant() instanceof IntConstant) {
                mv.visitIincInsn(localToSlot.get(i.getLocal()), ((IntConstant) i.getConstant()).value);
            } else {
                throw new RuntimeException("Wrong constant type for increment!");
            }
        }

        @Override
        public void caseMulInst(MulInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.IMUL);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.IMUL);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.IMUL);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DMUL);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FMUL);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IMUL);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LMUL);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.IMUL);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseRemInst(RemInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.IREM);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.IREM);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.IREM);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DREM);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FREM);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.IREM);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LREM);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.IREM);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseSubInst(SubInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.ISUB);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.ISUB);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.ISUB);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DSUB);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FSUB);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.ISUB);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LSUB);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.ISUB);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseShlInst(ShlInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LSHL);
            } else {
                mv.visitInsn(Opcodes.ISHL);
            }
        }

        @Override
        public void caseShrInst(ShrInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LSHR);
            } else {
                mv.visitInsn(Opcodes.ISHR);
            }
        }

        @Override
        public void caseUshrInst(UshrInst i) {
            if (i.getOpType().equals(LongType.v())) {
                mv.visitInsn(Opcodes.LUSHR);
            } else {
                mv.visitInsn(Opcodes.IUSHR);
            }
        }

        @Override
        public void caseNewInst(NewInst i) {
            mv.visitTypeInsn(Opcodes.NEW, slashify(i.getBaseType().getClassName()));
        }

        @Override
        public void caseNegInst(NegInst i) {
            i.getOpType().apply(new TypeSwitch() {

                @Override
                public void caseBooleanType(BooleanType t) {
                    mv.visitInsn(Opcodes.INEG);
                }

                @Override
                public void caseByteType(ByteType t) {
                    mv.visitInsn(Opcodes.INEG);
                }

                @Override
                public void caseCharType(CharType t) {
                    mv.visitInsn(Opcodes.INEG);
                }

                @Override
                public void caseDoubleType(DoubleType t) {
                    mv.visitInsn(Opcodes.DNEG);
                }

                @Override
                public void caseFloatType(FloatType t) {
                    mv.visitInsn(Opcodes.FNEG);
                }

                @Override
                public void caseIntType(IntType t) {
                    mv.visitInsn(Opcodes.INEG);
                }

                @Override
                public void caseLongType(LongType t) {
                    mv.visitInsn(Opcodes.LNEG);
                }

                @Override
                public void caseShortType(ShortType t) {
                    mv.visitInsn(Opcodes.INEG);
                }

                @Override
                public void defaultCase(Type t) {
                    throw new RuntimeException("invalid type");
                }
            });
        }

        @Override
        public void caseSwapInst(SwapInst i) {
            mv.visitInsn(Opcodes.SWAP);
        }

        @Override
        public void caseDup1Inst(Dup1Inst i) {
            if (sizeOfType(i.getOp1Type()) == 2) {
                mv.visitInsn(Opcodes.DUP2);
            } else {
                mv.visitInsn(Opcodes.DUP);
            }
        }

        @Override
        public void caseDup2Inst(Dup2Inst i) {
            Type firstOpType = i.getOp1Type();
            Type secondOpType = i.getOp2Type();
            // Use a pair of instructions to simulate them.
            if (sizeOfType(firstOpType) == 2) {
                mv.visitInsn(Opcodes.DUP2);
                if (sizeOfType(secondOpType) == 2) {
                    mv.visitInsn(Opcodes.DUP2);
                } else {
                    mv.visitInsn(Opcodes.DUP);
                }
            } else if (sizeOfType(secondOpType) == 2) {
                mv.visitInsn(Opcodes.DUP);
                mv.visitInsn(Opcodes.DUP2);
            } else {
                mv.visitInsn(Opcodes.DUP2);
            }
        }

        @Override
        public void caseDup1_x1Inst(Dup1_x1Inst i) {
            Type opType = i.getOp1Type();
            Type underType = i.getUnder1Type();
            if (sizeOfType(opType) == 2) {
                if (sizeOfType(underType) == 2) {
                    mv.visitInsn(Opcodes.DUP2_X2);
                } else {
                    mv.visitInsn(Opcodes.DUP2_X1);
                }
            } else {
                if (sizeOfType(underType) == 2) {
                    mv.visitInsn(Opcodes.DUP_X2);
                } else {
                    mv.visitInsn(Opcodes.DUP_X1);
                }
            }
        }

        @Override
        public void caseDup1_x2Inst(Dup1_x2Inst i) {
            int toSkip = sizeOfType(i.getUnder1Type()) + sizeOfType(i.getUnder2Type());
            if (sizeOfType(i.getOp1Type()) == 2) {
                if (toSkip == 2) {
                    mv.visitInsn(Opcodes.DUP2_X2);
                } else {
                    throw new RuntimeException("magic not implemented yet");
                }
            } else {
                if (toSkip == 2) {
                    mv.visitInsn(Opcodes.DUP_X2);
                } else {
                    throw new RuntimeException("magic not implemented yet");
                }
            }
        }

        @Override
        public void caseDup2_x1Inst(Dup2_x1Inst i) {
            int toDup = sizeOfType(i.getOp1Type()) + sizeOfType(i.getOp2Type());
            if (toDup == 2) {
                if (sizeOfType(i.getUnder1Type()) == 2) {
                    mv.visitInsn(Opcodes.DUP2_X2);
                } else {
                    mv.visitInsn(Opcodes.DUP2_X1);
                }
            } else {
                throw new RuntimeException("magic not implemented yet");
            }
        }

        @Override
        public void caseDup2_x2Inst(Dup2_x2Inst i) {
            int toDup = sizeOfType(i.getOp1Type()) + sizeOfType(i.getOp2Type());
            int toSkip = sizeOfType(i.getUnder1Type()) + sizeOfType(i.getUnder2Type());
            if (toDup > 2 || toSkip > 2) {
                throw new RuntimeException("magic not implemented yet");
            }
            if (toDup == 2 && toSkip == 2) {
                mv.visitInsn(Opcodes.DUP2_X2);
            } else {
                throw new RuntimeException("VoidType not allowed in Dup2_x2 Instruction");
            }
        }

        @Override
        public void caseNewArrayInst(NewArrayInst i) {
            Type t = i.getBaseType();
            if (t instanceof RefType) {
                mv.visitTypeInsn(Opcodes.ANEWARRAY, slashify(((RefType) t).getClassName()));
            } else if (t instanceof ArrayType) {
                mv.visitTypeInsn(Opcodes.ANEWARRAY, toTypeDesc(t));
            } else {
                int type;
                if (t.equals(BooleanType.v())) {
                    type = Opcodes.T_BOOLEAN;
                } else if (t.equals(CharType.v())) {
                    type = Opcodes.T_CHAR;
                } else if (t.equals(FloatType.v())) {
                    type = Opcodes.T_FLOAT;
                } else if (t.equals(DoubleType.v())) {
                    type = Opcodes.T_DOUBLE;
                } else if (t.equals(ByteType.v())) {
                    type = Opcodes.T_BYTE;
                } else if (t.equals(ShortType.v())) {
                    type = Opcodes.T_SHORT;
                } else if (t.equals(IntType.v())) {
                    type = Opcodes.T_INT;
                } else if (t.equals(LongType.v())) {
                    type = Opcodes.T_LONG;
                } else {
                    throw new RuntimeException("invalid type");
                }
                mv.visitIntInsn(Opcodes.NEWARRAY, type);
            }
        }

        @Override
        public void caseNewMultiArrayInst(NewMultiArrayInst i) {
            mv.visitMultiANewArrayInsn(toTypeDesc(i.getBaseType()), i.getDimensionCount());
        }

        @Override
        public void caseLookupSwitchInst(LookupSwitchInst i) {
            List<IntConstant> values = i.getLookupValues();
            List<Unit> targets = i.getTargets();
            int[] keys = new int[values.size()];
            Label[] labels = new Label[values.size()];
            for (int j = 0; j < values.size(); j++) {
                keys[j] = values.get(j).value;
                labels[j] = branchTargetLabels.get(targets.get(j));
            }
            mv.visitLookupSwitchInsn(branchTargetLabels.get(i.getDefaultTarget()), keys, labels);
        }

        @Override
        public void caseTableSwitchInst(TableSwitchInst i) {
            List<Unit> targets = i.getTargets();
            Label[] labels = new Label[targets.size()];
            for (int j = 0; j < targets.size(); j++) {
                labels[j] = branchTargetLabels.get(targets.get(j));
            }
            mv.visitTableSwitchInsn(i.getLowIndex(), i.getHighIndex(), branchTargetLabels.get(i.getDefaultTarget()), labels);
        }

        @Override
        public void caseEnterMonitorInst(EnterMonitorInst i) {
            mv.visitInsn(Opcodes.MONITORENTER);
        }

        @Override
        public void caseExitMonitorInst(ExitMonitorInst i) {
            mv.visitInsn(Opcodes.MONITOREXIT);
        }
    });
}

Example 18 with IntType

use of soot.IntType in project soot by Sable.

the class CP method handleMathematical.

/*
	 * x = b where b is in the before set of the statement as a constant then we
	 * can simply say x = that constant also
	 * 
	 * TODO: DONT WANT TO DO IT:::: If right expr is a unary expression see if
	 * the stuff inside is a Local
	 * 
	 * x = exp1 op exp2 (check if both exp1 and exp2 are int constants
	 * 
	 * killedValuse is either the constant value which left had before this
	 * assignment stmt or null if left was Top or not in the set
	 * 
	 * handle the special case when the inputset could not find a value because
	 * its the killed value //eg. x = x+1 since we top x first we will never get
	 * a match IMPORTANT
	 */
private void handleMathematical(CPFlowSet toReturn, Local left, Value right, Object killedValue) {
    // if right expr is a local or field
    Object value = isANotTopConstantInInputSet(toReturn, right);
    if (value != null) {
        // right was a local or field with a value other than top
        // dont send value SEND A CLONE OF VALUE.....IMPORTANT!!!!
        Object toSend = CPHelper.wrapperClassCloner(value);
        if (toSend != null) {
            addOrUpdate(toReturn, left, toSend);
        }
        // primitive local assigned some value from the right
        return;
    }
    // we could find in the set
    if (right instanceof BinopExpr) {
        Value op1 = ((BinopExpr) right).getOp1();
        Value op2 = ((BinopExpr) right).getOp2();
        Object op1Val = CPHelper.isAConstantValue(op1);
        Object op2Val = CPHelper.isAConstantValue(op2);
        if (op1Val == null)
            op1Val = isANotTopConstantInInputSet(toReturn, op1);
        if (op2Val == null)
            op2Val = isANotTopConstantInInputSet(toReturn, op2);
        if (op1 == left) {
            // System.out.println("\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>OP1 is the same as LHS");
            op1Val = killedValue;
        }
        if (op2 == left) {
            // System.out.println("\n\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>OP2 is the same as LHS");
            op2Val = killedValue;
        }
        if (op1Val != null && op2Val != null) {
            // System.out.println("found constant values for both operands of binary expression");
            if (left.getType() instanceof IntType && op1Val instanceof Integer && op2Val instanceof Integer) {
                // only caring about operations on two integers and result
                // is an integer
                int op1IntValue = ((Integer) op1Val).intValue();
                int op2IntValue = ((Integer) op2Val).intValue();
                String tempStr = ((BinopExpr) right).getSymbol();
                if (tempStr.length() > 1) {
                    char symbol = tempStr.charAt(1);
                    // System.out.println("found symbol "+symbol+" for the operands of binary expression");
                    int newValue = 0;
                    boolean set = false;
                    switch(symbol) {
                        case '+':
                            // System.out.println("Adding");
                            newValue = op1IntValue + op2IntValue;
                            set = true;
                            break;
                        case '-':
                            // System.out.println("Subtracting");
                            newValue = op1IntValue - op2IntValue;
                            set = true;
                            break;
                        case '*':
                            // System.out.println("Multiplying");
                            newValue = op1IntValue * op2IntValue;
                            set = true;
                            break;
                    }
                    if (set) {
                        // we have our new value
                        Integer newValueObject = new Integer(newValue);
                        addOrUpdate(toReturn, left, newValueObject);
                        return;
                    }
                }
            }
        } else {
        // System.out.println("atleast one value is not constant so cant simplify expression");
        }
    }
// System.out.println("DefinitionStmt checked right expr for mathematical stuff"+toReturn.toString());
}

Example 19 with IntType

use of soot.IntType in project soot by Sable.

the class Util method emptyBody.

/**
 * Remove all statements except from IdentityStatements for parameters.
 * Return default value (null or zero or nothing depending on the return
 * type).
 *
 * @param jBody
 */
public static void emptyBody(Body jBody) {
    // identity statements
    List<Unit> idStmts = new ArrayList<Unit>();
    List<Local> idLocals = new ArrayList<Local>();
    for (Unit u : jBody.getUnits()) {
        if (u instanceof IdentityStmt) {
            IdentityStmt i = (IdentityStmt) u;
            if (i.getRightOp() instanceof ParameterRef || i.getRightOp() instanceof ThisRef) {
                idStmts.add(u);
                idLocals.add((Local) i.getLeftOp());
            }
        }
    }
    jBody.getUnits().clear();
    jBody.getLocals().clear();
    jBody.getTraps().clear();
    final LocalGenerator lg = new LocalGenerator(jBody);
    for (Unit u : idStmts) jBody.getUnits().add(u);
    for (Local l : idLocals) jBody.getLocals().add(l);
    Type rType = jBody.getMethod().getReturnType();
    jBody.getUnits().add(Jimple.v().newNopStmt());
    if (rType instanceof VoidType) {
        jBody.getUnits().add(Jimple.v().newReturnVoidStmt());
    } else {
        Type t = jBody.getMethod().getReturnType();
        Local l = lg.generateLocal(t);
        AssignStmt ass = null;
        if (t instanceof RefType || t instanceof ArrayType) {
            ass = Jimple.v().newAssignStmt(l, NullConstant.v());
        } else if (t instanceof LongType) {
            ass = Jimple.v().newAssignStmt(l, LongConstant.v(0));
        } else if (t instanceof FloatType) {
            ass = Jimple.v().newAssignStmt(l, FloatConstant.v(0.0f));
        } else if (t instanceof IntType) {
            ass = Jimple.v().newAssignStmt(l, IntConstant.v(0));
        } else if (t instanceof DoubleType) {
            ass = Jimple.v().newAssignStmt(l, DoubleConstant.v(0));
        } else if (t instanceof BooleanType || t instanceof ByteType || t instanceof CharType || t instanceof ShortType) {
            ass = Jimple.v().newAssignStmt(l, IntConstant.v(0));
        } else {
            throw new RuntimeException("error: return type unknown: " + t + " class: " + t.getClass());
        }
        jBody.getUnits().add(ass);
        jBody.getUnits().add(Jimple.v().newReturnStmt(l));
    }
}

Example 20 with IntType

use of soot.IntType in project soot by Sable.

the class ShortcutIfGenerator method inASTStatementSequenceNode.

public void inASTStatementSequenceNode(ASTStatementSequenceNode node) {
    for (AugmentedStmt as : node.getStatements()) {
        Stmt s = as.get_Stmt();
        if (!(s instanceof DefinitionStmt))
            continue;
        DefinitionStmt ds = (DefinitionStmt) s;
        ValueBox rightBox = ds.getRightOpBox();
        Value right = rightBox.getValue();
        /*
			 * Going to match int i = (int) z where z is a boolean
			 * or int i= z i.e. without the cast
			 */
        // right type should contain the expected type on the left
        // in the case of the cast this is the cast type else just get the left type
        Type rightType = null;
        ValueBox OpBox = null;
        if (right instanceof CastExpr) {
            rightType = ((CastExpr) right).getCastType();
            OpBox = ((CastExpr) right).getOpBox();
        } else {
            rightType = ds.getLeftOp().getType();
            OpBox = rightBox;
        }
        if (!(rightType instanceof IntType)) {
            continue;
        }
        Value Op = OpBox.getValue();
        if (!(Op.getType() instanceof BooleanType)) {
            continue;
        }
        // ready for the switch
        ImmediateBox trueBox = new ImmediateBox(IntConstant.v(1));
        ImmediateBox falseBox = new ImmediateBox(IntConstant.v(0));
        DShortcutIf shortcut = new DShortcutIf(OpBox, trueBox, falseBox);
        if (DEBUG)
            System.out.println("created: " + shortcut);
        rightBox.setValue(shortcut);
    }
}