List of usage examples for org.objectweb.asm Opcodes CHECKCAST
int CHECKCAST
To view the source code for org.objectweb.asm Opcodes CHECKCAST.
Click Source Link
From source file:org.evosuite.graphs.cfg.BytecodeInstructionPool.java
License:Open Source License
/** * Determine how many bytes the current instruction occupies together with * its operands/*w ww . j av a 2s . co m*/ * * @return */ private int getBytecodeIncrement(AbstractInsnNode instructionNode) { int opcode = instructionNode.getOpcode(); switch (opcode) { case Opcodes.ALOAD: // index case Opcodes.ASTORE: // index case Opcodes.DLOAD: case Opcodes.DSTORE: case Opcodes.FLOAD: case Opcodes.FSTORE: case Opcodes.ILOAD: case Opcodes.ISTORE: case Opcodes.LLOAD: case Opcodes.LSTORE: VarInsnNode varNode = (VarInsnNode) instructionNode; if (varNode.var > 3) return 1; else return 0; case Opcodes.BIPUSH: // byte case Opcodes.NEWARRAY: case Opcodes.RET: return 1; case Opcodes.LDC: LdcInsnNode ldcNode = (LdcInsnNode) instructionNode; if (ldcNode.cst instanceof Double || ldcNode.cst instanceof Long) return 2; // LDC2_W else return 1; case 19: //LDC_W case 20: //LDC2_W return 2; case Opcodes.ANEWARRAY: // indexbyte1, indexbyte2 case Opcodes.CHECKCAST: // indexbyte1, indexbyte2 case Opcodes.GETFIELD: case Opcodes.GETSTATIC: case Opcodes.GOTO: case Opcodes.IF_ACMPEQ: case Opcodes.IF_ACMPNE: case Opcodes.IF_ICMPEQ: case Opcodes.IF_ICMPNE: case Opcodes.IF_ICMPGE: case Opcodes.IF_ICMPGT: case Opcodes.IF_ICMPLE: case Opcodes.IF_ICMPLT: case Opcodes.IFLE: case Opcodes.IFLT: case Opcodes.IFGE: case Opcodes.IFGT: case Opcodes.IFNE: case Opcodes.IFEQ: case Opcodes.IFNONNULL: case Opcodes.IFNULL: case Opcodes.IINC: case Opcodes.INSTANCEOF: case Opcodes.INVOKESPECIAL: case Opcodes.INVOKESTATIC: case Opcodes.INVOKEVIRTUAL: case Opcodes.JSR: case Opcodes.NEW: case Opcodes.PUTFIELD: case Opcodes.PUTSTATIC: case Opcodes.SIPUSH: // case Opcodes.LDC_W // case Opcodes.LDC2_W return 2; case Opcodes.MULTIANEWARRAY: return 3; case Opcodes.INVOKEDYNAMIC: case Opcodes.INVOKEINTERFACE: return 4; case Opcodes.LOOKUPSWITCH: case Opcodes.TABLESWITCH: // TODO: Could be more return 4; // case Opcodes.GOTO_W // case Opcodes.JSR_W } return 0; }
From source file:org.evosuite.instrumentation.error.CastErrorInstrumentation.java
License:Open Source License
@Override public void visitTypeInsn(int opcode, String type) { if (opcode == Opcodes.CHECKCAST) { Label origTarget = new Label(); // Label origTarget = new AnnotatedLabel(); // origTarget.info = Boolean.FALSE; mv.visitInsn(Opcodes.DUP);//from ww w . java2 s . com mv.tagBranch(); mv.visitJumpInsn(Opcodes.IFNULL, origTarget); mv.visitInsn(Opcodes.DUP); mv.visitTypeInsn(Opcodes.INSTANCEOF, type); mv.tagBranch(); mv.visitJumpInsn(Opcodes.IFNE, origTarget); mv.visitTypeInsn(Opcodes.NEW, "java/lang/ClassCastException"); mv.visitInsn(Opcodes.DUP); mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/ClassCastException", "<init>", "()V", false); mv.visitInsn(Opcodes.ATHROW); mv.visitLabel(origTarget); mv.tagBranchExit(); } }
From source file:org.evosuite.instrumentation.testability.transformer.BooleanArrayIndexTransformer.java
License:Open Source License
@Override protected AbstractInsnNode transformTypeInsnNode(MethodNode mn, TypeInsnNode typeNode) { if (frames == null) return typeNode; if (typeNode.getOpcode() == Opcodes.CHECKCAST) { Frame current = frames[mn.instructions.indexOf(typeNode)]; int size = current.getStackSize(); if (current.getStack(size - 1) == BooleanArrayInterpreter.INT_ARRAY) { BooleanTestabilityTransformation.logger.info("Array is of boolean type, changing CHECKCAST to [I"); TypeInsnNode replacement = new TypeInsnNode(Opcodes.CHECKCAST, "[I"); mn.instructions.insertBefore(typeNode, replacement); mn.instructions.remove(typeNode); return replacement; }//ww w . j a v a2 s . c om } return typeNode; }
From source file:org.evosuite.instrumentation.testability.transformer.BooleanCallsTransformer.java
License:Open Source License
@Override protected AbstractInsnNode transformMethodInsnNode(MethodNode mn, MethodInsnNode methodNode) { if (methodNode.owner.equals(Type.getInternalName(BooleanHelper.class))) return methodNode; methodNode.desc = this.booleanTestabilityTransformation.transformMethodDescriptor(methodNode.owner, methodNode.name, methodNode.desc); methodNode.name = DescriptorMapping.getInstance().getMethodName(methodNode.owner, methodNode.name, methodNode.desc);//from ww w . j a v a 2 s. c om if (DescriptorMapping.getInstance().isBooleanMethod(methodNode.desc)) { BooleanTestabilityTransformation.logger.info("Method needs value transformation: " + methodNode.name); if (DescriptorMapping.getInstance().hasBooleanParameters(methodNode.desc)) { BooleanTestabilityTransformation.logger .info("Method needs parameter transformation: " + methodNode.name); TransformationStatistics.transformBackToBooleanParameter(); int firstBooleanParameterIndex = -1; Type[] types = Type.getArgumentTypes(methodNode.desc); for (int i = 0; i < types.length; i++) { if (types[i].getDescriptor().equals("Z")) { if (firstBooleanParameterIndex == -1) { firstBooleanParameterIndex = i; break; } } } if (firstBooleanParameterIndex != -1) { int numOfPushs = types.length - 1 - firstBooleanParameterIndex; // int numOfPushs = types.length - firstBooleanParameterIndex; if (numOfPushs == 0) { if (!(methodNode.getPrevious().getOpcode() == Opcodes.ICONST_1 || methodNode.getPrevious().getOpcode() == Opcodes.ICONST_0)) { //the boolean parameter is the last parameter MethodInsnNode booleanHelperInvoke = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "intToBoolean", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] { Type.INT_TYPE })); mn.instructions.insertBefore(methodNode, booleanHelperInvoke); } } else { InsnList insnlist = new InsnList(); for (int i = 0; i < numOfPushs; i++) { MethodInsnNode booleanHelperPushParameter; if (types[types.length - 1 - i] == Type.BOOLEAN_TYPE || types[types.length - 1 - i] == Type.CHAR_TYPE || types[types.length - 1 - i] == Type.BYTE_TYPE || types[types.length - 1 - i] == Type.SHORT_TYPE || types[types.length - 1 - i] == Type.INT_TYPE || types[types.length - 1 - i] == Type.FLOAT_TYPE || types[types.length - 1 - i] == Type.LONG_TYPE || types[types.length - 1 - i] == Type.DOUBLE_TYPE) { if (types[types.length - 1 - i] == Type.BOOLEAN_TYPE) { booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE })); } else { booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { types[types.length - 1 - i] })); } } else { booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.getType(Object.class) })); } insnlist.add(booleanHelperPushParameter); } for (int i = firstBooleanParameterIndex; i < types.length; i++) { if (i == firstBooleanParameterIndex) { MethodInsnNode booleanHelperInvoke = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "intToBoolean", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] { Type.INT_TYPE })); insnlist.add(booleanHelperInvoke); } else { MethodInsnNode booleanHelperPopParameter; boolean objectNeedCast = false; if (types[i] == Type.BOOLEAN_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterBooleanFromInt", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.CHAR_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterChar", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.BYTE_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterByte", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.SHORT_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterShort", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.INT_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterInt", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.FLOAT_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterFloat", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.LONG_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterLong", Type.getMethodDescriptor(types[i], new Type[] {})); } else if (types[i] == Type.DOUBLE_TYPE) { booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterDouble", Type.getMethodDescriptor(types[i], new Type[] {})); } else { objectNeedCast = true; booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "popParameterObject", Type.getMethodDescriptor(Type.getType(Object.class), new Type[] {})); } insnlist.add(booleanHelperPopParameter); if (objectNeedCast) { TypeInsnNode tin = new TypeInsnNode(Opcodes.CHECKCAST, types[i].getInternalName()); insnlist.add(tin); } } } mn.instructions.insertBefore(methodNode, insnlist); } } } if (Type.getReturnType(methodNode.desc).equals(Type.BOOLEAN_TYPE)) { BooleanTestabilityTransformation.logger .info("Method needs return transformation: " + methodNode.name); TransformationStatistics.transformBackToBooleanParameter(); MethodInsnNode n = new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class), "booleanToInt", Type.getMethodDescriptor(Type.INT_TYPE, new Type[] { Type.BOOLEAN_TYPE })); mn.instructions.insert(methodNode, n); return n; } } else { BooleanTestabilityTransformation.logger.info("Method needs no transformation: " + methodNode.name); } // TODO: If this is a method that is not transformed, and it requires a Boolean parameter // then we need to convert this boolean back to an int // For example, we could use flow analysis to determine the point where the value is added to the stack // and insert a conversion function there return methodNode; }
From source file:org.evosuite.runtime.instrumentation.MethodCallReplacement.java
License:Open Source License
public void insertInvokeSpecialForMockedSuperclass(MethodCallReplacementMethodAdapter mv) { int numArguments = Type.getArgumentTypes(replacementDesc).length; mv.push(numArguments);//from www. j a v a2s. c om mv.newArray(Type.getType(Object.class)); for (int i = 0; i < numArguments; i++) { // param, array mv.dupX1(); // array, param, array mv.swap(); // array, array, param mv.push(numArguments - i - 1); // array, array, param, index mv.swap(); // array, array, index, param mv.arrayStore(Type.getType(Object.class)); // array } mv.push(methodName); mv.push(desc); Method invokeSpecialMethod = InvokeSpecialMock.class.getDeclaredMethods()[0]; mv.visitMethodInsn(Opcodes.INVOKESTATIC, InvokeSpecialMock.class.getCanonicalName().replace('.', '/'), "invokeSpecial", Type.getMethodDescriptor(invokeSpecialMethod), false); if (Type.getReturnType(desc).equals(Type.VOID_TYPE)) { mv.pop(); } else { mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getReturnType(desc).getInternalName()); } }
From source file:org.evosuite.seeding.CastClassAnalyzer.java
License:Open Source License
/** * Add all possible calls for a given method * //from ww w. ja v a 2 s . c o m * @param callGraph * @param mn */ @SuppressWarnings("unchecked") public void handleMethodNode(ClassNode cn, MethodNode mn, int depth) { if (mn.signature != null) { logger.debug("Visiting signature: " + mn.signature); CollectParameterTypesVisitor visitor = new CollectParameterTypesVisitor(cn.name); new SignatureReader(mn.signature).accept(visitor); for (Type castType : visitor.getClasses()) { if (!castClassMap.containsKey(castType)) { logger.debug("Adding new cast class from signature visitor: " + castType); castClassMap.put(castType, depth + 1); } } } InsnList instructions = mn.instructions; Iterator<AbstractInsnNode> iterator = instructions.iterator(); // TODO: This really shouldn't be here but in its own class while (iterator.hasNext()) { AbstractInsnNode insn = iterator.next(); if (insn.getOpcode() == Opcodes.CHECKCAST) { TypeInsnNode typeNode = (TypeInsnNode) insn; Type castType = Type.getObjectType(typeNode.desc); while (castType.getSort() == Type.ARRAY) { castType = castType.getElementType(); } logger.debug("Adding new cast class from cast: " + castType); if (!castClassMap.containsKey(castType)) castClassMap.put(castType, depth + 1); } else if (insn.getOpcode() == Opcodes.INSTANCEOF) { TypeInsnNode typeNode = (TypeInsnNode) insn; Type castType = Type.getObjectType(typeNode.desc); while (castType.getSort() == Type.ARRAY) { castType = castType.getElementType(); } logger.debug("Adding new cast class from instanceof: " + castType); if (!castClassMap.containsKey(castType)) castClassMap.put(castType, depth + 1); } else if (insn.getOpcode() == Opcodes.LDC) { LdcInsnNode ldcNode = (LdcInsnNode) insn; if (ldcNode.cst instanceof Type) { Type type = (Type) ldcNode.cst; while (type.getSort() == Type.ARRAY) { type = type.getElementType(); } if (!castClassMap.containsKey(type)) castClassMap.put(type, depth + 1); } } } }
From source file:org.evosuite.testcarver.instrument.Instrumenter.java
License:Open Source License
@SuppressWarnings("unchecked") private void transformWrapperCalls(MethodNode mn) { Iterator<AbstractInsnNode> iterator = mn.instructions.iterator(); List<Class<?>> wrapperClasses = getWrapperClasses(); while (iterator.hasNext()) { AbstractInsnNode insn = iterator.next(); if (insn instanceof MethodInsnNode) { MethodInsnNode methodInsnNode = (MethodInsnNode) insn; if (methodInsnNode.name.equals("<init>")) { String ownerName = methodInsnNode.owner.replace('/', '.'); for (Class<?> wrapperClass : wrapperClasses) { if (wrapperClass.getName().equals(ownerName)) { logger.debug("Replacing call " + methodInsnNode.name); methodInsnNode.owner = "org/evosuite/testcarver/wrapper/" + methodInsnNode.owner; break; }/* ww w. ja v a2s . co m*/ } } else { String ownerName = methodInsnNode.owner.replace('/', '.'); for (Class<?> wrapperClass : wrapperClasses) { if (wrapperClass.getName().equals(ownerName)) { if (methodInsnNode.getOpcode() == Opcodes.INVOKESTATIC) { logger.debug("Replacing call " + methodInsnNode.name); methodInsnNode.owner = PackageInfo.getEvoSuitePackageWithSlash() + "/testcarver/wrapper/" + methodInsnNode.owner; } Type[] parameterTypes = Type.getArgumentTypes(methodInsnNode.desc); try { Class<?>[] parameterClasses = new Class<?>[parameterTypes.length]; int pos = 0; for (Type parameter : parameterTypes) { switch (parameter.getSort()) { case Type.OBJECT: parameterClasses[pos++] = Class.forName(parameter.getClassName()); break; case Type.BOOLEAN: parameterClasses[pos++] = boolean.class; break; case Type.BYTE: parameterClasses[pos++] = byte.class; break; case Type.CHAR: parameterClasses[pos++] = char.class; break; case Type.DOUBLE: parameterClasses[pos++] = double.class; break; case Type.FLOAT: parameterClasses[pos++] = float.class; break; case Type.INT: parameterClasses[pos++] = int.class; break; case Type.LONG: parameterClasses[pos++] = long.class; break; case Type.SHORT: parameterClasses[pos++] = short.class; break; } } Method method = wrapperClass.getMethod(methodInsnNode.name, parameterClasses); if (Modifier.isFinal(method.getModifiers())) { if (methodInsnNode.getOpcode() != Opcodes.INVOKESTATIC) { methodInsnNode.setOpcode(Opcodes.INVOKESTATIC); Type[] args = Type.getArgumentTypes(methodInsnNode.desc); Type returnType = Type.getReturnType(methodInsnNode.desc); Type[] newargs = new Type[args.length + 1]; newargs[0] = Type.getObjectType(methodInsnNode.owner); for (int i = 0; i < args.length; i++) newargs[i + 1] = args[i]; methodInsnNode.desc = Type.getMethodDescriptor(returnType, newargs); methodInsnNode.owner = PackageInfo.getEvoSuitePackageWithSlash() + "/testcarver/wrapper/" + methodInsnNode.owner; } else { methodInsnNode.name += "_final"; } logger.debug( "Method is final: " + methodInsnNode.owner + "." + methodInsnNode.name); } else { logger.debug("Method is not final: " + methodInsnNode.owner + "." + methodInsnNode.name); } } catch (Exception e) { logger.warn("Error while instrumenting: " + e); } break; } } // } else if(methodInsnNode.name.equals("getTime")) { // if(methodInsnNode.owner.equals("java/util/Calendar")) { // logger.debug("Replacing call "+methodInsnNode.name); // methodInsnNode.owner = "org/evosuite/testcarver/wrapper/java/util/Calendar"; // methodInsnNode.name = "getTime"; // methodInsnNode.desc = "(Ljava/util/Calendar;)Ljava/util/Date;"; // methodInsnNode.setOpcode(Opcodes.INVOKESTATIC); // } // } } } else if (insn.getOpcode() == Opcodes.NEW || insn.getOpcode() == Opcodes.CHECKCAST) { TypeInsnNode typeInsnNode = (TypeInsnNode) insn; Type generatedType = Type.getType(typeInsnNode.desc); String name = generatedType.getInternalName().replace('/', '.'); logger.debug("Checking for replacement of " + name); for (Class<?> wrapperClass : wrapperClasses) { if (wrapperClass.getName().equals(name)) { logger.debug("Replacing new " + name); typeInsnNode.desc = PackageInfo.getEvoSuitePackageWithSlash() + "/testcarver/wrapper/" + generatedType.getInternalName(); break; } } } } }
From source file:org.fabric3.implementation.bytecode.reflection.BytecodeConsumerInvokerFactory.java
License:Open Source License
private void writeTargetInvoke(Method method, String internalTargetName, ClassWriter cw) { MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "invoke", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", null, EXCEPTIONS); mv.visitCode();/*from w w w .j a v a 2s . co m*/ Label label1 = new Label(); mv.visitLabel(label1); mv.visitLineNumber(9, label1); mv.visitVarInsn(Opcodes.ALOAD, 1); mv.visitTypeInsn(Opcodes.CHECKCAST, internalTargetName); if (method.getParameterTypes().length == 1) { // single argument method, load the parameter passes on to the stack Class<?> paramType = method.getParameterTypes()[0]; mv.visitVarInsn(Opcodes.ALOAD, 2); writeParam(paramType, mv); } else if (method.getParameterTypes().length > 1) { // multi-argument method: cast the parameter to an object array and then load each element on the stack to be passed as params mv.visitVarInsn(Opcodes.ALOAD, 2); mv.visitTypeInsn(Opcodes.CHECKCAST, "[Ljava/lang/Object;"); mv.visitTypeInsn(Opcodes.CHECKCAST, "[Ljava/lang/Object;"); mv.visitVarInsn(Opcodes.ASTORE, 3); int pos = 0; mv.visitVarInsn(Opcodes.ALOAD, 3); for (Class<?> paramType : method.getParameterTypes()) { mv.visitInsn(Opcodes.ICONST_0 + pos); mv.visitInsn(Opcodes.AALOAD); writeParam(paramType, mv); if (pos < method.getParameterTypes().length - 1) { mv.visitVarInsn(Opcodes.ALOAD, 3); } pos++; } } // invoke the instance String methodName = method.getName(); String methodDescriptor = Type.getMethodDescriptor(method); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, internalTargetName, methodName, methodDescriptor); Class<?> returnType = method.getReturnType(); writeReturn(returnType, mv); Label label2 = new Label(); mv.visitLabel(label2); String descriptor = Type.getDescriptor(ServiceInvoker.class); mv.visitLocalVariable("this", descriptor, null, label1, label2, 0); mv.visitLocalVariable("instance", "Ljava/lang/Object;", null, label1, label2, 1); mv.visitLocalVariable("arg", "Ljava/lang/Object;", null, label1, label2, 2); mv.visitMaxs(2, 3); mv.visitEnd(); }
From source file:org.fabric3.implementation.bytecode.reflection.BytecodeConsumerInvokerFactory.java
License:Open Source License
private void writeParam(Class<?> paramType, MethodVisitor mv) { if (Integer.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Integer"); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I"); } else if (Boolean.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Boolean"); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z"); } else if (Double.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Double"); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D"); } else if (Float.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Float"); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F"); } else if (Short.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Short"); mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S"); } else if (Byte.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Byte"); mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B"); } else if (Long.TYPE.equals(paramType)) { mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Long"); mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J"); } else {// w ww .ja v a2s. c o m mv.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(paramType)); } }
From source file:org.gradle.model.internal.manage.schema.extract.ManagedProxyClassGenerator.java
License:Apache License
private void putNodeStateFieldValueOnStack(MethodVisitor methodVisitor, Type generatedType) { putFieldValueOnStack(methodVisitor, generatedType, STATE_FIELD_NAME, GENERATED_VIEW_STATE_TYPE); methodVisitor.visitTypeInsn(Opcodes.CHECKCAST, MODEL_ELEMENT_STATE_TYPE_INTERNAL_NAME); }