LLVM  3.7.0
Mem2Reg.cpp
Go to the documentation of this file.
1 //===- Mem2Reg.cpp - The -mem2reg pass, a wrapper around the Utils lib ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass is a simple pass wrapper around the PromoteMemToReg function call
11 // exposed by the Utils library.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Transforms/Scalar.h"
16 #include "llvm/ADT/Statistic.h"
18 #include "llvm/IR/Dominators.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/Instructions.h"
23 using namespace llvm;
24 
25 #define DEBUG_TYPE "mem2reg"
26 
27 STATISTIC(NumPromoted, "Number of alloca's promoted");
28 
29 namespace {
30  struct PromotePass : public FunctionPass {
31  static char ID; // Pass identification, replacement for typeid
32  PromotePass() : FunctionPass(ID) {
34  }
35 
36  // runOnFunction - To run this pass, first we calculate the alloca
37  // instructions that are safe for promotion, then we promote each one.
38  //
39  bool runOnFunction(Function &F) override;
40 
41  void getAnalysisUsage(AnalysisUsage &AU) const override {
44  AU.setPreservesCFG();
45  // This is a cluster of orthogonal Transforms
49  }
50  };
51 } // end of anonymous namespace
52 
53 char PromotePass::ID = 0;
54 INITIALIZE_PASS_BEGIN(PromotePass, "mem2reg", "Promote Memory to Register",
55  false, false)
58 INITIALIZE_PASS_END(PromotePass, "mem2reg", "Promote Memory to Register",
59  false, false)
60 
61 bool PromotePass::runOnFunction(Function &F) {
62  std::vector<AllocaInst*> Allocas;
63 
64  BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function
65 
66  bool Changed = false;
67 
68  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
69  AssumptionCache &AC =
70  getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
71 
72  while (1) {
73  Allocas.clear();
74 
75  // Find allocas that are safe to promote, by looking at all instructions in
76  // the entry node
77  for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I)
78  if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca?
79  if (isAllocaPromotable(AI))
80  Allocas.push_back(AI);
81 
82  if (Allocas.empty()) break;
83 
84  PromoteMemToReg(Allocas, DT, nullptr, &AC);
85  NumPromoted += Allocas.size();
86  Changed = true;
87  }
88 
89  return Changed;
90 }
91 
92 // createPromoteMemoryToRegister - Provide an entry point to create this pass.
93 //
95  return new PromotePass();
96 }
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
STATISTIC(NumFunctions,"Total number of functions")
This class provides various memory handling functions that manipulate MemoryBlock instances...
Definition: Memory.h:45
Promote Memory to false
Definition: Mem2Reg.cpp:58
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of .assume calls within a function.
F(f)
char & LowerSwitchID
bool isAllocaPromotable(const AllocaInst *AI)
Return true if this alloca is legal for promotion.
void initializePromotePassPass(PassRegistry &)
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
void PromoteMemToReg(ArrayRef< AllocaInst * > Allocas, DominatorTree &DT, AliasSetTracker *AST=nullptr, AssumptionCache *AC=nullptr)
Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appro...
AnalysisUsage & addPreservedID(const void *ID)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
char & LowerInvokePassID
iterator end()
Definition: BasicBlock.h:233
Promote Memory to Register
Definition: Mem2Reg.cpp:58
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:263
mem2reg
Definition: Mem2Reg.cpp:58
#define I(x, y, z)
Definition: MD5.cpp:54
INITIALIZE_PASS_BEGIN(PromotePass,"mem2reg","Promote Memory to Register", false, false) INITIALIZE_PASS_END(PromotePass
FunctionPass * createPromoteMemoryToRegisterPass()
Definition: Mem2Reg.cpp:94
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76