/**
* Traverse the statements in the given body, looking for aggregation possibilities; that is,
* given a def d and a use u, d has no other uses, u has no other defs, collapse d and u.
*
* <p>option: only-stack-locals; if this is true, only aggregate variables starting with $
*/
protected void internalTransform(Body b, String phaseName, Map<String, String> options) {
StmtBody body = (StmtBody) b;
boolean onlyStackVars = PhaseOptions.getBoolean(options, "only-stack-locals");
int aggregateCount = 1;
if (Options.v().time()) Timers.v().aggregationTimer.start();
boolean changed = false;
Map<ValueBox, Zone> boxToZone =
new HashMap<ValueBox, Zone>(body.getUnits().size() * 2 + 1, 0.7f);
// Determine the zone of every box
{
Zonation zonation = new Zonation(body);
for (Unit u : body.getUnits()) {
Zone zone = zonation.getZoneOf(u);
for (ValueBox box : u.getUseBoxes()) {
boxToZone.put(box, zone);
}
for (ValueBox box : u.getDefBoxes()) {
boxToZone.put(box, zone);
}
}
}
do {
if (Options.v().verbose())
G.v()
.out
.println(
"["
+ body.getMethod().getName()
+ "] Aggregating iteration "
+ aggregateCount
+ "...");
// body.printTo(new java.io.PrintWriter(G.v().out, true));
changed = internalAggregate(body, boxToZone, onlyStackVars);
aggregateCount++;
} while (changed);
if (Options.v().time()) Timers.v().aggregationTimer.end();
}
/**
* given a DelayabilityAnalysis and the computations of each unit, calculates the latest
* computation-point for each expression.<br>
* the <code>equivRhsMap</code> could be calculated on the fly, but it is <b>very</b> likely that
* it already exists (as similar maps are used for calculating Earliestness, Delayed,...<br>
* the shared set allows more efficient set-operations, when they the computation is merged with
* other analyses/computations.
*
* @param dg a ExceptionalUnitGraph
* @param delayed the delayability-analysis of the same graph.
* @param equivRhsMap all computations of the graph
* @param set the shared flowSet
*/
public LatestComputation(
UnitGraph unitGraph, DelayabilityAnalysis delayed, Map equivRhsMap, BoundedFlowSet set) {
unitToLatest = new HashMap<Unit, FlowSet>(unitGraph.size() + 1, 0.7f);
Iterator unitIt = unitGraph.iterator();
while (unitIt.hasNext()) {
/* create a new Earliest-list for each unit */
Unit currentUnit = (Unit) unitIt.next();
/* basically the latest-set is:
* (delayed) INTERSECT (comp UNION (UNION_successors ~Delayed)) =
* (delayed) MINUS ((INTERSECTION_successors Delayed) MINUS comp).
*/
FlowSet delaySet = (FlowSet) delayed.getFlowBefore(currentUnit);
/* Calculate (INTERSECTION_successors Delayed) */
FlowSet succCompSet = (FlowSet) set.topSet();
List succList = unitGraph.getSuccsOf(currentUnit);
Iterator succIt = succList.iterator();
while (succIt.hasNext()) {
Unit successor = (Unit) succIt.next();
succCompSet.intersection((FlowSet) delayed.getFlowBefore(successor), succCompSet);
}
/* remove the computation of this set: succCompSet is then:
* ((INTERSECTION_successors Delayed) MINUS comp) */
if (equivRhsMap.get(currentUnit) != null) succCompSet.remove(equivRhsMap.get(currentUnit));
/* make the difference: */
FlowSet latest = (FlowSet) delaySet.emptySet();
delaySet.difference(succCompSet, latest);
unitToLatest.put(currentUnit, latest);
}
}
/** Prints the given <code>JimpleBody</code> to the specified <code>PrintWriter</code>. */
private void printLocalsInBody(Body body, UnitPrinter up) {
// Print out local variables
{
Map typeToLocals = new DeterministicHashMap(body.getLocalCount() * 2 + 1, 0.7f);
// Collect locals
{
Iterator localIt = body.getLocals().iterator();
while (localIt.hasNext()) {
Local local = (Local) localIt.next();
List localList;
Type t = local.getType();
if (typeToLocals.containsKey(t)) localList = (List) typeToLocals.get(t);
else {
localList = new ArrayList();
typeToLocals.put(t, localList);
}
localList.add(local);
}
}
// Print locals
{
Iterator typeIt = typeToLocals.keySet().iterator();
while (typeIt.hasNext()) {
Type type = (Type) typeIt.next();
List localList = (List) typeToLocals.get(type);
Object[] locals = localList.toArray();
up.type(type);
up.literal(" ");
for (int k = 0; k < locals.length; k++) {
if (k != 0) up.literal(", ");
up.local((Local) locals[k]);
}
up.literal(";");
up.newline();
}
}
if (!typeToLocals.isEmpty()) {
up.newline();
}
}
}
/**
* Computes the analysis given a UnitGraph computed from a method body. It is recommended that a
* ExceptionalUnitGraph (or similar) be provided for correct results in the case of exceptional
* control flow.
*
* @param g a graph on which to compute the analysis.
* @see ExceptionalUnitGraph
*/
public SimpleLiveLocals(UnitGraph graph) {
if (Options.v().time()) Timers.v().liveTimer.start();
if (Options.v().verbose())
G.v()
.out
.println(
"["
+ graph.getBody().getMethod().getName()
+ "] Constructing SimpleLiveLocals...");
SimpleLiveLocalsAnalysis analysis = new SimpleLiveLocalsAnalysis(graph);
if (Options.v().time()) Timers.v().livePostTimer.start();
// Build unitToLocals map
{
unitToLocalsAfter = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f);
unitToLocalsBefore = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f);
Iterator unitIt = graph.iterator();
while (unitIt.hasNext()) {
Unit s = (Unit) unitIt.next();
FlowSet set = (FlowSet) analysis.getFlowBefore(s);
unitToLocalsBefore.put(s, Collections.unmodifiableList(set.toList()));
set = (FlowSet) analysis.getFlowAfter(s);
unitToLocalsAfter.put(s, Collections.unmodifiableList(set.toList()));
}
}
if (Options.v().time()) Timers.v().livePostTimer.end();
if (Options.v().time()) Timers.v().liveTimer.end();
}
SimpleLiveLocalsAnalysis(UnitGraph g) {
super(g);
if (Options.v().time()) Timers.v().liveSetupTimer.start();
emptySet = new ArraySparseSet();
// Create kill sets.
{
unitToKillSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f);
Iterator unitIt = g.iterator();
while (unitIt.hasNext()) {
Unit s = (Unit) unitIt.next();
FlowSet killSet = emptySet.clone();
Iterator boxIt = s.getDefBoxes().iterator();
while (boxIt.hasNext()) {
ValueBox box = (ValueBox) boxIt.next();
if (box.getValue() instanceof Local) killSet.add(box.getValue(), killSet);
}
unitToKillSet.put(s, killSet);
}
}
// Create generate sets
{
unitToGenerateSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f);
Iterator unitIt = g.iterator();
while (unitIt.hasNext()) {
Unit s = (Unit) unitIt.next();
FlowSet genSet = emptySet.clone();
Iterator boxIt = s.getUseBoxes().iterator();
while (boxIt.hasNext()) {
ValueBox box = (ValueBox) boxIt.next();
if (box.getValue() instanceof Local) genSet.add(box.getValue(), genSet);
}
unitToGenerateSet.put(s, genSet);
}
}
if (Options.v().time()) Timers.v().liveSetupTimer.end();
if (Options.v().time()) Timers.v().liveAnalysisTimer.start();
doAnalysis();
if (Options.v().time()) Timers.v().liveAnalysisTimer.end();
}
/**
* Parse the command line arguments specific to CFGViewer, and convert them into phase options for
* jtp.printcfg.
*
* @return an array of arguments to pass on to Soot.Main.main().
*/
private String[] parse_options(String[] args) {
List<String> sootArgs = new ArrayList<String>(args.length);
for (int i = 0, n = args.length; i < n; i++) {
if (args[i].equals("--alt-classpath") || args[i].equals("--alt-class-path")) {
sootArgs.add("-p");
sootArgs.add(phaseFullname);
sootArgs.add(altClassPathOptionName + ':' + args[++i]);
} else if (args[i].startsWith("--graph=")) {
sootArgs.add("-p");
sootArgs.add(phaseFullname);
sootArgs.add(graphTypeOptionName + ':' + args[i].substring("--graph=".length()));
} else if (args[i].startsWith("--ir=")) {
sootArgs.add("-p");
sootArgs.add(phaseFullname);
sootArgs.add(irOptionName + ':' + args[i].substring("--ir=".length()));
} else if (args[i].equals("--brief")) {
sootArgs.add("-p");
sootArgs.add(phaseFullname);
sootArgs.add(briefLabelOptionName + ":true");
} else if (args[i].equals("--multipages")) {
sootArgs.add("-p");
sootArgs.add(phaseFullname);
sootArgs.add(multipageOptionName + ":true");
} else if (args[i].equals("--help")) {
return new String[0]; // This is a cheesy method to inveigle
// our caller into printing the help
// and exiting.
} else if (args[i].equals("--soot-class-path")
|| args[i].equals("-soot-class-path")
|| args[i].equals("--soot-classpath")
|| args[i].equals("-soot-classpath")
|| args[i].equals("--process-dir")
|| args[i].equals("-process-dir")
|| args[i].equals("--android-jars")
|| args[i].equals("-android-jars")
|| args[i].equals("--force-android-jar")
|| args[i].equals("-force-android-jar")) {
// Pass classpaths without treating ":" as a method specifier.
sootArgs.add(args[i]);
sootArgs.add(args[++i]);
} else if (args[i].equals("-p")
|| args[i].equals("--phase-option")
|| args[i].equals("-phase-option")) {
// Pass phase options without treating ":" as a method
// specifier.
sootArgs.add(args[i]);
sootArgs.add(args[++i]);
sootArgs.add(args[++i]);
} else {
int smpos = args[i].indexOf(':');
if (smpos == -1) {
sootArgs.add(args[i]);
} else {
String clsname = args[i].substring(0, smpos);
sootArgs.add(clsname);
String methname = args[i].substring(smpos + 1);
if (methodsToPrint == null) {
methodsToPrint = new HashMap<String, String>();
}
methodsToPrint.put(methname, clsname);
}
}
}
String[] sootArgsArray = new String[sootArgs.size()];
return (String[]) sootArgs.toArray(sootArgsArray);
}
