/**
* Copyright (C) 2010-2017 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.instrumentation.coverage;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.evosuite.PackageInfo;
import org.evosuite.Properties;
import org.evosuite.Properties.Criterion;
import org.evosuite.coverage.dataflow.DefUsePool;
import org.evosuite.graphs.GraphPool;
import org.evosuite.graphs.cfg.BytecodeInstruction;
import org.evosuite.graphs.cfg.RawControlFlowGraph;
import org.evosuite.testcase.execution.ExecutionTrace;
import org.evosuite.testcase.execution.ExecutionTracer;
import org.evosuite.utils.ArrayUtil;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* <p>
* DefUseInstrumentation class.
* </p>
*
* @author Andre Mis
*/
public class DefUseInstrumentation implements MethodInstrumentation {
private static Logger logger = LoggerFactory.getLogger(DefUseInstrumentation.class);
/*
* (non-Javadoc)
*
* @see org.evosuite.cfg.MethodInstrumentation#analyze(org.objectweb
* .asm.tree.MethodNode, org.jgrapht.Graph, java.lang.String,
* java.lang.String)
*/
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public void analyze(ClassLoader classLoader, MethodNode mn, String className,
String methodName, int access) {
RawControlFlowGraph completeCFG = GraphPool.getInstance(classLoader).getRawCFG(className,
methodName);
logger.info("Applying DefUse instrumentation on CFG with "+completeCFG.vertexCount() +" nodes");
Iterator<AbstractInsnNode> j = mn.instructions.iterator();
while (j.hasNext()) {
AbstractInsnNode in = j.next();
for (BytecodeInstruction v : completeCFG.vertexSet()) {
if ((ArrayUtil.contains(Properties.CRITERION, Criterion.DEFUSE)
|| ArrayUtil.contains(Properties.CRITERION, Criterion.ALLDEFS))
&& in.equals(v.getASMNode()) && v.isDefUse()) {
boolean isValidDU = false;
// if(v.isLocalArrayDefinition()) {
// LoggingUtils.getEvoLogger().info(
// "LOCAL ARRAY VAR DEF " + v.toString()+" loaded by "+v.getSourceOfStackInstruction(2).toString());
// }
if (v.isMethodCallOfField()) {
// keep track of field method calls, though we do not
// know
// how to handle them at this point during the analysis
// (need complete CCFGs first)
isValidDU = DefUsePool.addAsFieldMethodCall(v);
} else {
// keep track of uses
if (v.isUse())
isValidDU = DefUsePool.addAsUse(v);
// keep track of definitions
if (v.isDefinition())
isValidDU = DefUsePool.addAsDefinition(v) || isValidDU;
}
if (isValidDU) {
boolean staticContext = v.isStaticDefUse()
|| ((access & Opcodes.ACC_STATIC) > 0);
// adding instrumentation for defuse-coverage
InsnList instrumentation = getInstrumentation(v, staticContext,
className,
methodName,
mn);
if (instrumentation == null)
throw new IllegalStateException("error instrumenting node "
+ v.toString());
if (v.isMethodCallOfField())
mn.instructions.insertBefore(v.getASMNode(), instrumentation);
else if(v.isArrayStoreInstruction())
mn.instructions.insertBefore(v.getSourceOfArrayReference().getASMNode(), instrumentation);
// Loading of an array is already handled by ALOAD
// AILOAD would only be needed if we define DU pairs on
// array indices
// else if(v.isArrayLoadInstruction())
// mn.instructions.insertBefore(v.getSourceOfArrayReference().getASMNode(), instrumentation);
else if(v.isUse())
mn.instructions.insert(v.getASMNode(), instrumentation);
else
mn.instructions.insertBefore(v.getASMNode(), instrumentation);
}
}
}
}
}
/**
* Creates the instrumentation needed to track defs and uses
*
*/
private InsnList getInstrumentation(BytecodeInstruction v, boolean staticContext,
String className, String methodName, MethodNode mn) {
InsnList instrumentation = new InsnList();
if (!v.isDefUse()) {
logger.warn("unexpected DefUseInstrumentation call for a non-DU-instruction");
return instrumentation;
}
if (DefUsePool.isKnownAsFieldMethodCall(v)) {
return getMethodInstrumentation(v, staticContext, instrumentation, mn);
}
if (DefUsePool.isKnownAsUse(v)) {
// The actual object that is defined is on the stack _after_ the load instruction
addObjectInstrumentation(v, instrumentation, mn);
addCallingObjectInstrumentation(staticContext, instrumentation);
instrumentation.add(new LdcInsnNode(DefUsePool.getUseCounter()));
instrumentation.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
PackageInfo.getNameWithSlash(ExecutionTracer.class), "passedUse",
"(Ljava/lang/Object;Ljava/lang/Object;I)V"));
}
if (DefUsePool.isKnownAsDefinition(v)) {
// The actual object that is defined is on the stack _before_ the store instruction
addObjectInstrumentation(v, instrumentation, mn);
addCallingObjectInstrumentation(staticContext, instrumentation);
instrumentation.add(new LdcInsnNode(DefUsePool.getDefCounter()));
instrumentation.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
PackageInfo.getNameWithSlash(org.evosuite.testcase.execution.ExecutionTracer.class), "passedDefinition",
"(Ljava/lang/Object;Ljava/lang/Object;I)V"));
}
return instrumentation;
}
private void addCallingObjectInstrumentation(boolean staticContext,
InsnList instrumentation) {
// the object on which the DU is covered is passed by the
// instrumentation.
// If we are in a static context, null is passed instead
if (staticContext) {
instrumentation.add(new InsnNode(Opcodes.ACONST_NULL));
} else {
instrumentation.add(new VarInsnNode(Opcodes.ALOAD, 0)); // "this"
}
}
@SuppressWarnings({ "unchecked", "unused" })
private int getNextLocalVariable(MethodNode mn) {
int var = 1;
List<LocalVariableNode> nodes = mn.localVariables;
for(LocalVariableNode varNode : nodes) {
if(varNode.index >= var) {
var = varNode.index + 1;
}
}
return var;
}
private void addObjectInstrumentation(BytecodeInstruction instruction, InsnList instrumentation, MethodNode mn) {
if(instruction.isLocalVariableDefinition()) {
if(instruction.getASMNode().getOpcode() == Opcodes.ALOAD) {
instrumentation.add(new InsnNode(Opcodes.DUP));
} else {
instrumentation.add(new InsnNode(Opcodes.ACONST_NULL));
}
} else if(instruction.isLocalVariableUse()){
if(instruction.getASMNode().getOpcode() == Opcodes.ASTORE) {
instrumentation.add(new InsnNode(Opcodes.DUP));
} else {
instrumentation.add(new InsnNode(Opcodes.ACONST_NULL));
}
} else if(instruction.isArrayStoreInstruction()) {
// Object, index, value
instrumentation.add(new InsnNode(Opcodes.DUP));
// } else if(instruction.isArrayLoadInstruction()) {
// instrumentation.add(new InsnNode(Opcodes.DUP));
} else if(instruction.isFieldNodeDU()) {
// TODO: FieldNodeDU takes care of ArrayStore - why?
Type type = Type.getType(instruction.getFieldType());
if(type.getSort() == Type.OBJECT) {
instrumentation.add(new InsnNode(Opcodes.DUP));
} else {
instrumentation.add(new InsnNode(Opcodes.ACONST_NULL));
}
} else if(instruction.isMethodCall()) {
Type type = Type.getReturnType(instruction.getMethodCallDescriptor());
if(type.getSort() == Type.OBJECT) {
instrumentation.add(new InsnNode(Opcodes.DUP));
} else {
instrumentation.add(new InsnNode(Opcodes.ACONST_NULL));
}
}
}
@SuppressWarnings("unchecked")
private int getNextLocalNum(MethodNode mn) {
List<LocalVariableNode> variables = mn.localVariables;
int max = 0;
for(LocalVariableNode node : variables) {
if(node.index > max)
max = node.index;
}
return max + 1;
}
private InsnList getMethodInstrumentation(BytecodeInstruction call, boolean staticContext, InsnList instrumentation, MethodNode mn) {
String descriptor = call.getMethodCallDescriptor();
Type[] args = Type.getArgumentTypes(descriptor);
int loc = getNextLocalNum(mn);
Map<Integer, Integer> to = new HashMap<Integer, Integer>();
for (int i = args.length - 1; i >= 0; i--) {
Type type = args[i];
instrumentation.add(new VarInsnNode(type.getOpcode(Opcodes.ISTORE), loc));
to.put(i, loc);
loc++;
}
// instrumentation.add(new InsnNode(Opcodes.DUP));//callee
addObjectInstrumentation(call, instrumentation, mn);
addCallingObjectInstrumentation(staticContext, instrumentation);
// field method calls get special treatment:
// during instrumentation it is not clear whether a field method
// call constitutes a definition or a use. So the instrumentation
// will call a special function of the ExecutionTracer which will
// redirect the call to either passedUse() or passedDefinition()
// using the information available during runtime (the CCFGs)
instrumentation.add(new LdcInsnNode(DefUsePool.getDefUseCounter()));
instrumentation.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
PackageInfo.getNameWithSlash(ExecutionTracer.class), "passedFieldMethodCall",
"(Ljava/lang/Object;Ljava/lang/Object;I)V"));
for (int i = 0; i < args.length; i++) {
Type type = args[i];
instrumentation.add(new VarInsnNode(type.getOpcode(Opcodes.ILOAD), to.get(i)));
}
return instrumentation;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.cfg.MethodInstrumentation#executeOnExcludedMethods ()
*/
/** {@inheritDoc} */
@Override
public boolean executeOnExcludedMethods() {
return false;
}
/*
* (non-Javadoc)
*
* @see org.evosuite.cfg.MethodInstrumentation#executeOnMainMethod()
*/
/** {@inheritDoc} */
@Override
public boolean executeOnMainMethod() {
return false;
}
}