public FaintVariableAnalysis(Body body) {
Chain<Local> locals = body.getLocals();
allVariables = new CollectionFlowUniverse<Local>(locals);
universalSet = new ArrayPackedSet(allVariables);
for (Local l : locals) universalSet.add(l);
useSetMap = new HashMap<Unit, BoundedFlowSet>();
defSetMap = new HashMap<Unit, BoundedFlowSet>();
UnitGraph graph = new BriefUnitGraph(body);
for (Unit u : graph) {
BoundedFlowSet defSet = new ArrayPackedSet(allVariables);
BoundedFlowSet useSet = new ArrayPackedSet(allVariables);
for (ValueBox v : u.getDefBoxes()) {
// Only do this for locals. We're not going to even try to handle anything
// other than locals.
if (v.getValue() instanceof Local) {
defSet.add(v.getValue());
}
}
for (ValueBox v : u.getUseBoxes()) {
// Only do this for locals. We're not going to even try to handle anything
// other than locals.
if (v.getValue() instanceof Local) {
useSet.add(v.getValue());
}
}
defSetMap.put(u, defSet);
useSetMap.put(u, useSet);
}
}
/**
* Constructs a graph for the units found in the provided Body instance. Each node in the graph
* corresponds to a unit. The edges are derived from the control flow.
*
* @param body The underlying body we want to make a graph for.
* @param addExceptionEdges If true then the control flow edges associated with exceptions are
* added.
* @param dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock This was added for Dava. If true,
* edges are not added from statement before area of protection to catch. If false, edges ARE
* added. For Dava, it should be true. For flow analyses, it should be false.
* @param Hierarchy Using class hierarchy analysis to find the run method of started thread
* @param PointsToAnalysis Using point to analysis (SPARK package) to improve the precision of
* results
*/
public PegGraph(
CallGraph callGraph,
Hierarchy hierarchy,
PAG pag,
Set methodsNeedingInlining,
Set allocNodes,
List<List> inlineSites,
Map<SootMethod, String> synchObj,
Set multiRunAllocNodes,
Map<AllocNode, String> allocNodeToObj,
Body unitBody,
String threadName,
SootMethod sm,
boolean addExceEdge,
boolean dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock) {
this.allocNodeToObj = allocNodeToObj;
this.multiRunAllocNodes = multiRunAllocNodes;
this.synchObj = synchObj;
this.inlineSites = inlineSites;
this.allocNodes = allocNodes;
this.methodsNeedingInlining = methodsNeedingInlining;
logFile = new File("log.txt");
try {
fileWriter = new FileWriter(logFile);
} catch (IOException io) {
System.err.println("Errors occur during create FileWriter !");
// throw io;
}
body = unitBody;
synch = new HashSet<List>();
exceHandlers = new HashSet<Unit>();
needInlining = true;
monitorObjs = new HashSet<Object>();
startToBeginNodes = new HashMap();
unitChain = body.getUnits();
int size = unitChain.size();
// initial unitToSuccs, unitToPreds, unitToPegMap, and startToThread
unitToSuccs = new HashMap(size * 2 + 1, 0.7f);
unitToPreds = new HashMap(size * 2 + 1, 0.7f);
// unitToPegMap is the map of a chain to its corresponding (cfg node --> peg node ) map.
unitToPegMap = new HashMap(size * 2 + 1, 0.7f);
startToThread = new HashMap(size * 2 + 1, 0.7f);
startToAllocNodes = new HashMap(size * 2 + 1, 0.7f);
waitingNodes = new HashMap<String, FlowSet>(size * 2 + 1, 0.7f);
joinStmtToThread = new HashMap<JPegStmt, Chain>();
threadNo = new HashMap();
threadNameToStart = new HashMap();
this.allocNodeToObj = new HashMap<AllocNode, String>(size * 2 + 1, 0.7f);
allocNodeToThread = new HashMap<AllocNode, PegChain>(size * 2 + 1, 0.7f);
notifyAll = new HashMap<String, Set<JPegStmt>>(size * 2 + 1, 0.7f);
methodsNeedingInlining = new HashSet();
allNodes = new ArraySparseSet();
canNotBeCompacted = new HashSet();
threadAllocSites = new HashSet();
specialJoin = new HashSet<JPegStmt>();
// if(Main.isVerbose)
// System.out.println(" Constructing PegGraph...");
// if(Main.isProfilingOptimization)
// Main.graphTimer.start();
// make a peg for debug
/*
mainPegChain = new HashChain();
specialTreatment1();
*/
// end make a peg
UnitGraph mainUnitGraph = new CompleteUnitGraph(body);
// mainPegChain = new HashChain();
mainPegChain =
new PegChain(
callGraph,
hierarchy,
pag,
threadAllocSites,
methodsNeedingInlining,
allocNodes,
inlineSites,
synchObj,
multiRunAllocNodes,
allocNodeToObj,
body,
sm,
threadName,
true,
this);
// testPegChain();
// System.out.println("finish building chain");
// testStartToThread();
// buildSuccessor(mainUnitGraph, mainPegChain,addExceptionEdges);
// buildSuccessorForExtendingMethod(mainPegChain);
// testSet(exceHandlers, "exceHandlers");
buildSuccessor(mainPegChain);
// System.out.println("finish building successors");
// unmodifiableSuccs(mainPegChain);
// testUnitToSucc );
buildPredecessor(mainPegChain);
// System.out.println("finish building predcessors");
// unmodifiablePreds(mainPegChain);
// testSynch();
addMonitorStmt();
addTag();
// System.out.println(this.toString());
buildHeadsAndTails();
// testIterator();
// testWaitingNodes();
// System.out.println("finish building heads and tails");
// testSet(canNotBeCompacted, "canNotBeCompacted");
// computeEdgeAndThreadNo();
// testExtendingPoints();
// testUnitToSucc();
// testPegChain();
/* if (print) {
PegToDotFile printer1 = new PegToDotFile(this, false, sm.getName());
}
*/
try {
fileWriter.flush();
fileWriter.close();
} catch (IOException io) {
System.err.println("Errors occur during close file " + logFile.getName());
// throw io;
}
// System.out.println("==threadAllocaSits==\n"+threadAllocSites.toString());
}
