LLVM  15.0.0git
SIAnnotateControlFlow.cpp
Go to the documentation of this file.
1 //===- SIAnnotateControlFlow.cpp ------------------------------------------===//
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 /// \file
10 /// Annotates the control flow with hardware specific intrinsics.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "AMDGPU.h"
15 #include "GCNSubtarget.h"
17 #include "llvm/Analysis/LoopInfo.h"
19 #include "llvm/IR/BasicBlock.h"
20 #include "llvm/IR/Constants.h"
21 #include "llvm/IR/Dominators.h"
22 #include "llvm/IR/IntrinsicsAMDGPU.h"
23 #include "llvm/InitializePasses.h"
27 
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "si-annotate-control-flow"
31 
32 namespace {
33 
34 // Complex types used in this pass
35 using StackEntry = std::pair<BasicBlock *, Value *>;
36 using StackVector = SmallVector<StackEntry, 16>;
37 
38 class SIAnnotateControlFlow : public FunctionPass {
40 
41  Type *Boolean;
42  Type *Void;
43  Type *IntMask;
44  Type *ReturnStruct;
45 
46  ConstantInt *BoolTrue;
47  ConstantInt *BoolFalse;
48  UndefValue *BoolUndef;
49  Constant *IntMaskZero;
50 
51  Function *If;
52  Function *Else;
53  Function *IfBreak;
54  Function *Loop;
55  Function *EndCf;
56 
57  DominatorTree *DT;
58  StackVector Stack;
59 
60  LoopInfo *LI;
61 
62  void initialize(Module &M, const GCNSubtarget &ST);
63 
64  bool isUniform(BranchInst *T);
65 
66  bool isTopOfStack(BasicBlock *BB);
67 
68  Value *popSaved();
69 
70  void push(BasicBlock *BB, Value *Saved);
71 
72  bool isElse(PHINode *Phi);
73 
74  bool hasKill(const BasicBlock *BB);
75 
76  bool eraseIfUnused(PHINode *Phi);
77 
78  bool openIf(BranchInst *Term);
79 
80  bool insertElse(BranchInst *Term);
81 
82  Value *
83  handleLoopCondition(Value *Cond, PHINode *Broken, llvm::Loop *L,
84  BranchInst *Term);
85 
86  bool handleLoop(BranchInst *Term);
87 
88  bool closeControlFlow(BasicBlock *BB);
89 
90 public:
91  static char ID;
92 
93  SIAnnotateControlFlow() : FunctionPass(ID) {}
94 
95  bool runOnFunction(Function &F) override;
96 
97  StringRef getPassName() const override { return "SI annotate control flow"; }
98 
99  void getAnalysisUsage(AnalysisUsage &AU) const override {
107  }
108 };
109 
110 } // end anonymous namespace
111 
112 INITIALIZE_PASS_BEGIN(SIAnnotateControlFlow, DEBUG_TYPE,
113  "Annotate SI Control Flow", false, false)
117 INITIALIZE_PASS_END(SIAnnotateControlFlow, DEBUG_TYPE,
118  "Annotate SI Control Flow", false, false)
119 
120 char SIAnnotateControlFlow::ID = 0;
121 
122 /// Initialize all the types and constants used in the pass
123 void SIAnnotateControlFlow::initialize(Module &M, const GCNSubtarget &ST) {
124  LLVMContext &Context = M.getContext();
125 
126  Void = Type::getVoidTy(Context);
128  IntMask = ST.isWave32() ? Type::getInt32Ty(Context)
130  ReturnStruct = StructType::get(Boolean, IntMask);
131 
132  BoolTrue = ConstantInt::getTrue(Context);
133  BoolFalse = ConstantInt::getFalse(Context);
134  BoolUndef = UndefValue::get(Boolean);
135  IntMaskZero = ConstantInt::get(IntMask, 0);
136 
137  If = Intrinsic::getDeclaration(&M, Intrinsic::amdgcn_if, { IntMask });
138  Else = Intrinsic::getDeclaration(&M, Intrinsic::amdgcn_else,
139  { IntMask, IntMask });
140  IfBreak = Intrinsic::getDeclaration(&M, Intrinsic::amdgcn_if_break,
141  { IntMask });
142  Loop = Intrinsic::getDeclaration(&M, Intrinsic::amdgcn_loop, { IntMask });
143  EndCf = Intrinsic::getDeclaration(&M, Intrinsic::amdgcn_end_cf, { IntMask });
144 }
145 
146 /// Is the branch condition uniform or did the StructurizeCFG pass
147 /// consider it as such?
148 bool SIAnnotateControlFlow::isUniform(BranchInst *T) {
149  return DA->isUniform(T) ||
150  T->getMetadata("structurizecfg.uniform") != nullptr;
151 }
152 
153 /// Is BB the last block saved on the stack ?
154 bool SIAnnotateControlFlow::isTopOfStack(BasicBlock *BB) {
155  return !Stack.empty() && Stack.back().first == BB;
156 }
157 
158 /// Pop the last saved value from the control flow stack
159 Value *SIAnnotateControlFlow::popSaved() {
160  return Stack.pop_back_val().second;
161 }
162 
163 /// Push a BB and saved value to the control flow stack
165  Stack.push_back(std::make_pair(BB, Saved));
166 }
167 
168 /// Can the condition represented by this PHI node treated like
169 /// an "Else" block?
170 bool SIAnnotateControlFlow::isElse(PHINode *Phi) {
171  BasicBlock *IDom = DT->getNode(Phi->getParent())->getIDom()->getBlock();
172  for (unsigned i = 0, e = Phi->getNumIncomingValues(); i != e; ++i) {
173  if (Phi->getIncomingBlock(i) == IDom) {
174 
175  if (Phi->getIncomingValue(i) != BoolTrue)
176  return false;
177 
178  } else {
179  if (Phi->getIncomingValue(i) != BoolFalse)
180  return false;
181 
182  }
183  }
184  return true;
185 }
186 
187 bool SIAnnotateControlFlow::hasKill(const BasicBlock *BB) {
188  for (const Instruction &I : *BB) {
189  if (const CallInst *CI = dyn_cast<CallInst>(&I))
190  if (CI->getIntrinsicID() == Intrinsic::amdgcn_kill)
191  return true;
192  }
193  return false;
194 }
195 
196 // Erase "Phi" if it is not used any more. Return true if any change was made.
197 bool SIAnnotateControlFlow::eraseIfUnused(PHINode *Phi) {
198  bool Changed = RecursivelyDeleteDeadPHINode(Phi);
199  if (Changed)
200  LLVM_DEBUG(dbgs() << "Erased unused condition phi\n");
201  return Changed;
202 }
203 
204 /// Open a new "If" block
205 bool SIAnnotateControlFlow::openIf(BranchInst *Term) {
206  if (isUniform(Term))
207  return false;
208 
209  Value *Ret = CallInst::Create(If, Term->getCondition(), "", Term);
210  Term->setCondition(ExtractValueInst::Create(Ret, 0, "", Term));
211  push(Term->getSuccessor(1), ExtractValueInst::Create(Ret, 1, "", Term));
212  return true;
213 }
214 
215 /// Close the last "If" block and open a new "Else" block
216 bool SIAnnotateControlFlow::insertElse(BranchInst *Term) {
217  if (isUniform(Term)) {
218  return false;
219  }
220  Value *Ret = CallInst::Create(Else, popSaved(), "", Term);
221  Term->setCondition(ExtractValueInst::Create(Ret, 0, "", Term));
222  push(Term->getSuccessor(1), ExtractValueInst::Create(Ret, 1, "", Term));
223  return true;
224 }
225 
226 /// Recursively handle the condition leading to a loop
227 Value *SIAnnotateControlFlow::handleLoopCondition(
228  Value *Cond, PHINode *Broken, llvm::Loop *L, BranchInst *Term) {
229  if (Instruction *Inst = dyn_cast<Instruction>(Cond)) {
230  BasicBlock *Parent = Inst->getParent();
232  if (L->contains(Inst)) {
233  Insert = Parent->getTerminator();
234  } else {
236  }
237 
238  Value *Args[] = { Cond, Broken };
239  return CallInst::Create(IfBreak, Args, "", Insert);
240  }
241 
242  // Insert IfBreak in the loop header TERM for constant COND other than true.
243  if (isa<Constant>(Cond)) {
244  Instruction *Insert = Cond == BoolTrue ?
245  Term : L->getHeader()->getTerminator();
246 
247  Value *Args[] = { Cond, Broken };
248  return CallInst::Create(IfBreak, Args, "", Insert);
249  }
250 
251  if (isa<Argument>(Cond)) {
253  Value *Args[] = { Cond, Broken };
254  return CallInst::Create(IfBreak, Args, "", Insert);
255  }
256 
257  llvm_unreachable("Unhandled loop condition!");
258 }
259 
260 /// Handle a back edge (loop)
261 bool SIAnnotateControlFlow::handleLoop(BranchInst *Term) {
262  if (isUniform(Term))
263  return false;
264 
265  BasicBlock *BB = Term->getParent();
266  llvm::Loop *L = LI->getLoopFor(BB);
267  if (!L)
268  return false;
269 
270  BasicBlock *Target = Term->getSuccessor(1);
271  PHINode *Broken = PHINode::Create(IntMask, 0, "phi.broken", &Target->front());
272 
273  Value *Cond = Term->getCondition();
274  Term->setCondition(BoolTrue);
275  Value *Arg = handleLoopCondition(Cond, Broken, L, Term);
276 
277  for (BasicBlock *Pred : predecessors(Target)) {
278  Value *PHIValue = IntMaskZero;
279  if (Pred == BB) // Remember the value of the previous iteration.
280  PHIValue = Arg;
281  // If the backedge from Pred to Target could be executed before the exit
282  // of the loop at BB, it should not reset or change "Broken", which keeps
283  // track of the number of threads exited the loop at BB.
284  else if (L->contains(Pred) && DT->dominates(Pred, BB))
285  PHIValue = Broken;
286  Broken->addIncoming(PHIValue, Pred);
287  }
288 
289  Term->setCondition(CallInst::Create(Loop, Arg, "", Term));
290 
291  push(Term->getSuccessor(0), Arg);
292 
293  return true;
294 }
295 
296 /// Close the last opened control flow
297 bool SIAnnotateControlFlow::closeControlFlow(BasicBlock *BB) {
298  llvm::Loop *L = LI->getLoopFor(BB);
299 
300  assert(Stack.back().first == BB);
301 
302  if (L && L->getHeader() == BB) {
303  // We can't insert an EndCF call into a loop header, because it will
304  // get executed on every iteration of the loop, when it should be
305  // executed only once before the loop.
307  L->getLoopLatches(Latches);
308 
310  for (BasicBlock *Pred : predecessors(BB)) {
311  if (!is_contained(Latches, Pred))
312  Preds.push_back(Pred);
313  }
314 
315  BB = SplitBlockPredecessors(BB, Preds, "endcf.split", DT, LI, nullptr,
316  false);
317  }
318 
319  Value *Exec = popSaved();
320  Instruction *FirstInsertionPt = &*BB->getFirstInsertionPt();
321  if (!isa<UndefValue>(Exec) && !isa<UnreachableInst>(FirstInsertionPt)) {
322  Instruction *ExecDef = cast<Instruction>(Exec);
323  BasicBlock *DefBB = ExecDef->getParent();
324  if (!DT->dominates(DefBB, BB)) {
325  // Split edge to make Def dominate Use
326  FirstInsertionPt = &*SplitEdge(DefBB, BB, DT, LI)->getFirstInsertionPt();
327  }
328  CallInst::Create(EndCf, Exec, "", FirstInsertionPt);
329  }
330 
331  return true;
332 }
333 
334 /// Annotate the control flow with intrinsics so the backend can
335 /// recognize if/then/else and loops.
337  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
338  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
339  DA = &getAnalysis<LegacyDivergenceAnalysis>();
340  TargetPassConfig &TPC = getAnalysis<TargetPassConfig>();
341  const TargetMachine &TM = TPC.getTM<TargetMachine>();
342 
343  bool Changed = false;
344  initialize(*F.getParent(), TM.getSubtarget<GCNSubtarget>(F));
345  for (df_iterator<BasicBlock *> I = df_begin(&F.getEntryBlock()),
346  E = df_end(&F.getEntryBlock()); I != E; ++I) {
347  BasicBlock *BB = *I;
348  BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());
349 
350  if (!Term || Term->isUnconditional()) {
351  if (isTopOfStack(BB))
352  Changed |= closeControlFlow(BB);
353 
354  continue;
355  }
356 
357  if (I.nodeVisited(Term->getSuccessor(1))) {
358  if (isTopOfStack(BB))
359  Changed |= closeControlFlow(BB);
360 
361  if (DT->dominates(Term->getSuccessor(1), BB))
362  Changed |= handleLoop(Term);
363  continue;
364  }
365 
366  if (isTopOfStack(BB)) {
367  PHINode *Phi = dyn_cast<PHINode>(Term->getCondition());
368  if (Phi && Phi->getParent() == BB && isElse(Phi) && !hasKill(BB)) {
369  Changed |= insertElse(Term);
370  Changed |= eraseIfUnused(Phi);
371  continue;
372  }
373 
374  Changed |= closeControlFlow(BB);
375  }
376 
377  Changed |= openIf(Term);
378  }
379 
380  if (!Stack.empty()) {
381  // CFG was probably not structured.
382  report_fatal_error("failed to annotate CFG");
383  }
384 
385  return Changed;
386 }
387 
388 /// Create the annotation pass
390  return new SIAnnotateControlFlow();
391 }
i
i
Definition: README.txt:29
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::StructType::get
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:406
llvm::Intrinsic::getDeclaration
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1418
Insert
Vector Rotate Left Mask Mask Insert
Definition: README_P9.txt:112
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:104
llvm::Function
Definition: Function.h:60
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:546
llvm::LoopBase::contains
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:138
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:145
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::df_end
df_iterator< T > df_end(const T &G)
Definition: DepthFirstIterator.h:224
push
static void push(SmallVectorImpl< uint64_t > &R, StringRef Str)
Definition: BitstreamRemarkSerializer.cpp:24
Local.h
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
Saved
Fixup Statepoint Caller Saved
Definition: FixupStatepointCallerSaved.cpp:89
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Boolean
unsigned char Boolean
Definition: ConvertUTF.h:115
llvm::LoopInfoWrapperPass
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:1287
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::GCNSubtarget
Definition: GCNSubtarget.h:31
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:119
initialize
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames)
Initialize the set of available library functions based on the specified target triple.
Definition: TargetLibraryInfo.cpp:116
llvm::tgtok::Else
@ Else
Definition: TGLexer.h:76
llvm::Type::getInt32Ty
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::RecursivelyDeleteDeadPHINode
bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)
If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...
Definition: Local.cpp:627
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:186
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::LoopBase::getLoopLatches
void getLoopLatches(SmallVectorImpl< BlockT * > &LoopLatches) const
Return all loop latch blocks of this loop.
Definition: LoopInfo.h:350
TargetMachine.h
Constants.h
llvm::PHINode::getIncomingValue
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
Definition: Instructions.h:2747
GCNSubtarget.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1504
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
DEBUG_TYPE
#define DEBUG_TYPE
Definition: SIAnnotateControlFlow.cpp:30
llvm::BasicBlock::getFirstInsertionPt
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:246
false
Definition: StackSlotColoring.cpp:141
llvm::M68kBeads::DA
@ DA
Definition: M68kBaseInfo.h:59
llvm::Instruction
Definition: Instruction.h:42
llvm::DominatorTreeWrapperPass
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:302
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::predecessors
auto predecessors(MachineBasicBlock *BB)
Definition: MachineSSAContext.h:30
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1777
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:928
llvm::LegacyDivergenceAnalysis
Definition: LegacyDivergenceAnalysis.h:31
llvm::tgtok::If
@ If
Definition: TGLexer.h:51
llvm::SplitBlockPredecessors
BasicBlock * SplitBlockPredecessors(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, bool PreserveLCSSA=false)
This method introduces at least one new basic block into the function and moves some of the predecess...
Definition: BasicBlockUtils.cpp:1176
llvm::PHINode::getNumIncomingValues
unsigned getNumIncomingValues() const
Return the number of incoming edges.
Definition: Instructions.h:2743
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(SIAnnotateControlFlow, DEBUG_TYPE, "Annotate SI Control Flow", false, false) INITIALIZE_PASS_END(SIAnnotateControlFlow
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
LoopInfo.h
llvm::TargetPassConfig
Target-Independent Code Generator Pass Configuration Options.
Definition: TargetPassConfig.h:84
BasicBlock.h
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::ExtractValueInst::Create
static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:2424
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
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:2801
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::M68kBeads::Term
@ Term
Definition: M68kBaseInfo.h:71
llvm::UndefValue
'undef' values are things that do not have specified contents.
Definition: Constants.h:1386
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1682
TargetPassConfig.h
llvm::df_begin
df_iterator< T > df_begin(const T &G)
Definition: DepthFirstIterator.h:219
llvm::pdb::PDB_MemoryType::Stack
@ Stack
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::df_iterator
Definition: DepthFirstIterator.h:86
llvm::LoopInfo
Definition: LoopInfo.h:1102
Control
bool Control
Definition: README.txt:468
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:137
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
AMDGPU.h
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
llvm::TargetPassConfig::getTM
TMC & getTM() const
Get the right type of TargetMachine for this target.
Definition: TargetPassConfig.h:151
llvm::ConstantInt::getFalse
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:883
runOnFunction
static bool runOnFunction(Function &F, bool PostInlining)
Definition: EntryExitInstrumenter.cpp:69
llvm::SplitEdge
BasicBlock * SplitEdge(BasicBlock *From, BasicBlock *To, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, const Twine &BBName="")
Split the edge connecting the specified blocks, and return the newly created basic block between From...
Definition: BasicBlockUtils.cpp:516
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
llvm::ConstantInt::getTrue
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:876
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:2693
llvm::LoopBase::getHeader
BlockT * getHeader() const
Definition: LoopInfo.h:104
llvm::BasicBlock::getFirstNonPHIOrDbgOrLifetime
const Instruction * getFirstNonPHIOrDbgOrLifetime(bool SkipPseudoOp=true) const
Returns a pointer to the first instruction in this block that is not a PHINode, a debug intrinsic,...
Definition: BasicBlock.cpp:230
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:222
LegacyDivergenceAnalysis.h
Flow
Annotate SI Control Flow
Definition: SIAnnotateControlFlow.cpp:118
Dominators.h
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:91
llvm::PHINode::getIncomingBlock
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
Definition: Instructions.h:2767
llvm::PHINode
Definition: Instructions.h:2651
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.h:119
llvm::createSIAnnotateControlFlowPass
FunctionPass * createSIAnnotateControlFlowPass()
Create the annotation pass.
Definition: SIAnnotateControlFlow.cpp:389
llvm::Pass::getAnalysisUsage
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:97
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:1461
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::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3086
BasicBlockUtils.h
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38