/**
* 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.graphs.cfg;
import org.evosuite.coverage.branch.Branch;
import org.evosuite.coverage.branch.BranchPool;
import org.evosuite.coverage.dataflow.DefUsePool;
import org.evosuite.graphs.GraphPool;
import org.evosuite.graphs.cdg.ControlDependenceGraph;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.*;
import org.objectweb.asm.tree.analysis.SourceValue;
import java.io.Serializable;
import java.util.Set;
/**
* Internal representation of a BytecodeInstruction
*
* Extends ASMWrapper which serves as an interface to the ASM library.
*
* Known super classes are DefUse and Branch which yield specific functionality
* needed to achieve theirs respective coverage criteria
*
* Old: Node of the control flow graph
*
* @author Gordon Fraser, Andre Mis
*/
public class BytecodeInstruction extends ASMWrapper implements Serializable,
Comparable<BytecodeInstruction> {
private static final long serialVersionUID = 3630449183355518857L;
// identification of a byteCode instruction inside EvoSuite
protected ClassLoader classLoader;
protected String className;
protected String methodName;
protected int instructionId;
protected int bytecodeOffset;
// auxiliary information
private int lineNumber = -1;
// experiment: also searching through all CFG nodes in order to determine an
// instruction BasicBlock might be a little to expensive too just to safe
// space for one reference
private BasicBlock basicBlock;
/**
* Generates a ByteCodeInstruction instance that represents a byteCode
* instruction as indicated by the given ASMNode in the given method and
* class
*
* @param className
* a {@link java.lang.String} object.
* @param methodName
* a {@link java.lang.String} object.
* @param instructionId
* a int.
* @param bytecodeOffset
* a int.
* @param asmNode
* a {@link org.objectweb.asm.tree.AbstractInsnNode} object.
*/
public BytecodeInstruction(ClassLoader classLoader, String className,
String methodName, int instructionId, int bytecodeOffset, AbstractInsnNode asmNode) {
if (className == null || methodName == null || asmNode == null)
throw new IllegalArgumentException("null given");
if (instructionId < 0)
throw new IllegalArgumentException(
"expect instructionId to be positive, not " + instructionId);
this.instructionId = instructionId;
this.bytecodeOffset = bytecodeOffset;
this.asmNode = asmNode;
this.classLoader = classLoader;
setClassName(className);
setMethodName(methodName);
}
/**
* Can represent any byteCode instruction
*
* @param wrap
* a {@link org.evosuite.graphs.cfg.BytecodeInstruction} object.
*/
public BytecodeInstruction(BytecodeInstruction wrap) {
this(wrap.classLoader, wrap.className, wrap.methodName, wrap.instructionId,
wrap.bytecodeOffset, wrap.asmNode, wrap.lineNumber, wrap.basicBlock);
this.frame = wrap.frame;
}
/**
* <p>
* Constructor for BytecodeInstruction.
* </p>
*
* @param className
* a {@link java.lang.String} object.
* @param methodName
* a {@link java.lang.String} object.
* @param instructionId
* a int.
* @param bytecodeOffset
* a int.
* @param asmNode
* a {@link org.objectweb.asm.tree.AbstractInsnNode} object.
* @param lineNumber
* a int.
* @param basicBlock
* a {@link org.evosuite.graphs.cfg.BasicBlock} object.
*/
public BytecodeInstruction(ClassLoader classLoader, String className,
String methodName, int instructionId, int bytecodeOffset, AbstractInsnNode asmNode,
int lineNumber, BasicBlock basicBlock) {
this(classLoader, className, methodName, instructionId, bytecodeOffset, asmNode,
lineNumber);
this.basicBlock = basicBlock;
}
/**
* <p>
* Constructor for BytecodeInstruction.
* </p>
*
* @param className
* a {@link java.lang.String} object.
* @param methodName
* a {@link java.lang.String} object.
* @param instructionId
* a int.
* @param bytecodeOffset
* a int.
* @param asmNode
* a {@link org.objectweb.asm.tree.AbstractInsnNode} object.
* @param lineNumber
* a int.
*/
public BytecodeInstruction(ClassLoader classLoader, String className,
String methodName, int instructionId, int bytecodeOffset, AbstractInsnNode asmNode,
int lineNumber) {
this(classLoader, className, methodName, instructionId, bytecodeOffset, asmNode);
if (lineNumber != -1)
setLineNumber(lineNumber);
}
// getter + setter
private void setMethodName(String methodName) {
if (methodName == null)
throw new IllegalArgumentException("null given");
this.methodName = methodName;
}
private void setClassName(String className) {
if (className == null)
throw new IllegalArgumentException("null given");
this.className = className;
}
/**
* <p>
* setCFGFrame
* </p>
*
* @param frame
* a {@link org.evosuite.graphs.cfg.CFGFrame} object.
*/
public void setCFGFrame(CFGFrame frame) {
this.frame = frame;
}
// --- Field Management ---
/** {@inheritDoc} */
@Override
public int getInstructionId() {
return instructionId;
}
/**
* <p>
* getBytecodeOffset
* </p>
*
* @return a int.
*/
public int getBytecodeOffset() {
return bytecodeOffset;
}
/** {@inheritDoc} */
@Override
public String getMethodName() {
return methodName;
}
/**
* <p>
* Getter for the field <code>className</code>.
* </p>
*
* @return a {@link java.lang.String} object.
*/
@Override
public String getClassName() {
return className;
}
/**
* <p>
* getName
* </p>
*
* @return a {@link java.lang.String} object.
*/
public String getName() {
return "BytecodeInstruction " + instructionId + " in " + methodName;
}
/**
* Return's the BasicBlock that contain's this instruction in it's CFG.
*
* If no BasicBlock containing this instruction was created yet, null is
* returned.
*
* @return a {@link org.evosuite.graphs.cfg.BasicBlock} object.
*/
public BasicBlock getBasicBlock() {
if (!hasBasicBlockSet())
retrieveBasicBlock();
return basicBlock;
}
private void retrieveBasicBlock() {
if (basicBlock == null)
basicBlock = getActualCFG().getBlockOf(this);
}
/**
* Once the CFG has been asked for this instruction's BasicBlock it sets
* this instance's internal basicBlock field.
*
* @param block
* a {@link org.evosuite.graphs.cfg.BasicBlock} object.
*/
public void setBasicBlock(BasicBlock block) {
if (block == null)
throw new IllegalArgumentException("null given");
if (!block.getClassName().equals(getClassName())
|| !block.getMethodName().equals(getMethodName()))
throw new IllegalArgumentException(
"expect block to be for the same method and class as this instruction");
if (this.basicBlock != null)
throw new IllegalArgumentException(
"basicBlock already set! not allowed to overwrite");
this.basicBlock = block;
}
/**
* Checks whether this instance's basicBlock has already been set by the CFG
* or
*
* @return a boolean.
*/
public boolean hasBasicBlockSet() {
return basicBlock != null;
}
/** {@inheritDoc} */
@Override
public int getLineNumber() {
if (lineNumber == -1 && isLineNumber())
retrieveLineNumber();
return lineNumber;
}
/**
* <p>
* Setter for the field <code>lineNumber</code>.
* </p>
*
* @param lineNumber
* a int.
*/
public void setLineNumber(int lineNumber) {
if (lineNumber <= 0)
throw new IllegalArgumentException(
"expect lineNumber value to be positive");
if (isLabel())
return;
if (isLineNumber()) {
int asmLine = super.getLineNumber();
// sanity check
if (lineNumber != -1 && asmLine != lineNumber)
throw new IllegalStateException(
"linenumber instruction has lineNumber field set to a value different from instruction linenumber");
this.lineNumber = asmLine;
} else {
this.lineNumber = lineNumber;
}
}
/**
* At first, if this instruction constitutes a line number instruction this
* method tries to retrieve the lineNumber from the underlying asmNode and
* set the lineNumber field to the value given by the asmNode.
*
* This can lead to an IllegalStateException, should the lineNumber field
* have been set to another value previously
*
* After that, if the lineNumber field is still not initialized, this method
* returns false Otherwise it returns true
*
* @return a boolean.
*/
public boolean hasLineNumberSet() {
retrieveLineNumber();
return lineNumber != -1;
}
/**
* If the underlying ASMNode is a LineNumberNode the lineNumber field of
* this instance will be set to the lineNumber contained in that
* LineNumberNode
*
* Should the lineNumber field have been set to a value different from that
* contained in the asmNode, this method throws an IllegalStateExeption
*/
private void retrieveLineNumber() {
if (isLineNumber()) {
int asmLine = super.getLineNumber();
// sanity check
if (this.lineNumber != -1 && asmLine != this.lineNumber)
throw new IllegalStateException(
"lineNumber field was manually set to a value different from the actual lineNumber contained in LineNumberNode");
this.lineNumber = asmLine;
}
}
// --- graph section ---
/**
* Returns the ActualControlFlowGraph of this instructions method
*
* Convenience method. Redirects the call to GraphPool.getActualCFG()
*
* @return a {@link org.evosuite.graphs.cfg.ActualControlFlowGraph} object.
*/
public ActualControlFlowGraph getActualCFG() {
ActualControlFlowGraph myCFG = GraphPool.getInstance(classLoader).getActualCFG(className,
methodName);
if (myCFG == null)
throw new IllegalStateException(
"expect GraphPool to know CFG for every method for which an instruction is known");
return myCFG;
}
/**
* Returns the RawControlFlowGraph of this instructions method
*
* Convenience method. Redirects the call to GraphPool.getRawCFG()
*
* @return a {@link org.evosuite.graphs.cfg.RawControlFlowGraph} object.
*/
public RawControlFlowGraph getRawCFG() {
RawControlFlowGraph myCFG = GraphPool.getInstance(classLoader).getRawCFG(className,
methodName);
if (myCFG == null)
throw new IllegalStateException(
"expect GraphPool to know CFG for every method for which an instruction is known");
return myCFG;
}
/**
* Returns the ControlDependenceGraph of this instructions method
*
* Convenience method. Redirects the call to GraphPool.getCDG()
*
* @return a {@link org.evosuite.graphs.cdg.ControlDependenceGraph} object.
*/
public ControlDependenceGraph getCDG() {
ControlDependenceGraph myCDG = GraphPool.getInstance(classLoader).getCDG(className,
methodName);
if (myCDG == null)
throw new IllegalStateException(
"expect GraphPool to know CDG for every method for which an instruction is known");
return myCDG;
}
// --- CDG-Section ---
/**
* Returns a cfg.Branch object for each branch this instruction is control
* dependent on as determined by the ControlDependenceGraph. If this
* instruction is only dependent on the root branch this method returns an
* empty set
*
* If this instruction is a Branch and it is dependent on itself - which can
* happen in loops for example - the returned set WILL contain this. If you
* do not need the full set in order to avoid loops, call
* getAllControlDependentBranches instead
*
* @return a {@link java.util.Set} object.
*/
public Set<ControlDependency> getControlDependencies() {
BasicBlock myBlock = getBasicBlock();
// return new
// HashSet<ControlDependency>(myBlock.getControlDependencies());
return myBlock.getControlDependencies();
}
/**
* This method returns a random Branch among all Branches this instruction
* is control dependent on
*
* If this instruction is only dependent on the root branch, this method
* returns null
*
* Since EvoSuite was previously unable to detect multiple control
* dependencies for one instruction this method serves as a backwards
* compatibility bridge
*
* @return a {@link org.evosuite.coverage.branch.Branch} object.
*/
public Branch getControlDependentBranch() {
Set<ControlDependency> controlDependentBranches = getControlDependencies();
for (ControlDependency cd : controlDependentBranches)
return cd.getBranch();
return null; // root branch
}
/**
* Returns all branchIds of Branches this instruction is directly control
* dependent on as determined by the ControlDependenceGraph for this
* instruction's method.
*
* If this instruction is control dependent on the root branch the id -1
* will be contained in this set
*
* @return a {@link java.util.Set} object.
*/
public Set<Integer> getControlDependentBranchIds() {
BasicBlock myBlock = getBasicBlock();
return myBlock.getControlDependentBranchIds();
}
/**
* Determines whether or not this instruction is control dependent on the
* root branch of it's method by calling getControlDependentBranchIds() to
* see if the return contains -1.
*
* @return a boolean.
*/
public boolean isRootBranchDependent() {
return getControlDependencies().isEmpty();
}
/**
* This method returns a random branchId among all branchIds this
* instruction is control dependent on.
*
* This method returns -1 if getControlDependentBranch() returns null,
* otherwise that Branch's branchId is returned
*
* Note: The returned branchExpressionValue comes from the same Branch
* getControlDependentBranch() and getControlDependentBranchId() return
*
* Since EvoSuite was previously unable to detect multiple control
* dependencies for one instruction this method serves as a backwards
* compatibility bridge
*
* @return a int.
*/
public int getControlDependentBranchId() {
Branch b = getControlDependentBranch();
if (b == null)
return -1;
return b.getActualBranchId();
}
/**
* This method returns the branchExpressionValue from a random Branch among
* all Branches this instruction is control dependent on.
*
* This method returns true if getControlDependentBranch() returns null,
* otherwise that Branch's branchExpressionValue is returned
*
* Note: The returned branchExpressionValue comes from the same Branch
* getControlDependentBranch() and getControlDependentBranchId() return
*
* Since EvoSuite was previously unable to detect multiple control
* dependencies for one instruction this method serves as a backwards
* compatibility bridge
*
* @return a boolean.
*/
public boolean getControlDependentBranchExpressionValue() {
Branch b = getControlDependentBranch();
return getBranchExpressionValue(b);
}
/**
* <p>
* getBranchExpressionValue
* </p>
*
* @param b
* a {@link org.evosuite.coverage.branch.Branch} object.
* @return a boolean.
*/
public boolean getBranchExpressionValue(Branch b) {
if (!isDirectlyControlDependentOn(b))
throw new IllegalArgumentException(
"this method can only be called for branches that this instruction is directly control dependent on.");
if (b == null)
return true; // root branch special case
return getControlDependency(b).getBranchExpressionValue();
}
/**
* Determines whether this BytecodeInstruction is directly control dependent
* on the given Branch. Meaning within this instruction CDG there is an
* incoming ControlFlowEdge to this instructions BasicBlock holding the
* given Branch as it's branchInstruction.
*
* If the given Branch is null, this method checks whether the this
* instruction is control dependent on the root branch of it's method.
*
* @param branch
* a {@link org.evosuite.coverage.branch.Branch} object.
* @return a boolean.
*/
public boolean isDirectlyControlDependentOn(Branch branch) {
if (branch == null)
return getControlDependentBranchIds().contains(-1);
for (ControlDependency cd : getControlDependencies())
if (cd.getBranch().equals(branch))
return true;
return false;
}
/**
* <p>
* getControlDependency
* </p>
*
* @param branch
* a {@link org.evosuite.coverage.branch.Branch} object.
* @return a {@link org.evosuite.graphs.cfg.ControlDependency} object.
*/
public ControlDependency getControlDependency(Branch branch) {
if (!isDirectlyControlDependentOn(branch))
throw new IllegalArgumentException(
"instruction not directly control dependent on given branch");
for (ControlDependency cd : getControlDependencies())
if (cd.getBranch().equals(branch))
return cd;
throw new IllegalStateException(
"expect getControlDependencies() to contain a CD for each branch that isDirectlyControlDependentOn() returns true on");
}
// /**
// * WARNING: better don't user this method right now TODO
// *
// * Determines whether the CFGVertex is transitively control dependent on
// the
// * given Branch
// *
// * A CFGVertex is transitively control dependent on a given Branch if the
// * Branch and the vertex are in the same method and the vertex is either
// * directly control dependent on the Branch - look at
// * isDirectlyControlDependentOn(Branch) - or the CFGVertex of the control
// * dependent branch of this CFGVertex is transitively control dependent on
// * the given branch.
// *
// */
// public boolean isTransitivelyControlDependentOn(Branch branch) {
// if (!getClassName().equals(branch.getClassName()))
// return false;
// if (!getMethodName().equals(branch.getMethodName()))
// return false;
//
// // TODO: this method does not take into account, that there might be
// // multiple branches this instruction is control dependent on
//
// BytecodeInstruction vertexHolder = this;
// do {
// if (vertexHolder.isDirectlyControlDependentOn(branch))
// return true;
// vertexHolder = vertexHolder.getControlDependentBranch()
// .getInstruction();
// } while (vertexHolder != null);
//
// return false;
// }
// /**
// * WARNING: better don't user this method right now TODO
// *
// * Determines the number of branches that have to be passed in order to
// pass
// * this CFGVertex
// *
// * Used to determine TestFitness difficulty
// */
/**
* <p>
* getCDGDepth
* </p>
*
* @return a int.
*/
public int getCDGDepth() {
int min = Integer.MAX_VALUE;
Set<ControlDependency> dependencies = getControlDependencies();
if (dependencies.isEmpty())
min = 1;
for (ControlDependency dependency : dependencies) {
int depth = getCDG().getControlDependenceDepth(dependency);
if (depth < min)
min = depth;
}
return min;
/*
* // TODO: this method does not take into account, that there might be
* // multiple branches this instruction is control dependent on Branch
* current = getControlDependentBranch(); int r = 1; while (current !=
* null) { r++; current =
* current.getInstruction().getControlDependentBranch(); } return r;
*/
}
// String methods
/**
* <p>
* explain
* </p>
*
* @return a {@link java.lang.String} object.
*/
public String explain() {
if (isBranch()) {
if (BranchPool.getInstance(classLoader).isKnownAsBranch(this)) {
Branch b = BranchPool.getInstance(classLoader).getBranchForInstruction(this);
if (b == null)
throw new IllegalStateException(
"expect BranchPool to be able to return Branches for instructions fullfilling BranchPool.isKnownAsBranch()");
return "Branch " + b.getActualBranchId() + " - "
+ getInstructionType();
}
return "UNKNOWN Branch I" + instructionId + " "
+ getInstructionType() +", jump to "+((JumpInsnNode)asmNode).label.getLabel();
// + " - " + ((JumpInsnNode) asmNode).label.getLabel();
}
return getASMNodeString();
}
/**
* <p>
* getASMNodeString
* </p>
*
* @return a {@link java.lang.String} object.
*/
public String getASMNodeString() {
String type = getType();
String opcode = getInstructionType();
String stack = "";
if (frame == null)
stack = "null";
else
for (int i = 0; i < frame.getStackSize(); i++) {
stack += frame.getStack(i) + ",";
}
if (asmNode instanceof LabelNode) {
return "LABEL " + ((LabelNode) asmNode).getLabel().toString();
} else if (asmNode instanceof FieldInsnNode)
return "Field" + " " + ((FieldInsnNode) asmNode).owner + "."
+ ((FieldInsnNode) asmNode).name + " Type=" + type
+ ", Opcode=" + opcode;
else if (asmNode instanceof FrameNode)
return "Frame" + " " + asmNode.getOpcode() + " Type=" + type
+ ", Opcode=" + opcode;
else if (asmNode instanceof IincInsnNode)
return "IINC " + ((IincInsnNode) asmNode).var + " Type=" + type
+ ", Opcode=" + opcode;
else if (asmNode instanceof InsnNode)
return "" + opcode;
else if (asmNode instanceof IntInsnNode)
return "INT " + ((IntInsnNode) asmNode).operand + " Type=" + type
+ ", Opcode=" + opcode;
else if (asmNode instanceof MethodInsnNode)
return opcode + " " + ((MethodInsnNode) asmNode).owner + "." + ((MethodInsnNode) asmNode).name + ((MethodInsnNode) asmNode).desc;
else if (asmNode instanceof JumpInsnNode)
return "JUMP " + ((JumpInsnNode) asmNode).label.getLabel()
+ " Type=" + type + ", Opcode=" + opcode + ", Stack: "
+ stack + " - Line: " + lineNumber;
else if (asmNode instanceof LdcInsnNode)
return "LDC " + ((LdcInsnNode) asmNode).cst + " Type=" + type; // +
// ", Opcode=";
// + opcode; // cst starts with mutationid if
// this is location of mutation
else if (asmNode instanceof LineNumberNode)
return "LINE " + " " + ((LineNumberNode) asmNode).line;
else if (asmNode instanceof LookupSwitchInsnNode)
return "LookupSwitchInsnNode" + " " + asmNode.getOpcode()
+ " Type=" + type + ", Opcode=" + opcode;
else if (asmNode instanceof MultiANewArrayInsnNode)
return "MULTIANEWARRAY " + " " + asmNode.getOpcode() + " Type="
+ type + ", Opcode=" + opcode;
else if (asmNode instanceof TableSwitchInsnNode)
return "TableSwitchInsnNode" + " " + asmNode.getOpcode() + " Type="
+ type + ", Opcode=" + opcode;
else if (asmNode instanceof TypeInsnNode) {
switch(asmNode.getOpcode()) {
case Opcodes.NEW:
return "NEW " + ((TypeInsnNode) asmNode).desc;
case Opcodes.ANEWARRAY:
return "ANEWARRAY " + ((TypeInsnNode) asmNode).desc;
case Opcodes.CHECKCAST:
return "CHECKCAST " + ((TypeInsnNode) asmNode).desc;
case Opcodes.INSTANCEOF:
return "INSTANCEOF " + ((TypeInsnNode) asmNode).desc;
default:
return "Unknown node" + " Type=" + type + ", Opcode=" + opcode;
}
}
// return "TYPE " + " " + node.getOpcode() + " Type=" + type
// + ", Opcode=" + opcode;
else if (asmNode instanceof VarInsnNode)
return opcode + " " + ((VarInsnNode) asmNode).var;
else
return "Unknown node" + " Type=" + type + ", Opcode=" + opcode;
}
/**
* <p>
* printFrameInformation
* </p>
*/
public void printFrameInformation() {
System.out.println("Frame STACK:");
for (int i = 0; i < frame.getStackSize(); i++) {
SourceValue v = (SourceValue) frame.getStack(i);
System.out.print(" " + i + "(" + v.insns.size() + "): ");
for (Object n : v.insns) {
AbstractInsnNode node = (AbstractInsnNode) n;
BytecodeInstruction ins = BytecodeInstructionPool.getInstance(classLoader).getInstruction(className,
methodName,
node);
System.out.print(ins.toString() + ", ");
}
System.out.println();
}
System.out.println("Frame LOCALS:");
for (int i = 1; i < frame.getLocals(); i++) {
SourceValue v = (SourceValue) frame.getLocal(i);
System.out.print(" " + i + "(" + v.insns.size() + "): ");
for (Object n : v.insns) {
AbstractInsnNode node = (AbstractInsnNode) n;
BytecodeInstruction ins = BytecodeInstructionPool.getInstance(classLoader).getInstruction(className,
methodName,
node);
System.out.print(ins.toString() + ", ");
}
System.out.println();
}
}
// --- Inherited from Object ---
/** {@inheritDoc} */
@Override
public String toString() {
String r = "I" + instructionId;
r += " (" + + bytecodeOffset + ")";
r += " " + explain();
if (hasLineNumberSet() && !isLineNumber())
r += " l" + getLineNumber();
return r;
}
/**
* Convenience method:
*
* If this instruction is known by the BranchPool to be a Branch, you can
* call this method in order to retrieve the corresponding Branch object
* registered within the BranchPool.
*
* Otherwise this method will return null;
*
* @return a {@link org.evosuite.coverage.branch.Branch} object.
*/
public Branch toBranch() {
try {
return BranchPool.getInstance(classLoader).getBranchForInstruction(this);
} catch (Exception e) {
return null;
}
}
/**
* <p>
* proceedsOwnConstructorInvocation
* </p>
*
* @return a boolean.
*/
public boolean proceedsOwnConstructorInvocation() {
RawControlFlowGraph cfg = getRawCFG();
for (BytecodeInstruction other : cfg.vertexSet())
if (other.isConstructorInvocation()
&& other.isMethodCallOnSameObject())
if (getInstructionId() < other.getInstructionId())
return true;
return false;
}
/**
* <p>
* isWithinConstructor
* </p>
*
* @return a boolean.
*/
public boolean isWithinConstructor() {
return getMethodName().startsWith("<init>");
}
/**
* <p>
* isLastInstructionInMethod
* </p>
*
* @return a boolean.
*/
public boolean isLastInstructionInMethod() {
return equals(getRawCFG().getInstructionWithBiggestId());
}
/**
* <p>
* canBeExitPoint
* </p>
*
* @return a boolean.
*/
public boolean canBeExitPoint() {
return canReturnFromMethod() || isLastInstructionInMethod();
}
/**
* Returns the RawCFG of the method called by this instruction
*
* @return a {@link org.evosuite.graphs.cfg.RawControlFlowGraph} object.
*/
public RawControlFlowGraph getCalledCFG() {
if (!isMethodCall())
return null;
return GraphPool.getInstance(classLoader).getRawCFG(getCalledMethodsClass(),
getCalledMethod());
}
/**
* Determines whether this instruction calls a method on its own Object
* ('this')
*
* This is done using the getSourceOfMethodInvocationInstruction() method
* and checking if the return of that method loads this using loadsReferenceToThis()
*
* @return a boolean.
*/
public boolean isMethodCallOnSameObject() {
BytecodeInstruction srcInstruction = getSourceOfMethodInvocationInstruction();
if (srcInstruction == null)
return false;
return srcInstruction.loadsReferenceToThis();
}
/**
* Determines whether this instruction calls a method on a field variable
*
* This is done using the getSourceOfMethodInvocationInstruction() method
* and checking if the return of that method is a field use instruction
*
* @return a boolean.
*/
public boolean isMethodCallOfField() {
if(!this.isMethodCall())
return false;
if (this.isInvokeStatic())
return false;
// If the instruction belongs to static initialization block of the
// class, then the method call cannot be done on a fields.
if (this.methodName.contains("<clinit>"))
return false;
BytecodeInstruction srcInstruction = getSourceOfMethodInvocationInstruction();
if (srcInstruction == null)
return false;
//is a field use? But field uses are also "GETSTATIC"
if (srcInstruction.isFieldNodeUse()) {
//is static? if not, return yes. This control is not necessary in theory, but you never know...
if (srcInstruction.isStaticDefUse()) {
//is static, check if the name of the class that contain the static field is equals to the current class name
//if is equals, return true, otherwise we are in a case where we are calling a field over an external static class
//e.g. System.out
if (srcInstruction.asmNode instanceof FieldInsnNode) {
String classNameField = ((FieldInsnNode) srcInstruction.asmNode).owner;
classNameField = classNameField.replace('/', '.');
if (classNameField.equals(className)) {
return true;
}
}
} else {
return true;
}
}
return false;
}
/**
* Determines the name of the field variable this method call is invoked on
*
* This is done using the getSourceOfMethodInvocationInstruction() method
* and returning its variable name
*
* @return a {@link java.lang.String} object.
*/
@Override
public String getFieldMethodCallName() {
BytecodeInstruction srcInstruction = getSourceOfMethodInvocationInstruction();
if (srcInstruction == null)
return null;
return srcInstruction.getVariableName();
}
/**
* If this is a method call instruction this method will return the
* instruction that loaded the reference of the Object the method is invoked
* onto the stack.
*
* This is done using getSourceOfStackInstruction()
*
* The reference is found on top of the stack minus the number of the called
* methods argument
*/
public BytecodeInstruction getSourceOfMethodInvocationInstruction() {
if (!isMethodCall())
return null;
// the object on which this method is called is on top of the stack
// minus the number of arguments the called method has
return getSourceOfStackInstruction(getCalledMethodsArgumentCount());
}
/**
* If this instruction is an array instruction this method will return the
* BytecodeInstruction that loaded the reference of the array onto the
* stack.
*
* This is done using getSourceOfStackMethod()
*
* The reference is found on top of the stack minus two
*/
public BytecodeInstruction getSourceOfArrayReference() {
if(isArrayStoreInstruction()) {
// when reaching an array store instruction the stack should end in
// <arrayref>,<index>,<value>. so the array reference is on top of the
// stack minus two
return getSourceOfStackInstruction(2);
} else if(isArrayLoadInstruction()) {
// when reaching an array store instruction the stack should end in
// <arrayref>,<index>. so the array reference is on top of the
// stack minus one
return getSourceOfStackInstruction(1);
} else {
return null;
}
}
/**
* This method returns the BytecodeInstruction that loaded the reference
* which is located on top of the stack minus positionFromTop when this
* instruction is executed.
*
* This is done using the CFGFrame created by the SourceInterpreter() of the
* BytecodeAnalyzer via the CFGGenerator
*
* Note that this method may return null. This can happen when aliasing is
* involved. For example for method invocations on objects this can happen
* when you first store the object in a local variable and then call a
* method on that variable
*
* see PairTestClass.sourceCallerTest() for an even worse example.
*
* TODO: this could be done better by following the SourceValues even
* further.
*/
public BytecodeInstruction getSourceOfStackInstruction(int positionFromTop) {
if (frame == null)
throw new IllegalStateException(
"expect each BytecodeInstruction to have its CFGFrame set");
int stackPos = frame.getStackSize() - (1 + positionFromTop);
if (stackPos < 0){
StackTraceElement[] se = new Throwable().getStackTrace();
int t=0;
System.out.println("Stack trace: ");
while(t<se.length){
System.out.println(se[t]);
t++;
}
return null;
}
SourceValue source = (SourceValue) frame.getStack(stackPos);
if (source.insns.size() != 1) {
// we don't know for sure, let's be conservative
return null;
}
Object sourceIns = source.insns.iterator().next();
AbstractInsnNode sourceInstruction = (AbstractInsnNode) sourceIns;
BytecodeInstruction src = BytecodeInstructionPool.getInstance(classLoader).getInstruction(className,
methodName,
sourceInstruction);
return src;
}
public boolean isFieldMethodCallDefinition() {
if (!isMethodCallOfField())
return false;
// before this instruction is categorized in the DefUsePool we do not
// know if
// this instruction calls a pure or impure method, so we just label it
// as both a Use and Definition for now
if (!(DefUsePool.isKnownAsUse(this) && DefUsePool
.isKnownAsFieldMethodCall(this))) {
return true;
}
// once the DefUsePool knows about this instruction we only return true
// if it was
// categorized as a Use
return DefUsePool.isKnownAsDefinition(this);
}
public boolean isFieldMethodCallUse() {
if (!isMethodCallOfField())
return false;
// before this instruction is categorized in the DefUsePool we do not
// know if
// this instruction calls a pure or impure method, so we just label it
// as both a Use and Definition for now
if ((DefUsePool.isKnownAsFieldMethodCall(this) && !DefUsePool.isKnownAsDefinition(this))) {
return true;
}
// once the DefUsePool knows about this instruction we only return true
// if it was
// categorized as a Use
return DefUsePool.isKnownAsUse(this);
}
/**
* <p>
* isCallToPublicMethod
* </p>
*
* @return a boolean.
*/
public boolean isCallToPublicMethod() {
if (!isMethodCall())
return false;
if (getCalledCFG() == null) {
// TODO not sure if I am supposed to throw an Exception at this
// point
return false;
}
return getCalledCFG().isPublicMethod();
}
/**
* <p>
* isCallToStaticMethod
* </p>
*
* @return a boolean.
*/
public boolean isCallToStaticMethod() {
if (!isMethodCall())
return false;
if (getCalledCFG() == null) {
// TODO not sure if I am supposed to throw an Exception at this
// point
return false;
}
return getCalledCFG().isStaticMethod();
}
/**
* <p>
* canBeInstrumented
* </p>
*
* @return a boolean.
*/
public boolean canBeInstrumented() {
if (isWithinConstructor() && proceedsOwnConstructorInvocation()) {
// System.out.println("i cant be instrumented "+toString());
return false;
}
return true;
}
/** {@inheritDoc} */
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((className == null) ? 0 : className.hashCode());
result = prime * result + instructionId;
result = prime * result
+ ((methodName == null) ? 0 : methodName.hashCode());
return result;
}
/** {@inheritDoc} */
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
BytecodeInstruction other = (BytecodeInstruction) obj;
if (className == null) {
if (other.className != null)
return false;
} else if (!className.equals(other.className))
return false;
if (instructionId != other.instructionId)
return false;
if (methodName == null) {
if (other.methodName != null)
return false;
} else if (!methodName.equals(other.methodName))
return false;
return true;
}
// inherited from Object
/*
* (non-Javadoc)
*
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(BytecodeInstruction o) {
return getLineNumber() - o.getLineNumber();
}
}