LLVM  4.0.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 
16 #include "llvm/ADT/Statistic.h"
18 #include "llvm/IR/Dominators.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/Transforms/Scalar.h"
24 using namespace llvm;
25 
26 #define DEBUG_TYPE "mem2reg"
27 
28 STATISTIC(NumPromoted, "Number of alloca's promoted");
29 
31  AssumptionCache &AC) {
32  std::vector<AllocaInst *> Allocas;
33  BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function
34  bool Changed = false;
35 
36  while (1) {
37  Allocas.clear();
38 
39  // Find allocas that are safe to promote, by looking at all instructions in
40  // the entry node
41  for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I)
42  if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca?
43  if (isAllocaPromotable(AI))
44  Allocas.push_back(AI);
45 
46  if (Allocas.empty())
47  break;
48 
49  PromoteMemToReg(Allocas, DT, nullptr, &AC);
50  NumPromoted += Allocas.size();
51  Changed = true;
52  }
53  return Changed;
54 }
55 
57  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
58  auto &AC = AM.getResult<AssumptionAnalysis>(F);
59  if (!promoteMemoryToRegister(F, DT, AC))
60  return PreservedAnalyses::all();
61 
62  // FIXME: This should also 'preserve the CFG'.
63  return PreservedAnalyses::none();
64 }
65 
66 namespace {
67 struct PromoteLegacyPass : public FunctionPass {
68  static char ID; // Pass identification, replacement for typeid
69  PromoteLegacyPass() : FunctionPass(ID) {
71  }
72 
73  // runOnFunction - To run this pass, first we calculate the alloca
74  // instructions that are safe for promotion, then we promote each one.
75  //
76  bool runOnFunction(Function &F) override {
77  if (skipFunction(F))
78  return false;
79 
80  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
81  AssumptionCache &AC =
82  getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
83  return promoteMemoryToRegister(F, DT, AC);
84  }
85 
86  void getAnalysisUsage(AnalysisUsage &AU) const override {
89  AU.setPreservesCFG();
90  }
91  };
92 } // end of anonymous namespace
93 
94 char PromoteLegacyPass::ID = 0;
95 INITIALIZE_PASS_BEGIN(PromoteLegacyPass, "mem2reg", "Promote Memory to "
96  "Register",
97  false, false)
100 INITIALIZE_PASS_END(PromoteLegacyPass, "mem2reg", "Promote Memory to Register",
101  false, false)
102 
103 // createPromoteMemoryToRegister - Provide an entry point to create this pass.
104 //
106  return new PromoteLegacyPass();
107 }
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:46
Promote Memory to false
Definition: Mem2Reg.cpp:100
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of .assume calls within a function.
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:189
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Mem2Reg.cpp:56
bool isAllocaPromotable(const AllocaInst *AI)
Return true if this alloca is legal for promotion.
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
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...
#define F(x, y, z)
Definition: MD5.cpp:51
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
FunctionPass * createPromoteMemoryToRegisterPass()
Definition: Mem2Reg.cpp:105
Represent the analysis usage information of a pass.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
A function analysis which provides an AssumptionCache.
Iterator for intrusive lists based on ilist_node.
iterator end()
Definition: BasicBlock.h:230
static bool promoteMemoryToRegister(Function &F, DominatorTree &DT, AssumptionCache &AC)
Definition: Mem2Reg.cpp:30
Promote Memory to Register
Definition: Mem2Reg.cpp:100
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
mem2reg
Definition: Mem2Reg.cpp:100
void initializePromoteLegacyPassPass(PassRegistry &)
#define I(x, y, z)
Definition: MD5.cpp:54
A container for analyses that lazily runs them and caches their results.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:217
an instruction to allocate memory on the stack
Definition: Instructions.h:60
INITIALIZE_PASS_BEGIN(PromoteLegacyPass,"mem2reg","Promote Memory to ""Register", false, false) INITIALIZE_PASS_END(PromoteLegacyPass