@Override
protected void flowThrough(Object in, Object node, Object out) {
// perform flow from in to out, through node
FlowSet inSet = (FlowSet) in, outSet = (FlowSet) out;
Unit unit = (Unit) node;
// System.out.println(inSet);
// System.out.println("=== " + unit);
// copy inSet to outSet
inSet.copy(outSet);
if (unit instanceof Stmt) {
Stmt s = (Stmt) unit;
if (exactProceedSet.contains(s)) {
// exact proceed
outSet.add(EXACT);
outSet.remove(NONE);
outSet.remove(NON_EXACT);
} else if (nonExactProceedSet.contains(s)) {
// non-exact proceed
if (!inSet.contains(EXACT)) {
outSet.add(NON_EXACT);
outSet.remove(NONE);
}
} else {
// no proceed
if (!inSet.contains(NON_EXACT) && !inSet.contains(EXACT)) outSet.add(NONE);
}
}
// System.out.println(outSet);
}
public boolean equals(Object o) {
if (!(o instanceof FlowSet)) return false;
FlowSet other = (FlowSet) o;
if (size() != other.size()) return false;
Iterator it = toList().iterator();
while (it.hasNext()) if (!other.contains(it.next())) return false;
return true;
}
public void difference(FlowSet other, FlowSet dest) {
if (dest == this && dest == other) {
dest.clear();
return;
}
Iterator it = this.toList().iterator();
FlowSet flowSet = (other == dest) ? (FlowSet) other.clone() : other;
dest.clear(); // now safe, since we have copies of this & other
while (it.hasNext()) {
Object o = it.next();
if (!flowSet.contains(o)) dest.add(o);
}
}
private boolean removeBeginNode() {
List heads = getHeads();
if (heads.size() != 1) {
// System.out.println("heads: "+heads);
// System.out.println("Error: the size of heads is not equal to 1!");
return false;
// System.exit(1);
} else {
JPegStmt head = (JPegStmt) heads.get(0);
// System.out.println("test head: "+head);
if (!head.getName().equals("begin")) {
System.err.println("Error: the head is not begin node!");
System.exit(1);
}
// remove begin node from heads list
heads.remove(0);
// set the preds list of the succs of head to a new list and put succs of head into heads
Iterator succOfHeadIt = getSuccsOf(head).iterator();
while (succOfHeadIt.hasNext()) {
JPegStmt succOfHead = (JPegStmt) succOfHeadIt.next();
unitToPreds.put(succOfHead, new ArrayList());
// put succs of head into heads
heads.add(succOfHead);
}
// remove begin node from inlinee Peg
if (!mainPegChain.remove(head)) {
System.err.println("fail to remove begin node in from mainPegChain!");
System.exit(1);
}
if (!allNodes.contains(head)) {
System.err.println("fail to find begin node in FlowSet allNodes!");
System.exit(1);
} else {
allNodes.remove(head);
}
// remove begin node from unitToSuccs
if (unitToSuccs.containsKey(head)) {
unitToSuccs.remove(head);
}
}
return true;
}
public void intersection(FlowSet other, FlowSet dest) {
if (dest == this && dest == other) return;
List elements = null;
FlowSet flowSet = null;
if (dest == this) {
/* makes automaticly a copy of <code>this</code>, as it will be cleared */
elements = toList();
flowSet = other;
} else {
/* makes a copy o <code>other</code>, as it might be cleared */
elements = other.toList();
flowSet = this;
}
dest.clear();
Iterator it = elements.iterator();
while (it.hasNext()) {
Object o = it.next();
if (flowSet.contains(o)) dest.add(o);
}
}
public boolean addPeg(PegGraph pg, Chain chain) {
if (!pg.removeBeginNode()) return false;
// System.out.println("adding one peg into another");
// System.out.println("after removeBeginNode===");
// pg.testPegChain();
// System.out.println(pg);
// put every node of peg into this
Iterator mainIt = pg.mainIterator();
while (mainIt.hasNext()) {
JPegStmt s = (JPegStmt) mainIt.next();
// System.out.println("add to mainPegChain: "+s);
mainPegChain.addLast(s);
// if (chain.contains(s)){
// System.err.println("error! chain contains: "+s);
// System.exit(1);
// }
// else
// chain.addLast(s);
}
Iterator it = pg.iterator();
while (it.hasNext()) {
JPegStmt s = (JPegStmt) it.next();
// System.out.println("add to allNodes: "+s);
if (allNodes.contains(s)) {
System.err.println("error! allNodes contains: " + s);
System.exit(1);
} else allNodes.add(s);
}
// testPegChain();
// testIterator();
unitToSuccs.putAll(pg.getUnitToSuccs());
unitToPreds.putAll(pg.getUnitToPreds());
// testUnitToSucc();
// testUnitToPred();
// buildMaps(pg); // RLH
return true;
}
private Map<Pair<Unit, Set<String>>, Set<Unit>> createProvidesConfigMap(
Collection<Unit> unitsInSelection, LiftedReachingDefinitions reachingDefinitions, Body body) {
Map<Pair<Unit, Set<String>>, Set<Unit>> unitConfigurationMap =
new HashMap<Pair<Unit, Set<String>>, Set<Unit>>();
for (Unit unitFromSelection : unitsInSelection) {
if (unitFromSelection instanceof DefinitionStmt) {
/*
* exclude definitions when it's $temp on the leftOp.
*/
DefinitionStmt definition = (DefinitionStmt) unitFromSelection;
Local leftOp = (Local) definition.getLeftOp();
if (leftOp.getName().charAt(0) == '$') {
continue;
}
System.out.println("Definition:" + definition);
// for every unit in the body...
Iterator<Unit> iterator = body.getUnits().snapshotIterator();
while (iterator.hasNext()) {
Unit nextUnit = iterator.next();
LiftedFlowSet<Collection<Set<Object>>> liftedFlowAfter =
reachingDefinitions.getFlowAfter(nextUnit);
Set<String>[] configurations = liftedFlowAfter.getConfigurations();
FlowSet[] lattices = liftedFlowAfter.getLattices();
// and for every configuration...
for (int configurationIndex = 0;
configurationIndex < configurations.length;
configurationIndex++) {
FlowSet flowSet = lattices[configurationIndex];
Set<String> currConfiguration = configurations[configurationIndex];
FeatureTag nextUnitTag = (FeatureTag) nextUnit.getTag("FeatureTag");
// if the unit belongs to the current configuration...
if (nextUnitTag.belongsToConfiguration(currConfiguration)) {
// if the definition reaches this unit...
if (flowSet.contains(definition)) {
List<ValueBox> useBoxes = nextUnit.getUseBoxes();
for (ValueBox vbox : useBoxes) {
/*
* and the definition is used, add to the
* map...
*/
if (vbox.getValue().equivTo(leftOp)) {
Pair<Unit, Set<String>> currentPair =
new Pair<Unit, Set<String>>(definition, currConfiguration);
Set<Unit> unitConfigurationReachesSet = unitConfigurationMap.get(currentPair);
if (unitConfigurationReachesSet == null) {
unitConfigurationReachesSet = new HashSet<Unit>();
unitConfigurationReachesSet.add(nextUnit);
unitConfigurationMap.put(currentPair, unitConfigurationReachesSet);
} else {
unitConfigurationReachesSet.add(nextUnit);
}
}
}
}
}
}
}
}
}
return unitConfigurationMap;
}
protected void buildSuccsForInlining(JPegStmt stmt, Chain chain, PegGraph inlinee) {
// System.out.println("entering buildSuccsForInlining...");
Tag tag = (Tag) stmt.getTags().get(0);
// System.out.println("stmt is: "+tag+" "+stmt);
/*connect heads of inlinee with the preds of invokeStmt and
* delete stmt from the succs list from the preds
*/
Iterator predIt = getPredsOf(stmt).iterator();
// System.out.println("preds list: "+getPredsOf(stmt));
// System.out.println("preds size: "+getPredsOf(stmt).size());
Iterator headsIt = inlinee.getHeads().iterator();
{
// System.out.println("heads: "+inlinee.getHeads());
while (predIt.hasNext()) {
JPegStmt pred = (JPegStmt) predIt.next();
// System.out.println("pred: "+pred);
List succList = (List) getSuccsOf(pred);
// System.out.println("succList of pred: "+succList);
int pos = succList.indexOf(stmt);
// System.out.println("remove : "+stmt + " from succList: \n"+succList+ "\n of pred" );
// remove invokeStmt
succList.remove(pos);
while (headsIt.hasNext()) {
succList.add(headsIt.next());
}
unitToSuccs.put(pred, succList);
}
{
while (headsIt.hasNext()) {
Object head = headsIt.next();
List predsOfHeads = new ArrayList();
predsOfHeads.addAll(getPredsOf(head));
unitToPreds.put(head, predsOfHeads);
}
}
/*
{
predIt = getPredsOf(stmt).iterator();
while (predIt.hasNext()){
JPegStmt s = (JPegStmt)predIt.next();
if (unitToSuccs.containsKey(s)){
Iterator succIt = ((List) unitToSuccs.get(s)).iterator();
while(succIt.hasNext()){
//Object successor = succIt.next();
JPegStmt successor = (JPegStmt)succIt.next();
List predList = (List) unitToPreds.get(successor);
if (predList != null) {
try {
predList.add(s);
} catch(NullPointerException e) {
System.out.println(s + "successor: " + successor);
throw e;
}
}
}
}
}
}*/
}
/*connect tails of inlinee with the succ of invokeStmt and
* delete stmt from the
*/
Iterator tailsIt = inlinee.getTails().iterator();
{
// System.out.println("tails: "+inlinee.getTails());
while (tailsIt.hasNext()) {
Iterator succIt = getSuccsOf(stmt).iterator();
JPegStmt tail = (JPegStmt) tailsIt.next();
List succList = null;
if (unitToSuccs.containsKey(tail)) {
// System.out.println("error: unitToSucc containsKey: "+tail);
succList = (List) getSuccsOf(tail);
// System.out.println("succList: "+succList);
} else {
succList = new ArrayList();
}
while (succIt.hasNext()) {
JPegStmt succ = (JPegStmt) succIt.next();
succList.add(succ);
// System.out.println("succ: "+succ);
// remove stmt from the preds list of the succs of itself.
List predListOfSucc = getPredsOf(succ);
if (predListOfSucc == null) {
System.err.println("Error: predListOfSucc is null!");
System.exit(1);
} else {
if (predListOfSucc.size() != 0) {
int pos = predListOfSucc.indexOf(stmt);
if (pos > 0 || pos == 0) {
// System.out.println("remove stmt: "+stmt+" from the preds list"+predListOfSucc+"
// of the succ");
predListOfSucc.remove(pos);
}
// System.out.println("remove(from PRED): ");
}
}
unitToPreds.put(succ, predListOfSucc);
}
unitToSuccs.put(tail, succList);
// System.out.println("put: "+tail);
// System.out.println("succList: "+succList+ "into unitToSucc");
}
}
// add Nov 1
{
tailsIt = inlinee.getTails().iterator();
while (tailsIt.hasNext()) {
JPegStmt s = (JPegStmt) tailsIt.next();
if (unitToSuccs.containsKey(s)) {
Iterator succIt = unitToSuccs.get(s).iterator();
while (succIt.hasNext()) {
// Object successor = succIt.next();
JPegStmt successor = (JPegStmt) succIt.next();
List<JPegStmt> predList = unitToPreds.get(successor);
if (predList != null && !predList.contains(s)) {
try {
predList.add(s);
/*
Tag tag = (Tag)successor.getTags().get(0);
System.out.println("add "+s+" to predlist of "+tag+" "+successor);
*/
} catch (NullPointerException e) {
System.out.println(s + "successor: " + successor);
throw e;
}
}
}
}
}
}
// end add Nov 1
// System.out.println("stmt: "+stmt);
// remove stmt from allNodes and mainPegChain
// System.out.println("mainPegChain contains stmt: "+mainPegChain.contains(stmt));
// testPegChain();
if (!allNodes.contains(stmt)) {
System.err.println("fail to find begin node in allNodes!");
System.exit(1);
} else {
allNodes.remove(stmt);
// System.out.println("remove from allNode: "+stmt);
}
if (!chain.contains(stmt)) {
System.err.println("Error! Chain does not contains stmt (extending point)!");
System.exit(1);
} else {
if (!chain.remove(stmt)) {
System.err.println("fail to remove invoke stmt in from Chain!");
System.exit(1);
}
}
/*
if (!mainPegChain.contains(stmt)){
boolean find = false;
//System.out.println("main chain does not contain AFTER");
Set maps = startToThread.entrySet();
for(Iterator iter=maps.iterator(); iter.hasNext();){
Map.Entry entry = (Map.Entry)iter.next();
Object startNode = entry.getKey();
Iterator runIt = ((List)entry.getValue()).iterator();
while (runIt.hasNext()){
Chain chain=(Chain)runIt.next();
if (chain.contains(stmt)) {
find = true;
if (!chain.remove(stmt)){
System.err.println("fail to remove begin node in from mainPegChain!");
System.exit(1);
}
break;
}
}
if (find == false){
System.err.println("fail to find stmt: "+stmt+" in chains!");
System.exit(1);
}
}
//this.toString();
}
else{
if (!mainPegChain.remove(stmt)) {
System.err.println("fail to remove begin node in from mainPegChain!");
System.exit(1);
}
else{
// System.out.println("remove(from mainchain): "+stmt);
}
}
*/
// remove stmt from unitToSuccs and unitToPreds
if (unitToSuccs.containsKey(stmt)) {
unitToSuccs.remove(stmt);
}
if (unitToPreds.containsKey(stmt)) {
unitToPreds.remove(stmt);
}
}
