[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