LLVM: lib/Target/AMDGPU/AMDGPURewriteUndefForPHI.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
65
66using namespace llvm;
67
68#define DEBUG_TYPE "amdgpu-rewrite-undef-for-phi"
69
70namespace {
71
72class AMDGPURewriteUndefForPHILegacy : public FunctionPass {
73public:
74 static char ID;
77 }
80 return "AMDGPU Rewrite Undef for PHI";
81 }
82
86
89 }
90};
91
92}
93char AMDGPURewriteUndefForPHILegacy::ID = 0;
94
96 "Rewrite undef for PHI", false, false)
101
103 bool Changed = false;
105 for (auto &BB : F) {
106 for (auto &PHI : BB.phis()) {
107 if (UA.isDivergent(&PHI))
108 continue;
109
110
111 Value *UniqueDefinedIncoming = nullptr;
112
113
115
117
118 for (unsigned i = 0; i < PHI.getNumIncomingValues(); i++) {
120 BasicBlock *IncomingBB = PHI.getIncomingBlock(i);
121
123 continue;
124
125 if (isa(Incoming)) {
126
127 if (!DT->dominates(&BB, IncomingBB))
129 continue;
130 }
131
132 if (!UniqueDefinedIncoming) {
133 UniqueDefinedIncoming = Incoming;
134 DominateBB = IncomingBB;
135 } else if (Incoming == UniqueDefinedIncoming) {
136
137 if (DT->dominates(IncomingBB, DominateBB))
138 DominateBB = IncomingBB;
139 } else {
140 UniqueDefinedIncoming = nullptr;
141 break;
142 }
143 }
144
145
146
147
148 if (!UniqueDefinedIncoming || Undefs.empty() ||
150 continue;
151
152
153
154
155
157 return DT->dominates(DominateBB, UD);
158 })) {
159 PHI.replaceAllUsesWith(UniqueDefinedIncoming);
161 Changed = true;
162 }
163 }
164 }
165
166 for (auto *PHI : ToBeDeleted)
167 PHI->eraseFromParent();
168
169 return Changed;
170}
171
172bool AMDGPURewriteUndefForPHILegacy::runOnFunction(Function &F) {
174 getAnalysis().getUniformityInfo();
175 DominatorTree *DT = &getAnalysis().getDomTree();
177}
178
184 if (Changed) {
187 return PA;
188 }
189
191}
192
194 return new AMDGPURewriteUndefForPHILegacy();
195}
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
Rewrite undef for false bool rewritePHIs(Function &F, UniformityInfo &UA, DominatorTree *DT)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
LLVM IR instance of the generic uniformity analysis.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
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.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
LLVM Basic Block Representation.
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...
Represents analyses that only rely on functions' control flow.
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.
bool dominates(const BasicBlock *BB, const Use &U) const
Return true if the (end of the) basic block BB dominates the use U.
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
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.
Analysis pass which computes UniformityInfo.
Legacy analysis pass which computes a CycleInfo.
LLVM Value Representation.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
void initializeAMDGPURewriteUndefForPHILegacyPass(PassRegistry &)
FunctionPass * createAMDGPURewriteUndefForPHILegacyPass()
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...