List of usage examples for org.objectweb.asm Opcodes L2D
int L2D
To view the source code for org.objectweb.asm Opcodes L2D.
Click Source Link
From source file:org.jboss.byteman.agent.adapter.RuleGeneratorAdapter.java
License:Open Source License
/** * Generates the instructions to cast a numerical value from one type to * another.// w ww. j a v a2 s .c om * * @param from the type of the top stack value * @param to the type into which this value must be cast. */ public void cast(final Type from, final Type to) { if (from != to) { if (from == Type.DOUBLE_TYPE) { if (to == Type.FLOAT_TYPE) { visitInsn(Opcodes.D2F); } else if (to == Type.LONG_TYPE) { visitInsn(Opcodes.D2L); } else { visitInsn(Opcodes.D2I); cast(Type.INT_TYPE, to); } } else if (from == Type.FLOAT_TYPE) { if (to == Type.DOUBLE_TYPE) { visitInsn(Opcodes.F2D); } else if (to == Type.LONG_TYPE) { visitInsn(Opcodes.F2L); } else { visitInsn(Opcodes.F2I); cast(Type.INT_TYPE, to); } } else if (from == Type.LONG_TYPE) { if (to == Type.DOUBLE_TYPE) { visitInsn(Opcodes.L2D); } else if (to == Type.FLOAT_TYPE) { visitInsn(Opcodes.L2F); } else { visitInsn(Opcodes.L2I); cast(Type.INT_TYPE, to); } } else { if (to == Type.BYTE_TYPE) { visitInsn(Opcodes.I2B); } else if (to == Type.CHAR_TYPE) { visitInsn(Opcodes.I2C); } else if (to == Type.DOUBLE_TYPE) { visitInsn(Opcodes.I2D); } else if (to == Type.FLOAT_TYPE) { visitInsn(Opcodes.I2F); } else if (to == Type.LONG_TYPE) { visitInsn(Opcodes.I2L); } else if (to == Type.SHORT_TYPE) { visitInsn(Opcodes.I2S); } } } }
From source file:org.jboss.byteman.rule.RuleElement.java
License:Open Source License
/** * compile code to convert a numeric or character primitive to a numeric or character primitive * @param fromType//ww w . ja va2s . c om * @param toType * @param mv * @param compileContext * @throws CompileException */ protected void compilePrimitiveConversion(Type fromType, Type toType, MethodVisitor mv, CompileContext compileContext) throws CompileException { if (fromType == Type.B || fromType == Type.S || fromType == Type.I) { if (toType == Type.B) { mv.visitInsn(Opcodes.I2B); } else if (toType == Type.S) { mv.visitInsn(Opcodes.I2S); } else if (toType == Type.C) { mv.visitInsn(Opcodes.I2C); } else if (toType == Type.I) { // nothing to do } else if (toType == Type.J) { mv.visitInsn(Opcodes.I2L); compileContext.addStackCount(1); } else if (toType == Type.F) { mv.visitInsn(Opcodes.I2F); } else if (toType == Type.D) { mv.visitInsn(Opcodes.I2D); compileContext.addStackCount(1); } } else if (fromType == Type.C) { // convert to the relevant numeric size if (toType == Type.B) { mv.visitInsn(Opcodes.I2B); } else if (toType == Type.S) { mv.visitInsn(Opcodes.I2S); } else if (toType == Type.C) { // nothing to do } else if (toType == Type.I) { // nothing to do } else if (toType == Type.J) { mv.visitInsn(Opcodes.I2L); compileContext.addStackCount(1); } else if (toType == Type.F) { mv.visitInsn(Opcodes.I2F); } else if (toType == Type.D) { mv.visitInsn(Opcodes.I2D); compileContext.addStackCount(1); } } else if (fromType == Type.J) { if (toType == Type.B || toType == Type.S || toType == Type.I || toType == Type.C) { mv.visitInsn(Opcodes.L2I); compileContext.addStackCount(-1); } else if (toType == Type.J) { // nothing to do } else if (toType == Type.F) { mv.visitInsn(Opcodes.L2F); compileContext.addStackCount(-1); } else if (toType == Type.D) { mv.visitInsn(Opcodes.L2D); } } else if (fromType == Type.F) { if (toType == Type.B) { mv.visitInsn(Opcodes.F2I); mv.visitInsn(Opcodes.I2B); } else if (toType == Type.S) { mv.visitInsn(Opcodes.F2I); mv.visitInsn(Opcodes.I2S); } else if (toType == Type.C) { mv.visitInsn(Opcodes.F2I); mv.visitInsn(Opcodes.I2C); } else if (toType == Type.I) { mv.visitInsn(Opcodes.F2I); } else if (toType == Type.J) { mv.visitInsn(Opcodes.F2L); compileContext.addStackCount(1); } else if (toType == Type.F) { // nothing to do } else if (toType == Type.D) { mv.visitInsn(Opcodes.F2D); compileContext.addStackCount(1); } } else if (fromType == Type.D) { if (toType == Type.B) { mv.visitInsn(Opcodes.D2I); mv.visitInsn(Opcodes.I2B); compileContext.addStackCount(-1); } else if (toType == Type.S) { mv.visitInsn(Opcodes.D2I); mv.visitInsn(Opcodes.I2S); compileContext.addStackCount(-1); } else if (toType == Type.C) { mv.visitInsn(Opcodes.D2I); mv.visitInsn(Opcodes.I2C); compileContext.addStackCount(-1); } else if (toType == Type.I) { mv.visitInsn(Opcodes.D2I); compileContext.addStackCount(-1); } else if (toType == Type.J) { mv.visitInsn(Opcodes.D2L); } else if (toType == Type.F) { mv.visitInsn(Opcodes.D2F); compileContext.addStackCount(-1); } else if (toType == Type.D) { // nothing to do } } }
From source file:org.openquark.cal.internal.javamodel.AsmJavaBytecodeGenerator.java
License:Open Source License
/** * Create the Java code for a given cast expression. This will cause the resulting casted object reference to * be pushed onto the operand stack./*w w w . jav a 2s . c om*/ * * @param castExpression the cast expression * @param context * @return JavaTypeName the type of the result on the operand stack. * @throws JavaGenerationException */ private static JavaTypeName encodeCastExpr(JavaExpression.CastExpression castExpression, GenerationContext context) throws JavaGenerationException { MethodVisitor mv = context.getMethodVisitor(); final JavaTypeName expressionToCastType = encodeExpr(castExpression.getExpressionToCast(), context); final JavaTypeName castType = castExpression.getCastType(); if (expressionToCastType.equals(castType)) { //no operation needed if the types are the same. return castType; } if (castType instanceof JavaTypeName.Reference) { //when the cast type is a object or array type, use the CHECKCAST instruction. This will fail bytecode verification if //the expressionToCast type is a primitive type mv.visitTypeInsn(Opcodes.CHECKCAST, castType.getJVMInternalName()); return castType; } //casting between primitive types. //There are 15 supported primitive conversions: I2L, I2F, I2D, L2I, L2F, L2D, F2I, F2L, F2D, D2I, D2L, D2F, I2B, I2C, I2S //Depending upon the expressionToCastType and castType, choose the appropriate instruction. final int conversionOpCode; switch (expressionToCastType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.SHORT_TAG: conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: //no-op return castType; case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.I2L; break; case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.I2D; break; case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.I2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.SHORT_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.CHAR_TAG: conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: //no-op return castType; case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.I2L; break; case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.I2D; break; case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.I2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.CHAR_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.INT_TAG: //no-op return castType; case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.I2L; break; case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.I2D; break; case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.I2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.INT_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.I2L; break; case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.I2D; break; case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.I2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.LONG_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: mv.visitInsn(Opcodes.L2I); conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: mv.visitInsn(Opcodes.L2I); conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: mv.visitInsn(Opcodes.L2I); conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: conversionOpCode = Opcodes.L2I; break; case JavaTypeName.LONG_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.L2D; break; case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.L2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.DOUBLE_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: mv.visitInsn(Opcodes.D2I); conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: mv.visitInsn(Opcodes.D2I); conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: mv.visitInsn(Opcodes.D2I); conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: conversionOpCode = Opcodes.D2I; break; case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.D2L; break; case JavaTypeName.DOUBLE_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.FLOAT_TAG: conversionOpCode = Opcodes.D2F; break; case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.FLOAT_TAG: { switch (castType.getTag()) { case JavaTypeName.VOID_TAG: case JavaTypeName.BOOLEAN_TAG: throw new JavaGenerationException("Unsupported primitive cast."); case JavaTypeName.BYTE_TAG: mv.visitInsn(Opcodes.F2I); conversionOpCode = Opcodes.I2B; break; case JavaTypeName.SHORT_TAG: mv.visitInsn(Opcodes.F2I); conversionOpCode = Opcodes.I2S; break; case JavaTypeName.CHAR_TAG: mv.visitInsn(Opcodes.F2I); conversionOpCode = Opcodes.I2C; break; case JavaTypeName.INT_TAG: conversionOpCode = Opcodes.F2I; break; case JavaTypeName.LONG_TAG: conversionOpCode = Opcodes.F2L; break; case JavaTypeName.DOUBLE_TAG: conversionOpCode = Opcodes.F2D; break; case JavaTypeName.FLOAT_TAG: //should be handled above as a no-op. throw new IllegalArgumentException(); case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a primitive type to a reference type."); default: { throw new IllegalArgumentException(); } } break; } case JavaTypeName.ARRAY_TAG: case JavaTypeName.OBJECT_TAG: throw new JavaGenerationException("Cannot cast a reference type to a primitive type."); default: { throw new IllegalArgumentException(); } } mv.visitInsn(conversionOpCode); return castType; }
From source file:org.openquark.cal.internal.javamodel.AsmJavaBytecodeGenerator.java
License:Open Source License
/** * Gets the op-code to widen a value of a given type to a value of another type. * @param typeToWiden the type to widen. * @param valueType the type to which the typeToWiden should be widened. * @return int the widening op code, as defined in org.objectweb.asm.Opcodes. Opcodes.NOP us used for the no-op. *//*from ww w.j ava 2s .c o m*/ private static int getWideningOpCode(JavaTypeName typeToWiden, JavaTypeName valueType) { if (typeToWiden.equals(valueType)) { return Opcodes.NOP; } // Widen from int-type values -> float, long, double if (isInternalIntType(typeToWiden)) { switch (valueType.getTag()) { case JavaTypeName.BYTE_TAG: case JavaTypeName.SHORT_TAG: case JavaTypeName.CHAR_TAG: case JavaTypeName.INT_TAG: return Opcodes.NOP; case JavaTypeName.LONG_TAG: return Opcodes.I2L; case JavaTypeName.DOUBLE_TAG: return Opcodes.I2D; case JavaTypeName.FLOAT_TAG: return Opcodes.I2F; default: throw new IllegalArgumentException("Invalid widening conversion."); } // Widen from long -> float, double } else if (typeToWiden.equals(JavaTypeName.LONG)) { switch (valueType.getTag()) { case JavaTypeName.DOUBLE_TAG: return Opcodes.L2D; case JavaTypeName.FLOAT_TAG: return Opcodes.L2F; default: throw new IllegalArgumentException("Invalid widening conversion."); } // Widen from float -> double } else if (typeToWiden.equals(JavaTypeName.FLOAT)) { if (valueType.equals(JavaTypeName.DOUBLE)) { return Opcodes.F2D; } throw new IllegalArgumentException("Invalid widening conversion."); } //throw new IllegalArgumentException("Invalid widening conversion."); return Opcodes.NOP; }
From source file:org.spongepowered.despector.emitter.bytecode.instruction.BytecodeCastEmitter.java
License:Open Source License
@Override public void emit(BytecodeEmitterContext ctx, Cast arg, TypeSignature type) { MethodVisitor mv = ctx.getMethodVisitor(); ctx.emitInstruction(arg.getValue(), null); TypeSignature to = arg.getType();/*from ww w . jav a 2s . c o m*/ TypeSignature from = arg.getValue().inferType(); if (to == ClassTypeSignature.INT) { if (from == ClassTypeSignature.LONG) { mv.visitInsn(Opcodes.L2I); } else if (from == ClassTypeSignature.FLOAT) { mv.visitInsn(Opcodes.F2I); } else if (from == ClassTypeSignature.DOUBLE) { mv.visitInsn(Opcodes.D2I); } } else if (to == ClassTypeSignature.LONG) { if (from == ClassTypeSignature.INT) { mv.visitInsn(Opcodes.I2L); } else if (from == ClassTypeSignature.FLOAT) { mv.visitInsn(Opcodes.F2L); } else if (from == ClassTypeSignature.DOUBLE) { mv.visitInsn(Opcodes.D2L); } } else if (to == ClassTypeSignature.FLOAT) { if (from == ClassTypeSignature.LONG) { mv.visitInsn(Opcodes.L2F); } else if (from == ClassTypeSignature.INT) { mv.visitInsn(Opcodes.I2F); } else if (from == ClassTypeSignature.DOUBLE) { mv.visitInsn(Opcodes.D2F); } } else if (to == ClassTypeSignature.DOUBLE) { if (from == ClassTypeSignature.LONG) { mv.visitInsn(Opcodes.L2D); } else if (from == ClassTypeSignature.FLOAT) { mv.visitInsn(Opcodes.F2D); } else if (from == ClassTypeSignature.INT) { mv.visitInsn(Opcodes.I2D); } } mv.visitTypeInsn(Opcodes.CHECKCAST, to.getDescriptor()); }
From source file:serianalyzer.JVMImpl.java
License:Open Source License
/** * @param opcode/*from w w w .j a v a 2s . c o m*/ * @param s */ static void handleJVMInsn(int opcode, JVMStackState s) { BaseType o1; BaseType o2; BaseType o3; List<BaseType> l1; List<BaseType> l2; switch (opcode) { case Opcodes.NOP: break; case Opcodes.ARRAYLENGTH: o1 = s.pop(); s.push(new BasicConstant(Type.INT_TYPE, 0, !(o1 != null && !o1.isTainted()))); break; case Opcodes.ACONST_NULL: s.push(new BasicConstant(Type.VOID_TYPE, "<null>")); //$NON-NLS-1$ break; case Opcodes.ICONST_M1: case Opcodes.ICONST_0: case Opcodes.ICONST_1: case Opcodes.ICONST_2: case Opcodes.ICONST_3: case Opcodes.ICONST_4: case Opcodes.ICONST_5: s.push(new BasicConstant(Type.INT_TYPE, opcode - 3)); break; case Opcodes.LCONST_0: case Opcodes.LCONST_1: s.push(new BasicConstant(Type.LONG_TYPE, opcode - 9L)); break; case Opcodes.FCONST_0: case Opcodes.FCONST_1: case Opcodes.FCONST_2: s.push(new BasicConstant(Type.FLOAT_TYPE, opcode - 11f)); break; case Opcodes.DCONST_0: case Opcodes.DCONST_1: s.push(new BasicConstant(Type.DOUBLE_TYPE, opcode - 14d)); break; case Opcodes.IALOAD: case Opcodes.LALOAD: case Opcodes.FALOAD: case Opcodes.DALOAD: case Opcodes.BALOAD: case Opcodes.CALOAD: case Opcodes.SALOAD: o1 = s.pop(); o2 = s.pop(); s.push(new BasicVariable(toType(opcode), "primitive array elem", //$NON-NLS-1$ (o1 == null || o1.isTainted()) | (o2 == null || o2.isTainted()))); break; case Opcodes.AALOAD: o1 = s.pop(); o2 = s.pop(); if (o1 != null && o2 instanceof SimpleType && ((SimpleType) o2).getType().toString().startsWith("[")) { //$NON-NLS-1$ Type atype = Type.getType(((SimpleType) o2).getType().toString().substring(1)); if (o2.getAlternativeTypes() != null && !o2.getAlternativeTypes().isEmpty()) { s.clear(); break; } s.push(new BasicVariable(atype, "array elem " + atype, o1.isTainted() | o2.isTainted())); //$NON-NLS-1$ } else { s.clear(); } break; case Opcodes.IASTORE: case Opcodes.LASTORE: case Opcodes.FASTORE: case Opcodes.DASTORE: case Opcodes.AASTORE: case Opcodes.BASTORE: case Opcodes.CASTORE: case Opcodes.SASTORE: s.pop(3); break; case Opcodes.POP2: s.pop(); case Opcodes.MONITORENTER: case Opcodes.MONITOREXIT: case Opcodes.POP: s.pop(); break; case Opcodes.DUP: if (!s.isEmpty()) { o1 = s.pop(); s.push(o1); s.push(o1); } break; case Opcodes.DUP_X1: o1 = s.pop(); o2 = s.pop(); s.push(o1); s.push(o2); s.push(o1); break; case Opcodes.DUP_X2: o1 = s.pop(); o2 = s.pop(); o3 = s.pop(); s.push(o1); s.push(o3); s.push(o2); s.push(o1); break; case Opcodes.DUP2: l1 = s.popWord(); if (l1.isEmpty()) { log.trace("DUP2 with unknown operand"); //$NON-NLS-1$ s.clear(); } else { s.pushWord(l1); s.pushWord(l1); } break; case Opcodes.DUP2_X1: l1 = s.popWord(); o1 = s.pop(); if (l1.isEmpty()) { log.trace("DUP2 with unknown operand"); //$NON-NLS-1$ s.clear(); } else { s.pushWord(l1); s.push(o1); s.pushWord(l1); } break; case Opcodes.DUP2_X2: l1 = s.popWord(); l2 = s.popWord(); if (l1.isEmpty() || l2.isEmpty()) { log.trace("DUP2 with unknown operand"); //$NON-NLS-1$ s.clear(); } else { s.pushWord(l1); s.pushWord(l2); s.pushWord(l1); } break; case Opcodes.SWAP: o1 = s.pop(); o2 = s.pop(); s.push(o1); s.push(o2); break; case Opcodes.IADD: case Opcodes.LADD: case Opcodes.FADD: case Opcodes.DADD: case Opcodes.ISUB: case Opcodes.LSUB: case Opcodes.FSUB: case Opcodes.DSUB: case Opcodes.IMUL: case Opcodes.LMUL: case Opcodes.FMUL: case Opcodes.DMUL: case Opcodes.IDIV: case Opcodes.LDIV: case Opcodes.FDIV: case Opcodes.DDIV: case Opcodes.IREM: case Opcodes.LREM: case Opcodes.FREM: case Opcodes.DREM: case Opcodes.IAND: case Opcodes.LAND: case Opcodes.IOR: case Opcodes.LOR: case Opcodes.IXOR: case Opcodes.LXOR: case Opcodes.LCMP: case Opcodes.FCMPL: case Opcodes.FCMPG: case Opcodes.DCMPL: case Opcodes.DCMPG: s.merge(2); break; case Opcodes.ISHL: case Opcodes.LSHL: case Opcodes.ISHR: case Opcodes.LSHR: case Opcodes.IUSHR: case Opcodes.LUSHR: s.pop(); // amount // ignore value break; case Opcodes.INEG: case Opcodes.F2I: case Opcodes.D2I: case Opcodes.L2I: s.push(cast(s.pop(), Type.INT_TYPE)); break; case Opcodes.LNEG: case Opcodes.I2L: case Opcodes.F2L: case Opcodes.D2L: s.push(cast(s.pop(), Type.LONG_TYPE)); break; case Opcodes.FNEG: case Opcodes.I2F: case Opcodes.L2F: case Opcodes.D2F: s.push(cast(s.pop(), Type.FLOAT_TYPE)); case Opcodes.DNEG: case Opcodes.I2D: case Opcodes.L2D: case Opcodes.F2D: s.push(cast(s.pop(), Type.DOUBLE_TYPE)); case Opcodes.I2B: s.push(cast(s.pop(), Type.BYTE_TYPE)); break; case Opcodes.I2C: s.push(cast(s.pop(), Type.CHAR_TYPE)); break; case Opcodes.I2S: s.push(cast(s.pop(), Type.SHORT_TYPE)); break; case Opcodes.ARETURN: s.clear(); break; case Opcodes.IRETURN: case Opcodes.LRETURN: case Opcodes.FRETURN: case Opcodes.DRETURN: case Opcodes.RETURN: if (log.isTraceEnabled()) { log.trace("Found return " + s.pop()); //$NON-NLS-1$ } s.clear(); break; case Opcodes.ATHROW: Object thrw = s.pop(); log.trace("Found throw " + thrw); //$NON-NLS-1$ s.clear(); break; default: log.warn("Unsupported instruction code " + opcode); //$NON-NLS-1$ } }
From source file:v6.java.preverifier.PreverifierMethodNode.java
License:Open Source License
/** * Return a boolean indicating whether the specified opcode is * a floating point Opcodes./* w ww. ja v a 2 s . c o m*/ * * @param opcode * @return */ private boolean isFloatingPointOpcode(int opcode) { boolean isFloatingPointOpcode = false; switch (opcode) { case Opcodes.FCONST_0: case Opcodes.FCONST_1: case Opcodes.FCONST_2: case Opcodes.DCONST_0: case Opcodes.DCONST_1: case Opcodes.FLOAD: case Opcodes.DLOAD: case Opcodes.FSTORE: case Opcodes.DSTORE: case Opcodes.FALOAD: case Opcodes.DALOAD: case Opcodes.FASTORE: case Opcodes.DASTORE: case Opcodes.FADD: case Opcodes.DADD: case Opcodes.FSUB: case Opcodes.DSUB: case Opcodes.FMUL: case Opcodes.DMUL: case Opcodes.FDIV: case Opcodes.DDIV: case Opcodes.FREM: case Opcodes.DREM: case Opcodes.FNEG: case Opcodes.DNEG: case Opcodes.FCMPG: case Opcodes.FCMPL: case Opcodes.DCMPG: case Opcodes.DCMPL: case Opcodes.I2F: case Opcodes.F2I: case Opcodes.I2D: case Opcodes.D2I: case Opcodes.L2F: case Opcodes.L2D: case Opcodes.F2L: case Opcodes.D2L: case Opcodes.F2D: case Opcodes.D2F: case Opcodes.FRETURN: case Opcodes.DRETURN: isFloatingPointOpcode = true; break; } return isFloatingPointOpcode; }