List of usage examples for org.objectweb.asm Opcodes IRETURN
int IRETURN
To view the source code for org.objectweb.asm Opcodes IRETURN.
Click Source Link
From source file:org.cacheonix.impl.transformer.ByteInstructionTest.java
License:LGPL
/** * Test method for {@link ByteInstruction#getReturnCode(String desc)} . *///from w w w . j av a 2s .co m public void testGetReturnCode() { String desc = "(IF)V"; int ret = ByteInstruction.getReturnCode(desc); assertEquals(ret, Opcodes.RETURN); desc = "(IF)I"; ret = ByteInstruction.getReturnCode(desc); assertEquals(ret, Opcodes.IRETURN); desc = "(IF)D"; ret = ByteInstruction.getReturnCode(desc); assertEquals(ret, Opcodes.DRETURN); desc = "(IF)Ljava/lang/Object;"; ret = ByteInstruction.getReturnCode(desc); assertEquals(ret, Opcodes.ARETURN); }
From source file:org.coldswap.util.MethodUtil.java
License:Open Source License
public static int getRetOpcodeToReplace(Type retType) { String retDesc = retType.getDescriptor(); int opcode = Opcodes.IRETURN; if ("Z".equals(retDesc)) { opcode = Opcodes.IRETURN;// ww w.j a v a 2s . c o m } else if ("B".equals(retDesc)) { opcode = Opcodes.IRETURN; } else if ("C".equals(retDesc)) { opcode = Opcodes.IRETURN; } else if ("S".equals(retDesc)) { opcode = Opcodes.IRETURN; } else if ("I".equals(retDesc)) { opcode = Opcodes.IRETURN; } else if ("J".equals(retDesc)) { opcode = Opcodes.LRETURN; } else if ("F".equals(retDesc)) { opcode = Opcodes.FRETURN; } else if ("D".equals(retDesc)) { opcode = Opcodes.DRETURN; } return opcode; }
From source file:org.decojer.cavaj.readers.asm.ReadMethodVisitor.java
License:Open Source License
@Override public void visitInsn(final int opcode) { T t = null;//from www . j a va2s. c om int iValue = Integer.MIN_VALUE; Object oValue = null; switch (opcode) { case Opcodes.NOP: // nothing to do, ignore break; /******* * ADD * *******/ case Opcodes.DADD: t = T.DOUBLE; // fall through case Opcodes.FADD: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IADD: if (t == null) { t = T.INT; } // fall through case Opcodes.LADD: if (t == null) { t = T.LONG; } add(new ADD(this.ops.size(), opcode, this.line, t)); break; /********* * ALOAD * *********/ case Opcodes.AALOAD: t = T.REF; // fall through case Opcodes.BALOAD: if (t == null) { t = T.SMALL; } // fall through case Opcodes.CALOAD: if (t == null) { t = T.CHAR; } // fall through case Opcodes.DALOAD: if (t == null) { t = T.DOUBLE; } // fall through case Opcodes.FALOAD: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IALOAD: if (t == null) { t = T.INT; } // fall through case Opcodes.LALOAD: if (t == null) { t = T.LONG; } // fall through case Opcodes.SALOAD: if (t == null) { t = T.SHORT; } add(new ALOAD(this.ops.size(), opcode, this.line, t)); break; /******* * AND * *******/ case Opcodes.IAND: t = T.AINT; // fall through case Opcodes.LAND: if (t == null) { t = T.LONG; } add(new AND(this.ops.size(), opcode, this.line, t)); break; /*************** * ARRAYLENGTH * ***************/ case Opcodes.ARRAYLENGTH: add(new ARRAYLENGTH(this.ops.size(), opcode, this.line)); break; /********** * ASTORE * **********/ case Opcodes.AASTORE: t = T.REF; // fall through case Opcodes.BASTORE: if (t == null) { t = T.SMALL; } // fall through case Opcodes.CASTORE: if (t == null) { t = T.CHAR; } // fall through case Opcodes.DASTORE: if (t == null) { t = T.DOUBLE; } // fall through case Opcodes.FASTORE: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IASTORE: if (t == null) { t = T.INT; } // fall through case Opcodes.LASTORE: if (t == null) { t = T.LONG; } // fall through case Opcodes.SASTORE: if (t == null) { t = T.SHORT; } add(new ASTORE(this.ops.size(), opcode, this.line, t)); break; /******** * CAST * ********/ case Opcodes.D2F: t = T.DOUBLE; oValue = T.FLOAT; // fall through case Opcodes.D2I: if (t == null) { t = T.DOUBLE; oValue = T.INT; } // fall through case Opcodes.D2L: if (t == null) { t = T.DOUBLE; oValue = T.LONG; } // fall through case Opcodes.F2D: if (t == null) { t = T.FLOAT; oValue = T.DOUBLE; } // fall through case Opcodes.F2I: if (t == null) { t = T.FLOAT; oValue = T.INT; } // fall through case Opcodes.F2L: if (t == null) { t = T.FLOAT; oValue = T.LONG; } // fall through case Opcodes.I2B: if (t == null) { t = T.INT; oValue = T.BYTE; } // fall through case Opcodes.I2C: if (t == null) { t = T.INT; oValue = T.CHAR; } // fall through case Opcodes.I2D: if (t == null) { t = T.INT; oValue = T.DOUBLE; } // fall through case Opcodes.I2F: if (t == null) { t = T.INT; oValue = T.FLOAT; } // fall through case Opcodes.I2L: if (t == null) { t = T.INT; oValue = T.LONG; } // fall through case Opcodes.I2S: if (t == null) { t = T.INT; oValue = T.SHORT; } // fall through case Opcodes.L2D: if (t == null) { t = T.LONG; oValue = T.DOUBLE; } // fall through case Opcodes.L2F: if (t == null) { t = T.LONG; oValue = T.FLOAT; } // fall through case Opcodes.L2I: if (t == null) { t = T.LONG; oValue = T.INT; } assert oValue instanceof T; add(new CAST(this.ops.size(), opcode, this.line, t, (T) oValue)); break; /******* * CMP * *******/ case Opcodes.DCMPG: t = T.DOUBLE; iValue = CMP.T_G; // fall through case Opcodes.DCMPL: if (t == null) { t = T.DOUBLE; iValue = CMP.T_L; } // fall through case Opcodes.FCMPG: if (t == null) { t = T.FLOAT; iValue = CMP.T_G; } // fall through case Opcodes.FCMPL: if (t == null) { t = T.FLOAT; iValue = CMP.T_L; } // fall through case Opcodes.LCMP: if (t == null) { t = T.LONG; iValue = CMP.T_0; } add(new CMP(this.ops.size(), opcode, this.line, t, iValue)); break; /******* * DIV * *******/ case Opcodes.DDIV: t = T.DOUBLE; // fall through case Opcodes.FDIV: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IDIV: if (t == null) { t = T.INT; } // fall through case Opcodes.LDIV: if (t == null) { t = T.LONG; } add(new DIV(this.ops.size(), opcode, this.line, t)); break; /******* * DUP * *******/ case Opcodes.DUP: oValue = DUP.Kind.DUP; // fall through case Opcodes.DUP_X1: if (oValue == null) { oValue = DUP.Kind.DUP_X1; } // fall through case Opcodes.DUP_X2: if (oValue == null) { oValue = DUP.Kind.DUP_X2; } // fall through case Opcodes.DUP2: if (oValue == null) { oValue = DUP.Kind.DUP2; } // fall through case Opcodes.DUP2_X1: if (oValue == null) { oValue = DUP.Kind.DUP2_X1; } // fall through case Opcodes.DUP2_X2: if (oValue == null) { oValue = DUP.Kind.DUP2_X2; } add(new DUP(this.ops.size(), opcode, this.line, (DUP.Kind) oValue)); break; /*********** * MONITOR * ***********/ case Opcodes.MONITORENTER: oValue = MONITOR.Kind.ENTER; // fall through case Opcodes.MONITOREXIT: if (oValue == null) { oValue = MONITOR.Kind.EXIT; } add(new MONITOR(this.ops.size(), opcode, this.line, (MONITOR.Kind) oValue)); break; /******* * MUL * *******/ case Opcodes.DMUL: t = T.DOUBLE; // fall through case Opcodes.FMUL: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IMUL: if (t == null) { t = T.INT; } // fall through case Opcodes.LMUL: if (t == null) { t = T.LONG; } add(new MUL(this.ops.size(), opcode, this.line, t)); break; /******* * NEG * *******/ case Opcodes.DNEG: t = T.DOUBLE; // fall through case Opcodes.FNEG: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.INEG: if (t == null) { t = T.INT; } // fall through case Opcodes.LNEG: if (t == null) { t = T.LONG; } add(new NEG(this.ops.size(), opcode, this.line, t)); break; /****** * OR * ******/ case Opcodes.IOR: t = T.AINT; // fall through case Opcodes.LOR: if (t == null) { t = T.LONG; } add(new OR(this.ops.size(), opcode, this.line, t)); break; /******* * POP * *******/ case Opcodes.POP: oValue = POP.Kind.POP; // fall through case Opcodes.POP2: if (oValue == null) { oValue = POP.Kind.POP2; } add(new POP(this.ops.size(), opcode, this.line, (POP.Kind) oValue)); break; /******** * PUSH * ********/ case Opcodes.ACONST_NULL: t = T.REF; // fall through case Opcodes.DCONST_0: if (t == null) { oValue = 0D; t = T.DOUBLE; } // fall through case Opcodes.FCONST_0: if (t == null) { oValue = 0F; t = T.FLOAT; } // fall through case Opcodes.ICONST_0: if (t == null) { oValue = 0; t = T.getJvmIntT(0); } // fall through case Opcodes.LCONST_0: if (t == null) { oValue = 0L; t = T.LONG; } // fall through case Opcodes.DCONST_1: if (t == null) { oValue = 1D; t = T.DOUBLE; } // fall through case Opcodes.FCONST_1: if (t == null) { oValue = 1F; t = T.FLOAT; } // fall through case Opcodes.ICONST_1: if (t == null) { oValue = 1; t = T.getJvmIntT(1); } // fall through case Opcodes.LCONST_1: if (t == null) { oValue = 1L; t = T.LONG; } // fall through case Opcodes.FCONST_2: if (t == null) { oValue = 2F; t = T.FLOAT; } // fall through case Opcodes.ICONST_2: if (t == null) { oValue = 2; t = T.getJvmIntT(2); } // fall through case Opcodes.ICONST_3: if (t == null) { oValue = 3; t = T.getJvmIntT(3); } // fall through case Opcodes.ICONST_4: if (t == null) { oValue = 4; t = T.getJvmIntT(4); } // fall through case Opcodes.ICONST_5: if (t == null) { oValue = 5; t = T.getJvmIntT(5); } // fall through case Opcodes.ICONST_M1: if (t == null) { oValue = -1; t = T.getJvmIntT(-1); } add(new PUSH(this.ops.size(), opcode, this.line, t, oValue)); break; /******* * REM * *******/ case Opcodes.DREM: t = T.DOUBLE; // fall through case Opcodes.FREM: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IREM: if (t == null) { t = T.INT; } // fall through case Opcodes.LREM: if (t == null) { t = T.LONG; } add(new REM(this.ops.size(), opcode, this.line, t)); break; /********** * RETURN * **********/ case Opcodes.ARETURN: t = T.REF; // fall through case Opcodes.DRETURN: if (t == null) { t = T.DOUBLE; } // fall through case Opcodes.FRETURN: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.IRETURN: if (t == null) { t = T.AINT; } // fall through case Opcodes.LRETURN: if (t == null) { t = T.LONG; } // fall through case Opcodes.RETURN: if (t == null) { t = T.VOID; } add(new RETURN(this.ops.size(), opcode, this.line, t)); break; /******* * SHL * *******/ case Opcodes.ISHL: t = T.INT; // fall through case Opcodes.LSHL: if (t == null) { t = T.LONG; } add(new SHL(this.ops.size(), opcode, this.line, t, T.INT)); break; /******* * SHR * *******/ case Opcodes.ISHR: case Opcodes.IUSHR: t = T.INT; // fall through case Opcodes.LSHR: case Opcodes.LUSHR: if (t == null) { t = T.LONG; } add(new SHR(this.ops.size(), opcode, this.line, t, T.INT, opcode == Opcodes.IUSHR || opcode == Opcodes.LUSHR)); break; /******* * SUB * *******/ case Opcodes.DSUB: t = T.DOUBLE; // fall through case Opcodes.FSUB: if (t == null) { t = T.FLOAT; } // fall through case Opcodes.ISUB: if (t == null) { t = T.INT; } // fall through case Opcodes.LSUB: if (t == null) { t = T.LONG; } add(new SUB(this.ops.size(), opcode, this.line, t)); break; /******** * SWAP * ********/ case Opcodes.SWAP: add(new SWAP(this.ops.size(), opcode, this.line)); break; /********* * THROW * *********/ case Opcodes.ATHROW: add(new THROW(this.ops.size(), opcode, this.line)); break; /******* * XOR * *******/ case Opcodes.IXOR: t = T.AINT; // fall through case Opcodes.LXOR: { if (t == null) { t = T.LONG; } add(new XOR(this.ops.size(), opcode, this.line, t)); break; } default: log.warn(getM() + ": Unknown insn opcode '" + opcode + "'!"); } }
From source file:org.eclipse.objectteams.otredyn.bytecode.asm.AbstractTransformableClassNode.java
License:Open Source License
/** * Returns the instructions, that are needed to convert * a return value of the type {@link Object} to the real type * @param returnType the real type//from w w w . j a v a 2 s . c om * @return */ protected InsnList getUnboxingInstructionsForReturnValue(Type returnType) { InsnList instructions = new InsnList(); switch (returnType.getSort()) { case Type.VOID: instructions.add(new InsnNode(Opcodes.POP)); instructions.add(new InsnNode(Opcodes.RETURN)); break; case Type.ARRAY: // fallthrough case Type.OBJECT: instructions.add(new TypeInsnNode(Opcodes.CHECKCAST, returnType.getInternalName())); instructions.add(new InsnNode(Opcodes.ARETURN)); break; default: String objectType = AsmTypeHelper.getObjectType(returnType); instructions.add(new TypeInsnNode(Opcodes.CHECKCAST, objectType)); instructions.add(AsmTypeHelper.getUnboxingInstructionForType(returnType, objectType)); instructions.add(new InsnNode(returnType.getOpcode(Opcodes.IRETURN))); } return instructions; }
From source file:org.eclipse.objectteams.otredyn.bytecode.asm.AbstractTransformableClassNode.java
License:Open Source License
/** * Replace all return statements in the given instructions with new * statements that convert the real return value to {@link Object} * and return this new {@link Object}// w w w. j a va 2 s . c o m * * @param instructions * @param returnType */ protected void replaceReturn(InsnList instructions, Type returnType) { if (returnType.getSort() != Type.OBJECT && returnType.getSort() != Type.ARRAY && returnType.getSort() != Type.VOID) { ListIterator<AbstractInsnNode> orgMethodIter = instructions.iterator(); while (orgMethodIter.hasNext()) { AbstractInsnNode orgMethodNode = orgMethodIter.next(); if (orgMethodNode.getOpcode() == returnType.getOpcode(Opcodes.IRETURN)) { instructions.insertBefore(orgMethodNode, AsmTypeHelper.getBoxingInstructionForType(returnType)); instructions.insertBefore(orgMethodNode, new InsnNode(Opcodes.ARETURN)); instructions.remove(orgMethodNode); } } } else if (returnType.getSort() == Type.VOID) { ListIterator<AbstractInsnNode> orgMethodIter = instructions.iterator(); while (orgMethodIter.hasNext()) { AbstractInsnNode orgMethodNode = orgMethodIter.next(); if (orgMethodNode.getOpcode() == Opcodes.RETURN) { instructions.insertBefore(orgMethodNode, new InsnNode(Opcodes.ACONST_NULL)); instructions.insertBefore(orgMethodNode, new InsnNode(Opcodes.ARETURN)); instructions.remove(orgMethodNode); } } } }
From source file:org.eclipse.objectteams.otredyn.bytecode.asm.AddEmptyMethodAdapter.java
License:Open Source License
@Override public void visitEnd() { MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions); if ((this.access & Opcodes.ACC_ABSTRACT) != 0) { mv.visitEnd();/*ww w . ja v a 2 s . c om*/ return; } mv.visitCode(); boolean needConstValue = true; if (superToCall != null) { needConstValue = false; boolean isStatic = (this.access & Opcodes.ACC_STATIC) != 0; int firstArgIndex = isStatic ? 0 : 1; if (!isStatic) mv.visitVarInsn(Opcodes.ALOAD, 0); // "this" Type[] args = Type.getArgumentTypes(desc); for (int i = 0, slot = firstArgIndex; i < args.length; slot += args[i++].getSize()) mv.visitVarInsn(args[i].getOpcode(Opcodes.ILOAD), slot); mv.visitMethodInsn(Opcodes.INVOKESPECIAL, superToCall, name, desc, false); } Type returnType = Type.getReturnType(this.desc); switch (returnType.getSort()) { case Type.VOID: mv.visitInsn(Opcodes.RETURN); break; case Type.INT: case Type.BOOLEAN: case Type.CHAR: case Type.BYTE: case Type.SHORT: if (needConstValue) mv.visitInsn(Opcodes.ICONST_1); mv.visitInsn(Opcodes.IRETURN); break; case Type.FLOAT: if (needConstValue) mv.visitInsn(Opcodes.FCONST_1); mv.visitInsn(Opcodes.FRETURN); break; case Type.LONG: if (needConstValue) mv.visitInsn(Opcodes.LCONST_1); mv.visitInsn(Opcodes.LRETURN); break; case Type.DOUBLE: case Type.OBJECT: case Type.ARRAY: if (needConstValue) mv.visitInsn(Opcodes.ACONST_NULL); mv.visitInsn(Opcodes.ARETURN); break; } mv.visitMaxs(1, maxLocals); mv.visitEnd(); }
From source file:org.eclipse.objectteams.otredyn.bytecode.asm.CreateCallAllBindingsCallInOrgMethod.java
License:Open Source License
protected InsnList getReturnInsn(Type returnType) { InsnList instructions = new InsnList(); switch (returnType.getSort()) { case Type.VOID: instructions.add(new InsnNode(Opcodes.RETURN)); break;//from w w w. ja va 2 s . co m case Type.ARRAY: case Type.OBJECT: instructions.add(new InsnNode(Opcodes.ACONST_NULL)); instructions.add(new InsnNode(Opcodes.ARETURN)); break; case Type.BOOLEAN: case Type.CHAR: case Type.BYTE: case Type.INT: case Type.SHORT: case Type.LONG: instructions.add(new InsnNode(Opcodes.ICONST_0)); instructions.add(new InsnNode(Opcodes.IRETURN)); break; case Type.DOUBLE: instructions.add(new InsnNode(Opcodes.DCONST_0)); instructions.add(new InsnNode(Opcodes.DRETURN)); break; case Type.FLOAT: instructions.add(new InsnNode(Opcodes.FCONST_0)); instructions.add(new InsnNode(Opcodes.FRETURN)); break; } return instructions; }
From source file:org.evosuite.graphs.cfg.ASMWrapper.java
License:Open Source License
/** * <p>//from ww w. j a va 2 s. c o m * isReturn * </p> * * @return a boolean. */ public boolean isReturn() { switch (asmNode.getOpcode()) { case Opcodes.RETURN: case Opcodes.ARETURN: case Opcodes.IRETURN: case Opcodes.LRETURN: case Opcodes.DRETURN: case Opcodes.FRETURN: return true; default: return false; } }
From source file:org.evosuite.instrumentation.BooleanTestabilityTransformation.java
License:Open Source License
/** * This helper function determines whether the boolean on the stack at the * current position will be stored in a Boolean variable * //from www.ja va 2s . c o m * @param position * @param mn * @return */ public boolean isBooleanAssignment(AbstractInsnNode position, MethodNode mn) { AbstractInsnNode node = position.getNext(); logger.info("Checking for ISTORE after boolean"); boolean done = false; while (!done) { if (node.getOpcode() == Opcodes.PUTFIELD || node.getOpcode() == Opcodes.PUTSTATIC) { // TODO: Check whether field is static logger.info("Checking field assignment"); FieldInsnNode fn = (FieldInsnNode) node; if (Type.getType(DescriptorMapping.getInstance().getFieldDesc(fn.owner, fn.name, fn.desc)) == Type.BOOLEAN_TYPE) { return true; } else { return false; } } else if (node.getOpcode() == Opcodes.ISTORE) { logger.info("Found ISTORE after boolean"); VarInsnNode vn = (VarInsnNode) node; // TODO: Check whether variable at this position is a boolean if (isBooleanVariable(vn.var, mn)) { logger.info("Assigning boolean to variable "); return true; } else { logger.info("Variable is not a bool"); return false; } } else if (node.getOpcode() == Opcodes.IRETURN) { logger.info("Checking return value of method {}.{}", cn.name, mn.name); if (DescriptorMapping.getInstance().isTransformedOrBooleanMethod(cn.name, mn.name, mn.desc)) { logger.info("Method returns a bool"); return true; } else { logger.info("Method does not return a bool"); return false; } } else if (node.getOpcode() == Opcodes.BASTORE) { // We remove all bytes, so BASTORE is only used for booleans AbstractInsnNode start = position.getNext(); boolean reassignment = false; while (start != node) { if (node instanceof InsnNode) { reassignment = true; } start = start.getNext(); } logger.info("Possible assignment to array?"); if (reassignment) return false; else return true; } else if (node instanceof MethodInsnNode) { // if it is a boolean parameter of a converted method, then it needs to be converted // Problem: How do we know which parameter it represents? MethodInsnNode methodNode = (MethodInsnNode) node; String desc = DescriptorMapping.getInstance().getMethodDesc(methodNode.owner, methodNode.name, methodNode.desc); Type[] types = Type.getArgumentTypes(desc); if (types.length > 0 && types[types.length - 1] == Type.BOOLEAN_TYPE) { return true; } else { return false; } } else if (node.getOpcode() == Opcodes.GOTO || node.getOpcode() == Opcodes.ICONST_0 || node.getOpcode() == Opcodes.ICONST_1 || node.getOpcode() == -1) { logger.info("Continuing search"); // continue search } else if (!(node instanceof LineNumberNode || node instanceof FrameNode)) { logger.info("Search ended with opcode {}", node.getOpcode()); return false; } if (node != mn.instructions.getLast()) node = node.getNext(); else done = true; } return false; }
From source file:org.evosuite.instrumentation.coverage.LCSAJsInstrumentation.java
License:Open Source License
/** {@inheritDoc} */ @SuppressWarnings("unchecked") //using external lib @Override/* ww w.j a v a2s . c om*/ public void analyze(ClassLoader classLoader, MethodNode mn, String className, String methodName, int access) { Queue<LCSAJ> lcsaj_queue = new LinkedList<LCSAJ>(); HashSet<Integer> targets_reached = new HashSet<Integer>(); AbstractInsnNode start = mn.instructions.getFirst(); int startID = 0; // TODO: This should replace the hack below if (methodName.startsWith("<init>")) { Iterator<AbstractInsnNode> j = mn.instructions.iterator(); boolean constructorInvoked = false; while (j.hasNext()) { AbstractInsnNode in = j.next(); startID++; if (!constructorInvoked) { if (in.getOpcode() == Opcodes.INVOKESPECIAL) { MethodInsnNode cn = (MethodInsnNode) in; Collection<String> superClasses = DependencyAnalysis.getInheritanceTree() .getSuperclasses(className); superClasses.add(className); String classNameWithDots = ResourceList.getClassNameFromResourcePath(cn.owner); if (superClasses.contains(classNameWithDots)) { constructorInvoked = true; break; } } else { continue; } } } } /* if (methodName.startsWith("<init>")) { if (mn.instructions.size() >= 4) { start = mn.instructions.get(4); startID = 4; } } */ LCSAJ a = new LCSAJ(className, methodName, BytecodeInstructionPool.getInstance(classLoader) .getInstruction(className, methodName, startID, start)); lcsaj_queue.add(a); targets_reached.add(0); ArrayList<TryCatchBlockNode> tc_blocks = (ArrayList<TryCatchBlockNode>) mn.tryCatchBlocks; for (TryCatchBlockNode t : tc_blocks) { LCSAJ b = new LCSAJ(className, methodName, BytecodeInstructionPool.getInstance(classLoader) .getInstruction(className, methodName, mn.instructions.indexOf(t.handler), t.handler)); lcsaj_queue.add(b); } while (!lcsaj_queue.isEmpty()) { LCSAJ currentLCSAJ = lcsaj_queue.poll(); int position = mn.instructions.indexOf(currentLCSAJ.getLastNodeAccessed()); // go to next bytecode instruction position++; if (position >= mn.instructions.size()) { // New LCSAJ for current + return LCSAJPool.add_lcsaj(className, methodName, currentLCSAJ); continue; } AbstractInsnNode next = mn.instructions.get(position); currentLCSAJ.lookupInstruction(position, BytecodeInstructionPool.getInstance(classLoader) .getInstruction(className, methodName, position, next)); if (next instanceof JumpInsnNode) { JumpInsnNode jump = (JumpInsnNode) next; // New LCSAJ for current + jump to target LCSAJPool.add_lcsaj(className, methodName, currentLCSAJ); LabelNode target = jump.label; int targetPosition = mn.instructions.indexOf(target); if (jump.getOpcode() != Opcodes.GOTO) { LCSAJ copy = new LCSAJ(currentLCSAJ); lcsaj_queue.add(copy); } if (!targets_reached.contains(targetPosition)) { LCSAJ c = new LCSAJ(className, methodName, BytecodeInstructionPool.getInstance(classLoader) .getInstruction(className, methodName, targetPosition, target)); lcsaj_queue.add(c); targets_reached.add(targetPosition); } } else if (next instanceof TableSwitchInsnNode) { TableSwitchInsnNode tswitch = (TableSwitchInsnNode) next; List<LabelNode> allTargets = tswitch.labels; for (LabelNode target : allTargets) { int targetPosition = mn.instructions.indexOf(target); if (!targets_reached.contains(targetPosition)) { LCSAJ b = new LCSAJ(className, methodName, BytecodeInstructionPool.getInstance(classLoader) .getInstruction(className, methodName, targetPosition, target)); lcsaj_queue.add(b); targets_reached.add(targetPosition); } } } else if (next instanceof InsnNode) { InsnNode insn = (InsnNode) next; // New LCSAJ for current + throw / return if (insn.getOpcode() == Opcodes.ATHROW || insn.getOpcode() == Opcodes.RETURN || insn.getOpcode() == Opcodes.ARETURN || insn.getOpcode() == Opcodes.IRETURN || insn.getOpcode() == Opcodes.DRETURN || insn.getOpcode() == Opcodes.LRETURN || insn.getOpcode() == Opcodes.FRETURN) { LCSAJPool.add_lcsaj(className, methodName, currentLCSAJ); } else lcsaj_queue.add(currentLCSAJ); } else lcsaj_queue.add(currentLCSAJ); } if (Properties.STRATEGY != Strategy.EVOSUITE) addInstrumentation(classLoader, mn, className, methodName); // if (Properties.WRITE_CFG) // for (LCSAJ l : LCSAJPool.getLCSAJs(className, methodName)) { // LCSAJGraph graph = new LCSAJGraph(l, false); // String graphDestination = "evosuite-graphs/LCSAJGraphs/" + className // + "/" + methodName; // File dir = new File(graphDestination); // if (dir.mkdirs()) // graph.generate(new File(graphDestination + "/LCSAJGraph no: " // + l.getID() + ".dot")); // else if (dir.exists()) // graph.generate(new File(graphDestination + "/LCSAJGraph no: " // + l.getID() + ".dot")); // } }