From 6074d2f37abaaa2957b4575d36fd9cd87d8ee08f Mon Sep 17 00:00:00 2001
From: Tanya Lattner <tonic@nondot.org>
Date: Fri, 30 May 2003 15:50:18 +0000
Subject: [PATCH] Added the CloneTrace function which clones traces. It takes a
vector of basic blocks, removes internal phi nodes, and returns a new vector
of basic blocks.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6431 91177308-0d34-0410-b5e6-96231b3b80d8
---
lib/Transforms/Utils/CloneTrace.cpp | 83 +++++++++++++++++++++++++++++
1 file changed, 83 insertions(+)
create mode 100644 lib/Transforms/Utils/CloneTrace.cpp
diff --git a/lib/Transforms/Utils/CloneTrace.cpp b/lib/Transforms/Utils/CloneTrace.cpp
new file mode 100644
index 00000000000..e8578c512d2
--- /dev/null
+++ b/lib/Transforms/Utils/CloneTrace.cpp
@@ -0,0 +1,83 @@
+//===- CloneTrace.cpp - Clone a trace ---------===//
+//
+// This file implements the CloneTrace interface, which is used
+// when writing runtime optimizations. It takes a vector of basic blocks
+// removes internal phi nodes, clones the basic blocks, and returns the new
+// vector of basic blocks.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Instruction.h"
+#include "llvm/BasicBlock.h"
+#include "llvm/iPHINode.h"
+#include "llvm/Function.h"
+#include "llvm/Transforms/Utils/Cloning.h"
+#include <map>
+
+
+//Clones the trace (a vector of basic blocks)
+std::vector<BasicBlock *> CloneTrace(std::vector<BasicBlock*> &origTrace) {
+
+ 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
+ BasicBlock *clonedBlock = CloneBasicBlock(*T, ValueMap);
+
+ //Add it to our new trace
+ clonedTrace.push_back(clonedBlock);
+
+ //Add this new mapping to our Value Map
+ ValueMap[*T] = clonedBlock;
+
+ //Add this cloned BB to the old BB's function
+ (*T)->getParent()->getBasicBlockList().push_back(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;
+}