LLVM  16.0.0git
DwarfEHPrepare.cpp
Go to the documentation of this file.
1 //===- DwarfEHPrepare - Prepare exception handling for code generation ----===//
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 mulches exception handling code into a form adapted to code
10 // generation. Required if using dwarf exception handling.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/BitVector.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/ADT/Triple.h"
18 #include "llvm/Analysis/CFG.h"
26 #include "llvm/IR/BasicBlock.h"
27 #include "llvm/IR/Constants.h"
29 #include "llvm/IR/DerivedTypes.h"
30 #include "llvm/IR/Dominators.h"
31 #include "llvm/IR/Function.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/IR/Type.h"
35 #include "llvm/InitializePasses.h"
36 #include "llvm/Pass.h"
37 #include "llvm/Support/Casting.h"
40 #include <cstddef>
41 
42 using namespace llvm;
43 
44 #define DEBUG_TYPE "dwarfehprepare"
45 
46 STATISTIC(NumResumesLowered, "Number of resume calls lowered");
47 STATISTIC(NumCleanupLandingPadsUnreachable,
48  "Number of cleanup landing pads found unreachable");
49 STATISTIC(NumCleanupLandingPadsRemaining,
50  "Number of cleanup landing pads remaining");
51 STATISTIC(NumNoUnwind, "Number of functions with nounwind");
52 STATISTIC(NumUnwind, "Number of functions with unwind");
53 
54 namespace {
55 
56 class DwarfEHPrepare {
57  CodeGenOpt::Level OptLevel;
58 
59  Function &F;
60  const TargetLowering &TLI;
61  DomTreeUpdater *DTU;
62  const TargetTransformInfo *TTI;
63  const Triple &TargetTriple;
64 
65  /// Return the exception object from the value passed into
66  /// the 'resume' instruction (typically an aggregate). Clean up any dead
67  /// instructions, including the 'resume' instruction.
68  Value *GetExceptionObject(ResumeInst *RI);
69 
70  /// Replace resumes that are not reachable from a cleanup landing pad with
71  /// unreachable and then simplify those blocks.
72  size_t
73  pruneUnreachableResumes(SmallVectorImpl<ResumeInst *> &Resumes,
74  SmallVectorImpl<LandingPadInst *> &CleanupLPads);
75 
76  /// Convert the ResumeInsts that are still present
77  /// into calls to the appropriate _Unwind_Resume function.
78  bool InsertUnwindResumeCalls();
79 
80 public:
81  DwarfEHPrepare(CodeGenOpt::Level OptLevel_, Function &F_,
82  const TargetLowering &TLI_, DomTreeUpdater *DTU_,
83  const TargetTransformInfo *TTI_, const Triple &TargetTriple_)
84  : OptLevel(OptLevel_), F(F_), TLI(TLI_), DTU(DTU_), TTI(TTI_),
85  TargetTriple(TargetTriple_) {}
86 
87  bool run();
88 };
89 
90 } // namespace
91 
92 Value *DwarfEHPrepare::GetExceptionObject(ResumeInst *RI) {
93  Value *V = RI->getOperand(0);
94  Value *ExnObj = nullptr;
95  InsertValueInst *SelIVI = dyn_cast<InsertValueInst>(V);
96  LoadInst *SelLoad = nullptr;
97  InsertValueInst *ExcIVI = nullptr;
98  bool EraseIVIs = false;
99 
100  if (SelIVI) {
101  if (SelIVI->getNumIndices() == 1 && *SelIVI->idx_begin() == 1) {
102  ExcIVI = dyn_cast<InsertValueInst>(SelIVI->getOperand(0));
103  if (ExcIVI && isa<UndefValue>(ExcIVI->getOperand(0)) &&
104  ExcIVI->getNumIndices() == 1 && *ExcIVI->idx_begin() == 0) {
105  ExnObj = ExcIVI->getOperand(1);
106  SelLoad = dyn_cast<LoadInst>(SelIVI->getOperand(1));
107  EraseIVIs = true;
108  }
109  }
110  }
111 
112  if (!ExnObj)
113  ExnObj = ExtractValueInst::Create(RI->getOperand(0), 0, "exn.obj", RI);
114 
115  RI->eraseFromParent();
116 
117  if (EraseIVIs) {
118  if (SelIVI->use_empty())
119  SelIVI->eraseFromParent();
120  if (ExcIVI->use_empty())
121  ExcIVI->eraseFromParent();
122  if (SelLoad && SelLoad->use_empty())
123  SelLoad->eraseFromParent();
124  }
125 
126  return ExnObj;
127 }
128 
129 size_t DwarfEHPrepare::pruneUnreachableResumes(
131  SmallVectorImpl<LandingPadInst *> &CleanupLPads) {
132  assert(DTU && "Should have DomTreeUpdater here.");
133 
134  BitVector ResumeReachable(Resumes.size());
135  size_t ResumeIndex = 0;
136  for (auto *RI : Resumes) {
137  for (auto *LP : CleanupLPads) {
138  if (isPotentiallyReachable(LP, RI, nullptr, &DTU->getDomTree())) {
139  ResumeReachable.set(ResumeIndex);
140  break;
141  }
142  }
143  ++ResumeIndex;
144  }
145 
146  // If everything is reachable, there is no change.
147  if (ResumeReachable.all())
148  return Resumes.size();
149 
150  LLVMContext &Ctx = F.getContext();
151 
152  // Otherwise, insert unreachable instructions and call simplifycfg.
153  size_t ResumesLeft = 0;
154  for (size_t I = 0, E = Resumes.size(); I < E; ++I) {
155  ResumeInst *RI = Resumes[I];
156  if (ResumeReachable[I]) {
157  Resumes[ResumesLeft++] = RI;
158  } else {
159  BasicBlock *BB = RI->getParent();
160  new UnreachableInst(Ctx, RI);
161  RI->eraseFromParent();
162  simplifyCFG(BB, *TTI, DTU);
163  }
164  }
165  Resumes.resize(ResumesLeft);
166  return ResumesLeft;
167 }
168 
169 bool DwarfEHPrepare::InsertUnwindResumeCalls() {
172  if (F.doesNotThrow())
173  NumNoUnwind++;
174  else
175  NumUnwind++;
176  for (BasicBlock &BB : F) {
177  if (auto *RI = dyn_cast<ResumeInst>(BB.getTerminator()))
178  Resumes.push_back(RI);
179  if (auto *LP = BB.getLandingPadInst())
180  if (LP->isCleanup())
181  CleanupLPads.push_back(LP);
182  }
183 
184  NumCleanupLandingPadsRemaining += CleanupLPads.size();
185 
186  if (Resumes.empty())
187  return false;
188 
189  // Check the personality, don't do anything if it's scope-based.
190  EHPersonality Pers = classifyEHPersonality(F.getPersonalityFn());
191  if (isScopedEHPersonality(Pers))
192  return false;
193 
194  LLVMContext &Ctx = F.getContext();
195 
196  size_t ResumesLeft = Resumes.size();
197  if (OptLevel != CodeGenOpt::None) {
198  ResumesLeft = pruneUnreachableResumes(Resumes, CleanupLPads);
199 #if LLVM_ENABLE_STATS
200  unsigned NumRemainingLPs = 0;
201  for (BasicBlock &BB : F) {
202  if (auto *LP = BB.getLandingPadInst())
203  if (LP->isCleanup())
204  NumRemainingLPs++;
205  }
206  NumCleanupLandingPadsUnreachable += CleanupLPads.size() - NumRemainingLPs;
207  NumCleanupLandingPadsRemaining -= CleanupLPads.size() - NumRemainingLPs;
208 #endif
209  }
210 
211  if (ResumesLeft == 0)
212  return true; // We pruned them all.
213 
214  // RewindFunction - _Unwind_Resume or the target equivalent.
215  FunctionCallee RewindFunction;
216  CallingConv::ID RewindFunctionCallingConv;
217  FunctionType *FTy;
218  const char *RewindName;
219  bool DoesRewindFunctionNeedExceptionObject;
220 
221  if ((Pers == EHPersonality::GNU_CXX || Pers == EHPersonality::GNU_CXX_SjLj) &&
222  TargetTriple.isTargetEHABICompatible()) {
223  RewindName = TLI.getLibcallName(RTLIB::CXA_END_CLEANUP);
224  FTy = FunctionType::get(Type::getVoidTy(Ctx), false);
225  RewindFunctionCallingConv =
226  TLI.getLibcallCallingConv(RTLIB::CXA_END_CLEANUP);
227  DoesRewindFunctionNeedExceptionObject = false;
228  } else {
229  RewindName = TLI.getLibcallName(RTLIB::UNWIND_RESUME);
230  FTy =
232  RewindFunctionCallingConv = TLI.getLibcallCallingConv(RTLIB::UNWIND_RESUME);
233  DoesRewindFunctionNeedExceptionObject = true;
234  }
235  RewindFunction = F.getParent()->getOrInsertFunction(RewindName, FTy);
236 
237  // Create the basic block where the _Unwind_Resume call will live.
238  if (ResumesLeft == 1) {
239  // Instead of creating a new BB and PHI node, just append the call to
240  // _Unwind_Resume to the end of the single resume block.
241  ResumeInst *RI = Resumes.front();
242  BasicBlock *UnwindBB = RI->getParent();
243  Value *ExnObj = GetExceptionObject(RI);
244  llvm::SmallVector<Value *, 1> RewindFunctionArgs;
245  if (DoesRewindFunctionNeedExceptionObject)
246  RewindFunctionArgs.push_back(ExnObj);
247 
248  // Call the rewind function.
249  CallInst *CI =
250  CallInst::Create(RewindFunction, RewindFunctionArgs, "", UnwindBB);
251  // The verifier requires that all calls of debug-info-bearing functions
252  // from debug-info-bearing functions have a debug location (for inlining
253  // purposes). Assign a dummy location to satisfy the constraint.
254  Function *RewindFn = dyn_cast<Function>(RewindFunction.getCallee());
255  if (RewindFn && RewindFn->getSubprogram())
256  if (DISubprogram *SP = F.getSubprogram())
257  CI->setDebugLoc(DILocation::get(SP->getContext(), 0, 0, SP));
258  CI->setCallingConv(RewindFunctionCallingConv);
259 
260  // We never expect _Unwind_Resume to return.
261  CI->setDoesNotReturn();
262  new UnreachableInst(Ctx, UnwindBB);
263  return true;
264  }
265 
266  std::vector<DominatorTree::UpdateType> Updates;
267  Updates.reserve(Resumes.size());
268 
269  llvm::SmallVector<Value *, 1> RewindFunctionArgs;
270 
271  BasicBlock *UnwindBB = BasicBlock::Create(Ctx, "unwind_resume", &F);
272  PHINode *PN = PHINode::Create(Type::getInt8PtrTy(Ctx), ResumesLeft, "exn.obj",
273  UnwindBB);
274 
275  // Extract the exception object from the ResumeInst and add it to the PHI node
276  // that feeds the _Unwind_Resume call.
277  for (ResumeInst *RI : Resumes) {
278  BasicBlock *Parent = RI->getParent();
279  BranchInst::Create(UnwindBB, Parent);
280  Updates.push_back({DominatorTree::Insert, Parent, UnwindBB});
281 
282  Value *ExnObj = GetExceptionObject(RI);
283  PN->addIncoming(ExnObj, Parent);
284 
285  ++NumResumesLowered;
286  }
287 
288  if (DoesRewindFunctionNeedExceptionObject)
289  RewindFunctionArgs.push_back(PN);
290 
291  // Call the function.
292  CallInst *CI =
293  CallInst::Create(RewindFunction, RewindFunctionArgs, "", UnwindBB);
294  CI->setCallingConv(RewindFunctionCallingConv);
295 
296  // We never expect _Unwind_Resume to return.
297  CI->setDoesNotReturn();
298  new UnreachableInst(Ctx, UnwindBB);
299 
300  if (DTU)
301  DTU->applyUpdates(Updates);
302 
303  return true;
304 }
305 
306 bool DwarfEHPrepare::run() {
307  bool Changed = InsertUnwindResumeCalls();
308 
309  return Changed;
310 }
311 
313  const TargetLowering &TLI, DominatorTree *DT,
314  const TargetTransformInfo *TTI,
315  const Triple &TargetTriple) {
317 
318  return DwarfEHPrepare(OptLevel, F, TLI, DT ? &DTU : nullptr, TTI,
319  TargetTriple)
320  .run();
321 }
322 
323 namespace {
324 
325 class DwarfEHPrepareLegacyPass : public FunctionPass {
326 
327  CodeGenOpt::Level OptLevel;
328 
329 public:
330  static char ID; // Pass identification, replacement for typeid.
331 
332  DwarfEHPrepareLegacyPass(CodeGenOpt::Level OptLevel = CodeGenOpt::Default)
333  : FunctionPass(ID), OptLevel(OptLevel) {}
334 
335  bool runOnFunction(Function &F) override {
336  const TargetMachine &TM =
337  getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
338  const TargetLowering &TLI = *TM.getSubtargetImpl(F)->getTargetLowering();
339  DominatorTree *DT = nullptr;
340  const TargetTransformInfo *TTI = nullptr;
341  if (auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>())
342  DT = &DTWP->getDomTree();
343  if (OptLevel != CodeGenOpt::None) {
344  if (!DT)
345  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
346  TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
347  }
348  return prepareDwarfEH(OptLevel, F, TLI, DT, TTI, TM.getTargetTriple());
349  }
350 
351  void getAnalysisUsage(AnalysisUsage &AU) const override {
354  if (OptLevel != CodeGenOpt::None) {
357  }
359  }
360 
361  StringRef getPassName() const override {
362  return "Exception handling preparation";
363  }
364 };
365 
366 } // end anonymous namespace
367 
369 
370 INITIALIZE_PASS_BEGIN(DwarfEHPrepareLegacyPass, DEBUG_TYPE,
371  "Prepare DWARF exceptions", false, false)
375 INITIALIZE_PASS_END(DwarfEHPrepareLegacyPass, DEBUG_TYPE,
376  "Prepare DWARF exceptions", false, false)
377 
378 FunctionPass *llvm::createDwarfEHPass(CodeGenOpt::Level OptLevel) {
379  return new DwarfEHPrepareLegacyPass(OptLevel);
380 }
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::AArch64PACKey::ID
ID
Definition: AArch64BaseInfo.h:818
llvm::Type::getInt8PtrTy
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:290
DebugInfoMetadata.h
llvm::Function
Definition: Function.h:60
Pass.h
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
Statistic.h
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1625
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:173
DomTreeUpdater.h
llvm::FunctionType::get
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:360
Local.h
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Module.h
llvm::DominatorTreeBase< BasicBlock, false >::Insert
static constexpr UpdateKind Insert
Definition: GenericDomTree.h:242
EHPersonalities.h
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1400
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::DomTreeUpdater::UpdateStrategy::Lazy
@ Lazy
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::classifyEHPersonality
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Definition: EHPersonalities.cpp:22
TargetLowering.h
llvm::createDwarfEHPass
FunctionPass * createDwarfEHPass(CodeGenOpt::Level OptLevel)
createDwarfEHPass - This pass mulches exception handling code into a form adapted to code generation.
Definition: DwarfEHPrepare.cpp:378
llvm::CallBase::setDoesNotReturn
void setDoesNotReturn()
Definition: InstrTypes.h:1883
TargetMachine.h
Constants.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::TargetLowering
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
Definition: TargetLowering.h:3506
exceptions
Prepare DWARF exceptions
Definition: DwarfEHPrepare.cpp:376
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1517
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
false
Definition: StackSlotColoring.cpp:141
llvm::isPotentiallyReachable
bool isPotentiallyReachable(const Instruction *From, const Instruction *To, const SmallPtrSetImpl< BasicBlock * > *ExclusionSet=nullptr, const DominatorTree *DT=nullptr, const LoopInfo *LI=nullptr)
Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in Ex...
Definition: CFG.cpp:231
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:306
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::DomTreeUpdater
Definition: DomTreeUpdater.h:28
BitVector.h
llvm::BitVector
Definition: BitVector.h:75
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
Type.h
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::dxil::PointerTypeAnalysis::run
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
Definition: PointerTypeAnalysis.cpp:189
llvm::TargetPassConfig
Target-Independent Code Generator Pass Configuration Options.
Definition: TargetPassConfig.h:84
BasicBlock.h
llvm::EHPersonality::GNU_CXX_SjLj
@ GNU_CXX_SjLj
prepareDwarfEH
static bool prepareDwarfEH(CodeGenOpt::Level OptLevel, Function &F, const TargetLowering &TLI, DominatorTree *DT, const TargetTransformInfo *TTI, const Triple &TargetTriple)
Definition: DwarfEHPrepare.cpp:312
llvm::Instruction::eraseFromParent
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:81
llvm::CodeGenOpt::Default
@ Default
Definition: CodeGen.h:55
llvm::InsertValueInst::getNumIndices
unsigned getNumIndices() const
Definition: Instructions.h:2643
llvm::ExtractValueInst::Create
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2470
RuntimeLibcalls.h
llvm::TargetTransformInfoWrapperPass
Wrapper pass for TargetTransformInfo.
Definition: TargetTransformInfo.h:2648
DEBUG_TYPE
#define DEBUG_TYPE
Definition: DwarfEHPrepare.cpp:44
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::PHINode::addIncoming
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
Definition: Instructions.h:2847
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::BranchInst::Create
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3188
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::isScopedEHPersonality
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
Definition: EHPersonalities.h:79
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:356
TargetPassConfig.h
llvm::InsertValueInst::idx_begin
idx_iterator idx_begin() const
Definition: Instructions.h:2613
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
llvm::TTI
TargetTransformInfo TTI
Definition: TargetTransformInfo.h:168
llvm::simplifyCFG
bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, DomTreeUpdater *DTU=nullptr, const SimplifyCFGOptions &Options={}, ArrayRef< WeakVH > LoopHeaders={})
Definition: SimplifyCFG.cpp:7328
Triple.h
llvm::CodeGenOpt::None
@ None
Definition: CodeGen.h:53
CFG.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::EHPersonality::GNU_CXX
@ GNU_CXX
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
llvm::BasicBlock::Create
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:97
TargetSubtargetInfo.h
llvm::CodeGenOpt::Level
Level
Definition: CodeGen.h:52
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:174
llvm::EHPersonality
EHPersonality
Definition: EHPersonalities.h:21
llvm::FunctionCallee::getCallee
Value * getCallee()
Definition: DerivedTypes.h:184
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:85
llvm::ResumeInst
Resume the propagation of an exception.
Definition: Instructions.h:4251
llvm::PHINode::Create
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
Definition: Instructions.h:2739
Casting.h
Function.h
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:221
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(DwarfEHPrepareLegacyPass, DEBUG_TYPE, "Prepare DWARF exceptions", false, false) INITIALIZE_PASS_END(DwarfEHPrepareLegacyPass
Instructions.h
SmallVector.h
Dominators.h
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:91
TargetTransformInfo.h
llvm::FunctionCallee
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:165
llvm::PHINode
Definition: Instructions.h:2697
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1845
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
DerivedTypes.h
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1474
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::UnreachableInst
This function has undefined behavior.
Definition: Instructions.h:4768
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::InsertValueInst
This instruction inserts a struct field of array element value into an aggregate value.
Definition: Instructions.h:2555
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1459
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103