LLVM  14.0.0git
Mem2Reg.cpp
Go to the documentation of this file.
1 //===- Mem2Reg.cpp - The -mem2reg pass, a wrapper around the Utils lib ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass is a simple pass wrapper around the PromoteMemToReg function call
10 // exposed by the Utils library.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/Statistic.h"
17 #include "llvm/IR/BasicBlock.h"
18 #include "llvm/IR/Dominators.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/PassManager.h"
22 #include "llvm/InitializePasses.h"
23 #include "llvm/Pass.h"
24 #include "llvm/Support/Casting.h"
25 #include "llvm/Transforms/Utils.h"
27 #include <vector>
28 
29 using namespace llvm;
30 
31 #define DEBUG_TYPE "mem2reg"
32 
33 STATISTIC(NumPromoted, "Number of alloca's promoted");
34 
36  AssumptionCache &AC) {
37  std::vector<AllocaInst *> Allocas;
38  BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function
39  bool Changed = false;
40 
41  while (true) {
42  Allocas.clear();
43 
44  // Find allocas that are safe to promote, by looking at all instructions in
45  // the entry node
46  for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I)
47  if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca?
48  if (isAllocaPromotable(AI))
49  Allocas.push_back(AI);
50 
51  if (Allocas.empty())
52  break;
53 
54  PromoteMemToReg(Allocas, DT, &AC);
55  NumPromoted += Allocas.size();
56  Changed = true;
57  }
58  return Changed;
59 }
60 
62  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
63  auto &AC = AM.getResult<AssumptionAnalysis>(F);
64  if (!promoteMemoryToRegister(F, DT, AC))
65  return PreservedAnalyses::all();
66 
69  return PA;
70 }
71 
72 namespace {
73 
74 struct PromoteLegacyPass : public FunctionPass {
75  // Pass identification, replacement for typeid
76  static char ID;
77 
78  PromoteLegacyPass() : FunctionPass(ID) {
80  }
81 
82  // runOnFunction - To run this pass, first we calculate the alloca
83  // instructions that are safe for promotion, then we promote each one.
84  bool runOnFunction(Function &F) override {
85  if (skipFunction(F))
86  return false;
87 
88  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
89  AssumptionCache &AC =
90  getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
91  return promoteMemoryToRegister(F, DT, AC);
92  }
93 
94  void getAnalysisUsage(AnalysisUsage &AU) const override {
97  AU.setPreservesCFG();
98  }
99 };
100 
101 } // end anonymous namespace
102 
103 char PromoteLegacyPass::ID = 0;
104 
105 INITIALIZE_PASS_BEGIN(PromoteLegacyPass, "mem2reg", "Promote Memory to "
106  "Register",
107  false, false)
110 INITIALIZE_PASS_END(PromoteLegacyPass, "mem2reg", "Promote Memory to Register",
112 
113 // createPromoteMemoryToRegister - Provide an entry point to create this pass.
115  return new PromoteLegacyPass();
116 }
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
AssumptionCache.h
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
Mem2Reg.h
llvm::BasicBlock::iterator
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:90
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:783
llvm::Function
Definition: Function.h:62
Pass.h
Statistic.h
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:151
to
Should compile to
Definition: README.txt:449
mem2reg
mem2reg
Definition: Mem2Reg.cpp:110
llvm::PromoteMemToReg
void PromoteMemToReg(ArrayRef< AllocaInst * > Allocas, DominatorTree &DT, AssumptionCache *AC=nullptr)
Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appro...
Definition: PromoteMemoryToRegister.cpp:1014
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::PromotePass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Mem2Reg.cpp:61
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
false
Definition: StackSlotColoring.cpp:142
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:287
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
Utils.h
promoteMemoryToRegister
static bool promoteMemoryToRegister(Function &F, DominatorTree &DT, AssumptionCache &AC)
Definition: Mem2Reg.cpp:35
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::initializePromoteLegacyPassPass
void initializePromoteLegacyPassPass(PassRegistry &)
BasicBlock.h
llvm::AssumptionAnalysis
A function analysis which provides an AssumptionCache.
Definition: AssumptionCache.h:169
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(PromoteLegacyPass, "mem2reg", "Promote Memory to " "Register", false, false) INITIALIZE_PASS_END(PromoteLegacyPass
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
PromoteMemToReg.h
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:200
llvm::sys::Memory
This class provides various memory handling functions that manipulate MemoryBlock instances.
Definition: Memory.h:52
llvm::AnalysisUsage::setPreservesCFG
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:41
llvm::CFGAnalyses
Represents analyses that only rely on functions' control flow.
Definition: PassManager.h:116
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:69
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
Casting.h
Function.h
PassManager.h
llvm::createPromoteMemoryToRegisterPass
FunctionPass * createPromoteMemoryToRegisterPass()
Definition: Mem2Reg.cpp:114
llvm::DominatorTreeAnalysis
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:252
Instructions.h
llvm::PreservedAnalyses::preserveSet
void preserveSet()
Mark an analysis set as preserved.
Definition: PassManager.h:191
Dominators.h
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::AllocaInst
an instruction to allocate memory on the stack
Definition: Instructions.h:62
InitializePasses.h
llvm::isAllocaPromotable
bool isAllocaPromotable(const AllocaInst *AI)
Return true if this alloca is legal for promotion.
Definition: PromoteMemoryToRegister.cpp:64
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37