[llvm-commits] CVS: llvm/lib/Transforms/Scalar/Reg2Mem.cpp

[Andrew Lenharth]

Changes in directory llvm/lib/Transforms/Scalar:

Reg2Mem.cpp added (r1.1)
---
Log message:

The pass everyone has been waiting for!
Reg2Mem

for fun you can opt -reg2mem -mem2reg



---
Diffs of the changes:  (+79 -0)

 Reg2Mem.cpp |   79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 79 insertions(+)


Index: llvm/lib/Transforms/Scalar/Reg2Mem.cpp
diff -c /dev/null llvm/lib/Transforms/Scalar/Reg2Mem.cpp:1.1
*** /dev/null	Wed Nov  9 19:58:48 2005
--- llvm/lib/Transforms/Scalar/Reg2Mem.cpp	Wed Nov  9 19:58:38 2005
***************
*** 0 ****
--- 1,79 ----
+ //===- Reg2Mem.cpp - Convert registers to allocas -------------------------===//
+ //
+ //                     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.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file demotes all registers to memory references.  It is intented to be
+ // the inverse of PromoteMemoryToRegister.  By converting to loads, the only
+ // values live accross basic blocks are allocas and loads before phi nodes.
+ // It is intended that this should make CFG hacking much easier.
+ // To make later hacking easier, the entry block is split into two, such that
+ // all introduced allocas and nothing else are in the entry block.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #include "llvm/Transforms/Scalar.h"
+ #include "llvm/Transforms/Utils/Local.h"
+ #include "llvm/Pass.h"
+ #include "llvm/Function.h"
+ #include "llvm/Module.h"
+ #include "llvm/BasicBlock.h"
+ #include "llvm/Instructions.h"
+ #include "llvm/ADT/Statistic.h"
+ 
+ #include <list>
+ 
+ using namespace llvm;
+ 
+ namespace {
+   Statistic<> NumDemoted("reg2mem", "Number of registers demoted");
+   
+   struct RegToMem : public FunctionPass {
+ 
+    bool valueEscapes(Instruction* i) {
+       BasicBlock* bb = i->getParent();
+       for(Value::use_iterator ii = i->use_begin(), ie = i->use_end();
+           ii != ie; ++ii)
+         if (cast<Instruction>(*ii)->getParent() != bb)
+           return true;
+       return false;
+     }
+ 
+     virtual bool runOnFunction(Function &F) {
+       if (!F.isExternal()) {
+         //give us a clean block
+         BasicBlock& bbhead = F.getEntryBlock();
+         bbhead.splitBasicBlock(bbhead.begin());
+ 
+         //find the instructions
+         std::list<Instruction*> worklist;
+         for (Function::iterator ibb = F.begin(), ibe = F.end();
+              ibb != ibe; ++ibb)
+           for (BasicBlock::iterator iib = ibb->begin(), iie = ibb->end();
+                iib != iie; ++iib) {
+             if(valueEscapes(iib))
+               worklist.push_front(&*iib);
+           }
+         //demote escaped instructions
+         NumDemoted += worklist.size();
+         for (std::list<Instruction*>::iterator ilb = worklist.begin(), 
+                ile = worklist.end(); ilb != ile; ++ilb)
+           DemoteRegToStack(**ilb, false);
+         return true;
+       }
+       return false;
+     }
+   };
+   
+   RegisterOpt<RegToMem> X("reg2mem", "Demote all values to stack slots");
+ }
+ 
+ // createDemoteRegisterToMemory - Provide an entry point to create this pass.
+ //
+ FunctionPass *llvm::createDemoteRegisterToMemoryPass() {
+   return new RegToMem();
+ }