[llvm-commits] CVS: reopt/lib/LightWtProfiling/SLI.cpp

Brian Gaeke gaeke at cs.uiuc.edu
Mon Oct 6 12:58:02 PDT 2003


Changes in directory reopt/lib/LightWtProfiling:

SLI.cpp updated: 1.6 -> 1.7

---
Log message:

Qualify many `namespace std' names with std::, to eventually get rid
 of `using namespace std' in this file.
Use `succ_iterator' instead of `BasicBlock::succ_iterator'.
When checking an edge's color, it's okay to compare == WHITE instead
 of != BLACK && != GREY.
Remove some commented-out code.
Transform if (...) assert(0) and if (...) { ... } else assert (0)
 appropriately.



---
Diffs of the changes:

Index: reopt/lib/LightWtProfiling/SLI.cpp
diff -u reopt/lib/LightWtProfiling/SLI.cpp:1.6 reopt/lib/LightWtProfiling/SLI.cpp:1.7
--- reopt/lib/LightWtProfiling/SLI.cpp:1.6	Sat Sep 13 16:12:11 2003
+++ reopt/lib/LightWtProfiling/SLI.cpp	Mon Oct  6 12:56:52 2003
@@ -30,20 +30,19 @@
 
 void doInlining(uint64_t addr1, vector<Function *> &stack, VirtualMem *vm);
 
-void doBackEdgeDFS(BasicBlock *node, map<BasicBlock*, BasicBlock *> &backedges,
-		   map<BasicBlock *, Color> &color){
+void doBackEdgeDFS(BasicBlock *node,
+                   std::map<BasicBlock*, BasicBlock *> &backedges,
+                   std::map<BasicBlock *, Color> &color) {
   color[node] = GREY;
-  for(BasicBlock::succ_iterator s=succ_begin(node), se=succ_end(node); 
-      s!=se; ++s){
-    if(color[*s] == GREY){
-      //backedge node->*s
+  for(succ_iterator si=succ_begin(node), se=succ_end(node); si!=se; ++si){
+    if (color[*si] == GREY) {
+      //backedge node->*si
       assert(backedges.find(node) == backedges.end() && 
 	     "Multiple backedges starting at same basic block");
-      backedges[node] = *s;
-    }
-    else if(color[*s] != BLACK){
-      //must be white
-      doBackEdgeDFS(*s, backedges, color);
+      backedges[node] = *si;
+    } else if (color[*si] != BLACK) {
+      assert(color[*si] == WHITE);
+      doBackEdgeDFS(*si, backedges, color);
     }
   }
   color[node] = BLACK;
@@ -56,20 +55,17 @@
 }
 
 void doForwardDFS(BasicBlock *node,BasicBlock *end, 
-		  map<BasicBlock*, BasicBlock *> &backEdges, 
-		  map<BasicBlock *, unsigned long> &forward, 
-		  map<BasicBlock *, Color> &color){
+		  std::map<BasicBlock *, BasicBlock *> &backEdges, 
+		  std::map<BasicBlock *, unsigned long> &forward, 
+		  std::map<BasicBlock *, Color> &color){
   color[node] = GREY;
-  //std::cerr<<"Forward--------------\n";
-  //std::cerr<<node;
   forward[node] = 1;
   if(node != end){
-   for(BasicBlock::succ_iterator s=succ_begin(node), se=succ_end(node); 
-      s!=se; ++s){
+   for(succ_iterator s=succ_begin(node), se=succ_end(node); s!=se; ++s){
      //if node -> *s is a backedge, neglect
      if(backEdges[node] == *s)
        continue;
-     if(color[*s] != GREY && color[*s] != BLACK){
+     if(color[*s] == WHITE) {
        doForwardDFS(*s, end, backEdges, forward, color);
      }
    }
@@ -78,33 +74,27 @@
 }
 
 void getForward(BasicBlock *root, BasicBlock *end, 
-		map<BasicBlock*, BasicBlock *> &backEdges,
-		map<BasicBlock *, unsigned long> &forward){
+		std::map<BasicBlock*, BasicBlock *> &backEdges,
+		std::map<BasicBlock *, unsigned long> &forward){
   //do DFS, avoid backedges, don't go beyond end
-  map<BasicBlock *, Color> color;
+  std::map<BasicBlock *, Color> color;
   doForwardDFS(root, end, backEdges, forward, color);
 }
 
 void doBackwardDFS(BasicBlock *node, BasicBlock *start,
-		   map<BasicBlock*, BasicBlock *> &backEdges,
-		   map<BasicBlock *, unsigned long> &forward,
-		   map<BasicBlock *, unsigned long> &backward,
-		   map<BasicBlock *, Color> &color){
+		   std::map<BasicBlock *, BasicBlock *> &backEdges,
+		   std::map<BasicBlock *, unsigned long> &forward,
+		   std::map<BasicBlock *, unsigned long> &backward,
+		   std::map<BasicBlock *, Color> &color){
   color[node] = GREY;
   backward[node] = 1;
-  //std::cerr<<"Backward----------\n";
-  //std::cerr<<node;
   if(node != start){
-    for(BasicBlock::pred_iterator p=pred_begin(node), pe=pred_end(node); 
-	p!=pe; ++p){
+    for(pred_iterator p=pred_begin(node), pe=pred_end(node); p!=pe; ++p){
       if(forward[*p]){
-        //std::cerr<<"Color: "<<color[*p]<<"\n";
-        //std::cerr<<*p;
 	if(backEdges[*p] == node){
 	  continue;
-          //std::cerr<<"Has BE----------\n"; 
         }
-	if(color[*p] != GREY && color[*p] != BLACK){
+	if(color[*p] == WHITE) {
 	  doBackwardDFS(*p, start, backEdges, forward, backward, color);
 	}
       }
@@ -114,78 +104,63 @@
 }
 
 void getBackward(BasicBlock *node, BasicBlock *start,
-		 map<BasicBlock*, BasicBlock *> &backEdges,
-		 map<BasicBlock *, unsigned long> &forward,
-		 map<BasicBlock *, unsigned long> &backward){
+		 std::map<BasicBlock*, BasicBlock *> &backEdges,
+		 std::map<BasicBlock *, unsigned long> &forward,
+		 std::map<BasicBlock *, unsigned long> &backward){
   //do DFS, avoid backedges, consider only forward edges
-  map<BasicBlock *, Color> color;
+  std::map<BasicBlock *, Color> color;
   doBackwardDFS(node, start, backEdges, forward, backward, color);
   backward[start] = 1;
 }
 
-void getExit(map<BasicBlock *, unsigned long> &backward,
-	     map<BasicBlock *, unsigned long> &exitBBs){
-  vector<BasicBlock *> toPush;
-  for(map<BasicBlock *, unsigned long>::iterator MI = backward.begin(),
+void getExit(std::map<BasicBlock *, unsigned long> &backward,
+	     std::map<BasicBlock *, unsigned long> &exitBBs){
+  std::vector<BasicBlock *> toPush;
+  for(std::map<BasicBlock *, unsigned long>::iterator MI = backward.begin(),
 	ME = backward.end(); MI != ME; ++MI){
-    for(BasicBlock::succ_iterator s=succ_begin(MI->first), 
+    for(succ_iterator s=succ_begin(MI->first), 
 	  se=succ_end(MI->first); s != se; ++s){
       if(backward.find(*s) == backward.end()){
 	exitBBs[*s] = 1;
 	toPush.push_back(*s);
-	//std::cerr<<"Exit-----------\n";
-	//std::cerr<<*s;
       }
     }
   }
-
-  for(vector<BasicBlock *>::iterator VI = toPush.begin(), VE = toPush.end();
-      VI != VE; ++VI){
+  for(std::vector<BasicBlock *>::iterator VI = toPush.begin(),
+      VE = toPush.end(); VI != VE; ++VI){
     backward[*VI] = 1;
   }
 }
 
-void doTraceDFS(BasicBlock *node, vector<BasicBlock *> &trace, 
-		map<BasicBlock *, unsigned long> &backward,
-		map<BasicBlock *, Color> &color){
-  //std::cerr<<node;
+void doTraceDFS(BasicBlock *node, std::vector<BasicBlock *> &trace, 
+		std::map<BasicBlock *, unsigned long> &backward,
+		std::map<BasicBlock *, Color> &color){
   color[node] = GREY;
   trace.push_back(node);
-  for(BasicBlock::succ_iterator s=succ_begin(node), 
-	se=succ_end(node); s != se; ++s){
-    if(backward.find(*s) != backward.end()){
-      if(color[*s] != GREY && color[*s] != BLACK){
-	doTraceDFS(*s, trace, backward, color);
-      }
-    }
-  }
-
+  for(succ_iterator s=succ_begin(node), se=succ_end(node); s != se; ++s)
+    if(backward.find(*s) != backward.end())
+      if(color[*s] == WHITE)
+        doTraceDFS(*s, trace, backward, color);
   color[node] = BLACK;
 }
 
-void getTrace(BasicBlock *root, vector<BasicBlock *> &trace, 
-	      map<BasicBlock *, unsigned long> &backward){
+void getTrace(BasicBlock *root, std::vector<BasicBlock *> &trace, 
+	      std::map<BasicBlock *, unsigned long> &backward){
   //do a DFS from root ONLY on nodes in backward
-  map<BasicBlock *, Color> color;
+  std::map<BasicBlock *, Color> color;
   doTraceDFS(root, trace, backward, color);
 }
 
-
 void doTraceDFSForFunction(BasicBlock *node, vector<BasicBlock *> &trace, 
 			   map<BasicBlock *, Color> &color){
-
   color[node] = GREY;
   trace.push_back(node);
-  for(BasicBlock::succ_iterator s=succ_begin(node), 
-	se=succ_end(node); s != se; ++s){
-    if(color[*s] != GREY && color[*s] != BLACK){
+  for(succ_iterator s=succ_begin(node), se=succ_end(node); s != se; ++s)
+    if(color[*s] == WHITE)
       doTraceDFSForFunction(*s, trace, color);
-    }
-  }
   color[node] = BLACK;
 }
 
-
 //Inlining algorithm
 //
 //For the TOP loop
@@ -233,17 +208,8 @@
 
   assert(root && end && "No root or end found");
 
-  /*
-  std::cerr<<root->getParent();
-  std::cerr<<"root---------------------------\n";
-  std::cerr<<root;
-  std::cerr<<"exit---------------------------\n";
-  std::cerr<<end;
-  std::cerr<<"trace---------------------------\n";
-  */
-
   //find backedges
-  map<BasicBlock*, BasicBlock*> backEdges; //edge from key->value
+  std::map<BasicBlock*, BasicBlock*> backEdges; //edge from key->value
   getBackEdges(backEdges, root->getParent());
 
   //end node
@@ -251,24 +217,21 @@
 	 "No backedge with end found");
 
   //get forward edges
-  map<BasicBlock *, unsigned long> forward;
+  std::map<BasicBlock *, unsigned long> forward;
   getForward(root, end, backEdges, forward);
   
   //get backward edges
-  map<BasicBlock *, unsigned long> backward;
+  std::map<BasicBlock *, unsigned long> backward;
   getBackward(end, root, backEdges, forward, backward);
 
   //for BBs in backward, find exit nodes
-  map<BasicBlock *, unsigned long> exitBBs;
+  std::map<BasicBlock *, unsigned long> exitBBs;
   getExit(backward, exitBBs);
 
-  //std::cerr<<"Trace------------------\n";
   //get a vector of trace
-  vector<BasicBlock *> vBB;
+  std::vector<BasicBlock *> vBB;
   getTrace(root, vBB, backward);
 
-  //std::cerr<<"END---------------------------\n";
-
   unsigned int initial_code[] = {0x83663001};//0x82102001//move 1 to g1
   unsigned int call_code[] = {0xc277a7ef, 0xc25fa7ef, 0xde77a7f7, 0xde5fa7f7}; 
   //save g1, restore g1, save o7, restore o7
@@ -279,26 +242,24 @@
   //spill o0, g7->o0, call, unspill o0 0x90104000
   unsigned int exit_code[] = {CALL, NOP};//call llvm_time_end
 
-  map<int, uint64_t> callMap;
-  map<int, uint64_t> branchMap;
-  map<BasicBlock *, int> bbPlacement;
-  map<int, BasicBlock *> branchStub; 
-  map<uint64_t, int> toInline;
+  std::map<int, uint64_t> callMap;
+  std::map<int, uint64_t> branchMap;
+  std::map<BasicBlock *, int> bbPlacement;
+  std::map<int, BasicBlock *> branchStub; 
+  std::map<uint64_t, int> toInline;
 
   int index = 0;
-  vector<unsigned int> trace; 
+  std::vector<unsigned int> trace; 
   //generate a vector of instructions
   trace.push_back(initial_code[0]);
-  //trace.push_back(initial_code[1]);
   index += 1; 
+
   //assume: succ[0] is 0, succ[1] is 1
-  for(vector<BasicBlock *>::iterator VBI = vBB.begin(), VBE = vBB.end();
+  for(std::vector<BasicBlock *>::iterator VBI = vBB.begin(), VBE = vBB.end();
       VBI != VBE; ++VBI){//loop on vBB
-    
     std::pair<uint64_t, uint64_t> bbInst = getBasicBlockInfo(*VBI);
     uint64_t bbStart = bbInst.first;
     uint64_t bbEnd = bbInst.second;
-
     if(exitBBs.find(*VBI) != exitBBs.end()){ //is an exit BB
       bbPlacement[*VBI] = index;
       trace.push_back(call_code[2]);
@@ -311,15 +272,11 @@
       branchMap[index + 4] = bbStart;
       callMap[index+1] = (uint64_t)(intptr_t)(&llvm_time_end);
       index += 6;
-    }
-    else{ //This is not an exit BB
-      
+    } else{ //This is not an exit BB
       bbPlacement[*VBI] = index;
-
       bool isCondBranch = false;
       int fillLater = 0;
       bool isSucc0 = false;
-
       uint64_t succ0=0, succ1=0;
       BasicBlock *taken=NULL, *ntaken=NULL;
       TerminatorInst *TI = (*VBI)->getTerminator();
@@ -333,24 +290,19 @@
 	  succ1 = getBasicBlockInfo(ntaken).first;
 	}
       }
-
       
       for(uint64_t addr = bbStart; addr <= bbEnd; addr+=4){//loop on BB
 	unsigned instr = vm->readInstrFrmVm(addr, tr, tr2);
-      
 	if(isIndirectCall(instr)){
 	  trace.push_back(call_code[0]);
 	  trace.push_back(instr);
-	  //trace.push_back(NOP);
 	  trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
 	  trace.push_back(call_code[1]);
 	  index += 4;
 	  addr += 4;
-	}
-	else if(isCallInstr(instr)){
+	} else if(isCallInstr(instr)){
 	  uint64_t callTarget = getCallTarget(instr, addr);
 	  if(callTarget != (uint64_t)(intptr_t)&llvm_first_trigger){
-	   
 	    if(isInlinable(getRevFunction(M, callTarget))){
 	      trace.push_back(instr);
 	      trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
@@ -358,20 +310,16 @@
 	      toInline[callTarget] = 1;
 	      index += 2;
 	      addr += 4;
-	    }
-	    else{
-	   
+	    } else{
 	      trace.push_back(call_code[0]);
 	      trace.push_back(instr);
-	      //trace.push_back(NOP);
 	      trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
 	      trace.push_back(call_code[1]);
 	      callMap[index+1] = getCallTarget(instr, addr);
 	      index += 4;
 	      addr += 4;
 	    }
-	  }
-	  else{
+	  } else{
 	    trace.push_back(call_code[2]); //save o7
 	    trace.push_back(loop_top_code[0]);
 	    trace.push_back(loop_top_code[1]);
@@ -379,36 +327,30 @@
 	    callMap[index+1] = (uint64_t)(intptr_t)&countPath;
 	    index += 4;
 	  }
-	}
-	else if(isBranchInstr(instr)){//is branch
+	} else if(isBranchInstr(instr)){//is branch
 	  assert(!isBranchNever(instr) && "Branch never not handled!");
 	  if(isBranchAlways(instr)){
 	    uint64_t target = getBranchTarget(instr, addr);
 	    if(target == addr1){
-
 	      trace.push_back(instr);
 	      trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
 	      trace[index] = getBranchInst(instr, 
 					   (uint64_t)(intptr_t)&trace[0], 
 					   (uint64_t)(intptr_t)&trace[index]);
 	      index += 2;
-	    }
-	    else{
+	    } else{
 	      trace.push_back(instr);
 	      trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
-	      
 	      BasicBlock *targetBB=NULL;
 	      assert(getReverseBBMap(getBranchTarget(instr, addr), M, targetBB));
 	      branchStub[index] = targetBB;
 	      index += 2;
 	    }
-	    
 	    addr += 4;
-	  }
-	  else{
-	    if(isCondBranch){
-	      uint64_t target = getBranchTarget(instr, addr);
-	      if(target == succ0){
+	  } else{
+            assert (isCondBranch);
+	    uint64_t target = getBranchTarget(instr, addr);
+	    if (target == succ0) {
 		isSucc0 = true;
 		fillLater = index;
 		trace.push_back(instr);
@@ -417,8 +359,7 @@
 		trace.push_back(succ1_code[1]);
 		index += 4;
 		addr += 4;
-	      }
-	      else{
+	    } else {
 		fillLater = index;
 		trace.push_back(instr);
 		trace.push_back(vm->readInstrFrmVm(addr+4, tr, tr2));
@@ -426,60 +367,47 @@
 		trace.push_back(succ0_code[1]);
 		index += 4;
 		addr += 4; 
-	      }
-	    }
-	    else{
-	      assert(false && "Should not be here!");
 	    }
 	  }
-	}
-	else{
+	} else{
 	  trace.push_back(instr);
 	  index++;
 	}
       }
-    
+
       if(isCondBranch){
 	trace.push_back(0);//dummy
-
-	unsigned int newBranch = getBranchInst(trace[fillLater], 
-					       (uint64_t)(intptr_t)&trace[index],
-					       (uint64_t)(intptr_t)&trace[fillLater]);
-      
+	unsigned int newBranch =
+          getBranchInst(trace[fillLater], (uint64_t)(intptr_t)&trace[index],
+                        (uint64_t)(intptr_t)&trace[fillLater]);
 	trace[fillLater] = newBranch;
-
 	if(isSucc0){
+	  assert((taken != vBB[0]) && "Conditional branch to top!");
 	  trace[index] = succ0_code[0];
 	  trace.push_back(succ0_code[1]);
 	  trace.push_back(BRANCH_ALWAYS);
 	  trace.push_back(NOP);
-
-	  if(taken == vBB[0]){
-	    assert(false && "Conditional branch to top!");
-	  }
 	  branchStub[index+2] = taken;
 	  index += 4;
-	}
-	else{
+	} else{
+	  assert((ntaken != vBB[0]) && "Conditional branch to top!");
 	  trace[index] = succ1_code[0];
 	  trace.push_back(succ1_code[1]);
 	  trace.push_back(BRANCH_ALWAYS);
-	  if(ntaken == vBB[0]){
-	    assert(false && "Conditional branch to top!");
-	  }
-	  branchStub[index+2] = ntaken;
 	  trace.push_back(NOP);
+	  branchStub[index+2] = ntaken;
 	  index += 4;
 	}
       }
     }
   }
 
-  for(map<int, BasicBlock *>::iterator MI = branchStub.begin(),
-	ME = branchStub.end(); MI != ME; ++MI){
-    trace[MI->first] = getBranchInst(trace[MI->first], 
-				     (uint64_t)(intptr_t)&trace[bbPlacement[MI->second]],
-				     (uint64_t)(intptr_t)&trace[MI->first]);
+  for (std::map<int, BasicBlock *>::iterator MI = branchStub.begin(),
+       ME = branchStub.end(); MI != ME; ++MI) {
+    trace[MI->first] =
+      getBranchInst(trace[MI->first], 
+                    (uint64_t)(intptr_t)&trace[bbPlacement[MI->second]],
+                    (uint64_t)(intptr_t)&trace[MI->first]);
   }
   
 
@@ -490,15 +418,14 @@
   DEBUG(std::cerr << "Added-SLI-trace\t" << (void *)addr1 << "\t"
 	<< (void *)endAddr << "\t" << trace.size() << "\n");
 
-  for(map<uint64_t, int>::iterator MI = toInline.begin(), ME = toInline.end();
-      MI != ME; ++MI){
+  for(std::map<uint64_t, int>::iterator MI = toInline.begin(),
+      ME = toInline.end(); MI != ME; ++MI) {
     if(!tr->hasTraceAddr(MI->first)){
       vector<Function *> stack;
       stack.push_back(root->getParent());
       doInlining(MI->first, stack, vm);
     }
   }
-
 }
 
 void doInlining(uint64_t addr1, vector<Function *> &stack, VirtualMem *vm){





More information about the llvm-commits mailing list