Java tutorial
/** * Copyright (C) 2010-2016 Gordon Fraser, Andrea Arcuri and EvoSuite * contributors * * This file is part of EvoSuite. * * EvoSuite is free software: you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3.0 of the License, or * (at your option) any later version. * * EvoSuite is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with EvoSuite. If not, see <http://www.gnu.org/licenses/>. */ package org.evosuite.graphs.cfg; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.evosuite.coverage.branch.BranchPool; import org.evosuite.runtime.instrumentation.AnnotatedLabel; import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.InsnNode; import org.objectweb.asm.tree.LdcInsnNode; import org.objectweb.asm.tree.LabelNode; import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.VarInsnNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * <p> * BytecodeInstructionPool class. * </p> * * @author Andre Mis */ public class BytecodeInstructionPool { private static Logger logger = LoggerFactory.getLogger(BytecodeInstructionPool.class); private static Map<ClassLoader, BytecodeInstructionPool> instanceMap = new HashMap<ClassLoader, BytecodeInstructionPool>(); private final ClassLoader classLoader; private BytecodeInstructionPool(ClassLoader classLoader) { this.classLoader = classLoader; } public static BytecodeInstructionPool getInstance(ClassLoader classLoader) { if (!instanceMap.containsKey(classLoader)) { instanceMap.put(classLoader, new BytecodeInstructionPool(classLoader)); } return instanceMap.get(classLoader); } // maps className -> method inside that class -> list of // BytecodeInstructions private final Map<String, Map<String, List<BytecodeInstruction>>> instructionMap = new HashMap<String, Map<String, List<BytecodeInstruction>>>(); private final List<MethodNode> knownMethodNodes = new ArrayList<MethodNode>(); // fill the pool /** * Called by each CFGGenerator for it's corresponding method. * * The MethodNode contains all instructions within a method. A call to * registerMethodNode() fills the instructionMap of the * BytecodeInstructionPool with the instructions in that method and returns * a List containing the BytecodeInstructions within that method. * * While registering all instructions the lineNumber of each * BytecodeInstruction is set. * * @param node * a {@link org.objectweb.asm.tree.MethodNode} object. * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @return a {@link java.util.List} object. */ public List<BytecodeInstruction> registerMethodNode(MethodNode node, String className, String methodName) { registerMethodNode(node); int lastLineNumber = -1; int bytecodeOffset = 0; for (int instructionId = 0; instructionId < node.instructions.size(); instructionId++) { AbstractInsnNode instructionNode = node.instructions.get(instructionId); BytecodeInstruction instruction = BytecodeInstructionFactory.createBytecodeInstruction(classLoader, className, methodName, instructionId, bytecodeOffset, instructionNode); if (instruction.isLineNumber()) lastLineNumber = instruction.getLineNumber(); else if (lastLineNumber != -1) instruction.setLineNumber(lastLineNumber); bytecodeOffset += getBytecodeIncrement(instructionNode); if (!instruction.isLabel() && !instruction.isLineNumber() && !instruction.isFrame()) { bytecodeOffset++; } registerInstruction(instruction); } List<BytecodeInstruction> r = getInstructionsIn(className, methodName); if (r == null || r.size() == 0) throw new IllegalStateException( "expect instruction pool to return non-null non-empty list of instructions for a previously registered method " + methodName); return r; } /** * Determine how many bytes the current instruction occupies together with * its operands * * @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; } private void registerMethodNode(MethodNode node) { for (MethodNode mn : knownMethodNodes) if (mn == node) logger.debug("CFGGenerator.analyze() apparently got called for the same MethodNode twice"); knownMethodNodes.add(node); } /** * <p> * registerInstruction * </p> * * @param instruction * a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. */ public void registerInstruction(BytecodeInstruction instruction) { String className = instruction.getClassName(); String methodName = instruction.getMethodName(); if (!instructionMap.containsKey(className)) instructionMap.put(className, new HashMap<String, List<BytecodeInstruction>>()); if (!instructionMap.get(className).containsKey(methodName)) instructionMap.get(className).put(methodName, new ArrayList<BytecodeInstruction>()); instructionMap.get(className).get(methodName).add(instruction); logger.debug("Registering instruction " + instruction); List<BytecodeInstruction> instructions = instructionMap.get(className).get(methodName); if (instructions.size() > 1) { BytecodeInstruction previous = instructions.get(instructions.size() - 2); if (previous.isLabel()) { LabelNode ln = (LabelNode) previous.asmNode; if (ln.getLabel() instanceof AnnotatedLabel) { AnnotatedLabel aLabel = (AnnotatedLabel) ln.getLabel(); if (aLabel.isStartTag()) { if (aLabel.shouldIgnore()) { logger.debug("Ignoring artificial branch: " + instruction); return; } } } } } if (instruction.isActualBranch()) { BranchPool.getInstance(classLoader).registerAsBranch(instruction); } } // retrieve data from the pool /** * <p> * getInstruction * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @param instructionId * a int. * @param asmNode * a {@link org.objectweb.asm.tree.AbstractInsnNode} object. * @return a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. */ public BytecodeInstruction getInstruction(String className, String methodName, int instructionId, AbstractInsnNode asmNode) { BytecodeInstruction r = getInstruction(className, methodName, instructionId); if (r != null) assert (r.sanityCheckAbstractInsnNode(asmNode)); return r; } /** * <p> * getInstruction * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @param instructionId * a int. * @return a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. */ public BytecodeInstruction getInstruction(String className, String methodName, int instructionId) { if (instructionMap.get(className) == null) { logger.debug("unknown class: " + className); logger.debug(instructionMap.keySet().toString()); return null; } if (instructionMap.get(className).get(methodName) == null) { logger.debug("unknown method: " + methodName); logger.debug(instructionMap.get(className).keySet().toString()); return null; } for (BytecodeInstruction instruction : instructionMap.get(className).get(methodName)) { if (instruction.getInstructionId() == instructionId) return instruction; } logger.debug("unknown instruction " + instructionId + ", have " + instructionMap.get(className).get(methodName).size()); for (int i = 0; i < instructionMap.get(className).get(methodName).size(); i++) { logger.info(instructionMap.get(className).get(methodName).get(i).toString()); } return null; } /** * <p> * getInstruction * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @param node * a {@link org.objectweb.asm.tree.AbstractInsnNode} object. * @return a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. */ public BytecodeInstruction getInstruction(String className, String methodName, AbstractInsnNode node) { if (instructionMap.get(className) == null) { logger.debug("unknown class: " + className); logger.debug(instructionMap.keySet().toString()); return null; } if (instructionMap.get(className).get(methodName) == null) { logger.debug("unknown method: " + methodName); logger.debug(instructionMap.get(className).keySet().toString()); return null; } for (BytecodeInstruction instruction : instructionMap.get(className).get(methodName)) { if (instruction.asmNode == node) return instruction; } logger.debug("unknown instruction: " + node + ", have " + instructionMap.get(className).get(methodName).size() + " instructions for this method"); logger.debug(instructionMap.get(className).get(methodName).toString()); return null; } /** * <p> * knownClasses * </p> * * @return a {@link java.util.Set} object. */ public Set<String> knownClasses() { return new HashSet<String>(instructionMap.keySet()); } /** * <p> * knownMethods * </p> * * @param className * a {@link java.lang.String} object. * @return a {@link java.util.Set} object. */ public Set<String> knownMethods(String className) { Set<String> r = new HashSet<String>(); if (instructionMap.get(className) != null) r.addAll(instructionMap.get(className).keySet()); return r; } public boolean hasMethod(String className, String methodName) { if (instructionMap.get(className) != null) return instructionMap.get(className).containsKey(methodName); return false; } /** * <p> * getInstructionsIn * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @return a {@link java.util.List} object. */ public List<BytecodeInstruction> getInstructionsIn(String className, String methodName) { if (instructionMap.get(className) == null || instructionMap.get(className).get(methodName) == null) return null; List<BytecodeInstruction> r = new ArrayList<BytecodeInstruction>(); r.addAll(instructionMap.get(className).get(methodName)); return r; } public List<BytecodeInstruction> getInstructionsIn(String className) { if (instructionMap.get(className) == null) return null; List<BytecodeInstruction> r = new ArrayList<BytecodeInstruction>(); Map<String, List<BytecodeInstruction>> methodMap = instructionMap.get(className); for (List<BytecodeInstruction> methodInstructions : methodMap.values()) { r.addAll(methodInstructions); } return r; } public List<BytecodeInstruction> getAllInstructions() { List<BytecodeInstruction> r = new ArrayList<BytecodeInstruction>(); for (String className : instructionMap.keySet()) { Map<String, List<BytecodeInstruction>> methodMap = instructionMap.get(className); for (List<BytecodeInstruction> methodInstructions : methodMap.values()) { r.addAll(methodInstructions); } } return r; } /** * <p> * logInstructionsIn * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. */ public void logInstructionsIn(String className, String methodName) { logger.debug("Printing instructions in " + className + "." + methodName + ":"); List<BytecodeInstruction> instructions = getInstructionsIn(className, methodName); if (instructions == null) { logger.debug("..unknown method"); } else { for (BytecodeInstruction instruction : instructions) { logger.debug("\t" + instruction); } } } /** * <p> * createFakeInstruction * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. * @return a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. */ public BytecodeInstruction createFakeInstruction(String className, String methodName) { AbstractInsnNode fakeNode = new InsnNode(Opcodes.NOP); int instructionId = getInstructionsIn(className, methodName).size(); BytecodeInstruction instruction = new BytecodeInstruction(classLoader, className, methodName, instructionId, -1, fakeNode); registerInstruction(instruction); return instruction; } /** * <p> * clear * </p> */ public void clear() { instructionMap.clear(); knownMethodNodes.clear(); } public static void clearAll() { BytecodeInstructionPool.instanceMap.clear(); } /** * <p> * clear * </p> * * @param className * a {@link java.lang.String} object. */ public void clear(String className) { instructionMap.remove(className); } public static void clearAll(String className) { for (BytecodeInstructionPool pool : instanceMap.values()) { pool.clear(className); } } /** * <p> * clear * </p> * * @param className * a {@link java.lang.String} object. * @param methodName * a {@link java.lang.String} object. */ public void clear(String className, String methodName) { if (instructionMap.containsKey(className)) instructionMap.get(className).remove(methodName); } public static void clearAll(String className, String methodName) { for (BytecodeInstructionPool pool : instanceMap.values()) { pool.clear(className, methodName); } } /** * <p> * forgetInstruction * </p> * * @param ins * a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object. * @return a boolean. */ public boolean forgetInstruction(BytecodeInstruction ins) { if (!instructionMap.containsKey(ins.getClassName())) return false; if (!instructionMap.get(ins.getClassName()).containsKey(ins.getMethodName())) return false; return instructionMap.get(ins.getClassName()).get(ins.getMethodName()).remove(ins); } public int getFirstLineNumberOfMethod(String className, String methodName) { if (instructionMap.get(className) == null) throw new IllegalArgumentException("unknown class " + className); if (instructionMap.get(className).get(methodName) == null) throw new IllegalArgumentException("unknown method " + methodName + " in class " + className); if (instructionMap.get(className).get(methodName).isEmpty()) throw new IllegalArgumentException( "no instructions in method " + methodName + " in class " + className); int r = Integer.MAX_VALUE; for (BytecodeInstruction ins : instructionMap.get(className).get(methodName)) { if (ins.getLineNumber() < r) r = ins.getLineNumber(); } return r; } public BytecodeInstruction getFirstInstructionAtLineNumber(String className, String methodName, int lineNumber) { // TODO if (instructionMap.get(className) == null) return null; if (instructionMap.get(className).get(methodName) == null) return null; if (instructionMap.get(className).get(methodName).isEmpty()) return null; for (BytecodeInstruction ins : instructionMap.get(className).get(methodName)) { if (ins.getLineNumber() == lineNumber) return ins; } return null; } }