/**
* 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);
}
}
