2003-05-31 20:01:37 +00:00
|
|
|
//===- CloneTrace.cpp - Clone a trace -------------------------------------===//
|
2003-10-20 19:43:21 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2003-05-30 15:50:18 +00:00
|
|
|
//
|
2004-02-04 01:19:43 +00:00
|
|
|
// This file implements the CloneTrace interface, which is used when writing
|
|
|
|
// runtime optimizations. It takes a vector of basic blocks clones the basic
|
|
|
|
// blocks, removes internal phi nodes, adds it to the same function as the
|
|
|
|
// original (although there is no jump to it) and returns the new vector of
|
|
|
|
// basic blocks.
|
2003-05-30 15:50:18 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2003-05-31 20:01:37 +00:00
|
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
2003-05-30 15:50:18 +00:00
|
|
|
#include "llvm/iPHINode.h"
|
|
|
|
#include "llvm/Function.h"
|
2004-01-09 06:12:26 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2003-05-30 15:50:18 +00:00
|
|
|
//Clones the trace (a vector of basic blocks)
|
2004-01-09 06:12:26 +00:00
|
|
|
std::vector<BasicBlock *>
|
|
|
|
llvm::CloneTrace(const std::vector<BasicBlock*> &origTrace) {
|
2003-05-30 15:50:18 +00:00
|
|
|
std::vector<BasicBlock *> clonedTrace;
|
|
|
|
std::map<const Value*, Value*> ValueMap;
|
|
|
|
|
|
|
|
//First, loop over all the Basic Blocks in the trace and copy
|
|
|
|
//them using CloneBasicBlock. Also fix the phi nodes during
|
|
|
|
//this loop. To fix the phi nodes, we delete incoming branches
|
|
|
|
//that are not in the trace.
|
|
|
|
for(std::vector<BasicBlock *>::const_iterator T = origTrace.begin(),
|
|
|
|
End = origTrace.end(); T != End; ++T) {
|
|
|
|
|
|
|
|
//Clone Basic Block
|
2004-02-04 01:19:43 +00:00
|
|
|
BasicBlock *clonedBlock =
|
|
|
|
CloneBasicBlock(*T, ValueMap, ".tr", (*T)->getParent());
|
2003-05-30 15:50:18 +00:00
|
|
|
|
|
|
|
//Add it to our new trace
|
|
|
|
clonedTrace.push_back(clonedBlock);
|
|
|
|
|
|
|
|
//Add this new mapping to our Value Map
|
|
|
|
ValueMap[*T] = clonedBlock;
|
|
|
|
|
|
|
|
//Loop over the phi instructions and delete operands
|
|
|
|
//that are from blocks not in the trace
|
|
|
|
//only do this if we are NOT the first block
|
|
|
|
if(T != origTrace.begin()) {
|
|
|
|
for (BasicBlock::iterator I = clonedBlock->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(I); ++I) {
|
|
|
|
//get incoming value for the previous BB
|
|
|
|
Value *V = PN->getIncomingValueForBlock(*(T-1));
|
|
|
|
assert(V && "No incoming value from a BasicBlock in our trace!");
|
|
|
|
|
|
|
|
//remap our phi node to point to incoming value
|
|
|
|
ValueMap[*&I] = V;
|
|
|
|
|
|
|
|
//remove phi node
|
|
|
|
clonedBlock->getInstList().erase(PN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Second loop to do the remapping
|
|
|
|
for(std::vector<BasicBlock *>::const_iterator BB = clonedTrace.begin(),
|
|
|
|
BE = clonedTrace.end(); BB != BE; ++BB) {
|
|
|
|
for(BasicBlock::iterator I = (*BB)->begin(); I != (*BB)->end(); ++I) {
|
|
|
|
|
|
|
|
//Loop over all the operands of the instruction
|
|
|
|
for(unsigned op=0, E = I->getNumOperands(); op != E; ++op) {
|
|
|
|
const Value *Op = I->getOperand(op);
|
|
|
|
|
|
|
|
//Get it out of the value map
|
|
|
|
Value *V = ValueMap[Op];
|
|
|
|
|
|
|
|
//If not in the value map, then its outside our trace so ignore
|
|
|
|
if(V != 0)
|
|
|
|
I->setOperand(op,V);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//return new vector of basic blocks
|
|
|
|
return clonedTrace;
|
|
|
|
}
|