24#include "llvm/IR/IntrinsicsAMDGPU.h"
32#define DEBUG_TYPE "si-annotate-control-flow"
37using StackEntry = std::pair<BasicBlock *, Value *>;
40class SIAnnotateControlFlow {
79 bool eraseIfUnused(
PHINode *Phi);
96 : UA(&UA), DT(&DT), LI(&LI) {
112 :
Type::getInt64Ty(Context);
118 IntMaskZero = ConstantInt::get(IntMask, 0);
122 { IntMask, IntMask });
131bool SIAnnotateControlFlow::isUniform(
BranchInst *
T) {
132 return UA->isUniform(
T) ||
T->hasMetadata(
"structurizecfg.uniform");
136bool SIAnnotateControlFlow::isTopOfStack(
BasicBlock *BB) {
137 return !
Stack.empty() &&
Stack.back().first == BB;
141Value *SIAnnotateControlFlow::popSaved() {
142 return Stack.pop_back_val().second;
152bool SIAnnotateControlFlow::isElse(
PHINode *Phi) {
153 BasicBlock *IDom = DT->getNode(
Phi->getParent())->getIDom()->getBlock();
154 for (
unsigned i = 0, e =
Phi->getNumIncomingValues(); i != e; ++i) {
155 if (
Phi->getIncomingBlock(i) == IDom) {
157 if (
Phi->getIncomingValue(i) != BoolTrue)
161 if (
Phi->getIncomingValue(i) != BoolFalse)
169bool SIAnnotateControlFlow::hasKill(
const BasicBlock *BB) {
171 if (
const CallInst *CI = dyn_cast<CallInst>(&
I))
172 if (CI->getIntrinsicID() == Intrinsic::amdgcn_kill)
179bool SIAnnotateControlFlow::eraseIfUnused(
PHINode *Phi) {
187bool SIAnnotateControlFlow::openIf(
BranchInst *Term) {
192 Value *IfCall = IRB.CreateCall(If, {
Term->getCondition()});
193 Value *
Cond = IRB.CreateExtractValue(IfCall, {0});
194 Value *
Mask = IRB.CreateExtractValue(IfCall, {1});
201bool SIAnnotateControlFlow::insertElse(
BranchInst *Term) {
202 if (isUniform(Term)) {
207 Value *ElseCall = IRB.CreateCall(Else, {popSaved()});
208 Value *
Cond = IRB.CreateExtractValue(ElseCall, {0});
209 Value *
Mask = IRB.CreateExtractValue(ElseCall, {1});
216Value *SIAnnotateControlFlow::handleLoopCondition(
226 if (
L->contains(Inst)) {
229 Insert =
L->getHeader()->getFirstNonPHIOrDbgOrLifetime();
232 return CreateBreak(Insert);
236 if (isa<Constant>(
Cond)) {
238 Term :
L->getHeader()->getTerminator();
240 return CreateBreak(Insert);
243 if (isa<Argument>(
Cond)) {
245 return CreateBreak(Insert);
252bool SIAnnotateControlFlow::handleLoop(
BranchInst *Term) {
266 Term->setCondition(BoolTrue);
267 Value *Arg = handleLoopCondition(
Cond, Broken, L, Term);
270 Value *PHIValue = IntMaskZero;
276 else if (
L->contains(Pred) && DT->dominates(Pred, BB))
282 Term->setCondition(LoopCall);
290bool SIAnnotateControlFlow::closeControlFlow(
BasicBlock *BB) {
295 if (L &&
L->getHeader() == BB) {
299 SmallVector <BasicBlock *, 8> Latches;
300 L->getLoopLatches(Latches);
314 if (!isa<UndefValue>(Exec) && !isa<UnreachableInst>(FirstInsertionPt)) {
317 if (!DT->dominates(DefBB, BB)) {
321 IRBuilder<> IRB(FirstInsertionPt->getParent(), FirstInsertionPt);
325 IRB.SetCurrentDebugLocation(
DebugLoc());
326 IRB.CreateCall(EndCf, {
Exec});
334bool SIAnnotateControlFlow::run(
Function &
F) {
335 bool Changed =
false;
338 E =
df_end(&
F.getEntryBlock());
I != E; ++
I) {
342 if (!Term ||
Term->isUnconditional()) {
343 if (isTopOfStack(BB))
344 Changed |= closeControlFlow(BB);
349 if (
I.nodeVisited(
Term->getSuccessor(1))) {
350 if (isTopOfStack(BB))
351 Changed |= closeControlFlow(BB);
353 if (DT->dominates(
Term->getSuccessor(1), BB))
354 Changed |= handleLoop(Term);
358 if (isTopOfStack(BB)) {
360 if (Phi &&
Phi->getParent() == BB && isElse(Phi) && !hasKill(BB)) {
361 Changed |= insertElse(Term);
362 Changed |= eraseIfUnused(Phi);
366 Changed |= closeControlFlow(BB);
369 Changed |= openIf(Term);
372 if (!
Stack.empty()) {
388 SIAnnotateControlFlow Impl(*
F.getParent(), ST, DT, LI, UI);
391 bool Changed = Impl.run(
F);
416 FunctionPass::getAnalysisUsage(AU);
420 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
421 LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
423 getAnalysis<UniformityInfoWrapperPass>().getUniformityInfo();
428 SIAnnotateControlFlow Impl(*
F.getParent(), ST, DT, LI, UI);
434 "Annotate SI Control Flow",
false,
false)
The AMDGPU TargetMachine interface definition for hw codegen targets.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Fixup Statepoint Caller Saved
AMD GCN specific subclass of TargetSubtarget.
FunctionAnalysisManager FAM
const char LLVMTargetMachineRef TM
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames)
Initialize the set of available library functions based on the specified target triple.
Target-Independent Code Generator Pass Configuration Options pass.
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
SIAnnotateControlFlowLegacy()
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
LLVM Basic Block Representation.
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
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...
Conditional or Unconditional Branch instruction.
This class represents a function call, abstracting a target machine's calling convention.
This is the shared class of boolean and integer constants.
static ConstantInt * getTrue(LLVMContext &Context)
static ConstantInt * getFalse(LLVMContext &Context)
This is an important base class in LLVM.
Analysis pass which computes a DominatorTree.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
FunctionPass class - This class is used to implement most global optimizations.
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
void insertBefore(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately before the specified instruction.
This is an important class for using LLVM in a threaded context.
Analysis pass that exposes the LoopInfo for a function.
The legacy pass manager's analysis pass to compute loop information.
Represents a single loop in the control flow graph.
A Module instance is used to store all the information related to an LLVM module.
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
void preserve()
Mark an analysis as preserved.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Primary interface to the complete machine description for the target machine.
const STC & getSubtarget(const Function &F) const
This method returns a pointer to the specified type of TargetSubtargetInfo.
Target-Independent Code Generator Pass Configuration Options.
TMC & getTM() const
Get the right type of TargetMachine for this target.
Target - Wrapper for Target specific information.
The instances of the Type class are immutable: once they are created, they are never changed.
static IntegerType * getInt1Ty(LLVMContext &C)
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
'undef' values are things that do not have specified contents.
LLVM Value Representation.
const ParentTy * getParent() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
NodeAddr< PhiNode * > Phi
This is an optimization pass for GlobalISel generic memory operations.
FunctionPass * createSIAnnotateControlFlowLegacyPass()
Create the annotation pass.
df_iterator< T > df_begin(const T &G)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
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...
auto predecessors(const MachineBasicBlock *BB)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
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...
df_iterator< T > df_end(const T &G)
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...