1//===-- AMDGPUAnnotateUniformValues.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/// This pass adds amdgpu.uniform metadata to IR values so this information
11/// can be used during instruction selection.
12//
13//===----------------------------------------------------------------------===//
14
15#include "AMDGPU.h"
16#include "AMDGPUMemoryUtils.h"
17#include "Utils/AMDGPUBaseInfo.h"
18#include "llvm/Analysis/AliasAnalysis.h"
19#include "llvm/Analysis/MemorySSA.h"
20#include "llvm/Analysis/UniformityAnalysis.h"
21#include "llvm/IR/InstVisitor.h"
22#include "llvm/InitializePasses.h"
23
24#define DEBUG_TYPE "amdgpu-annotate-uniform"
25
26using namespace llvm;
27
28namespace {
29
30class AMDGPUAnnotateUniformValues
31 : public InstVisitor<AMDGPUAnnotateUniformValues> {
32 UniformityInfo *UA;
33 MemorySSA *MSSA;
34 AliasAnalysis *AA;
35 bool isEntryFunc;
36 bool Changed = false;
37
38 void setUniformMetadata(Instruction *I) {
39 I->setMetadata(Kind: "amdgpu.uniform", Node: MDNode::get(Context&: I->getContext(), MDs: {}));
40 Changed = true;
41 }
42
43 void setNoClobberMetadata(Instruction *I) {
44 I->setMetadata(Kind: "amdgpu.noclobber", Node: MDNode::get(Context&: I->getContext(), MDs: {}));
45 Changed = true;
46 }
47
48public:
49 AMDGPUAnnotateUniformValues(UniformityInfo &UA, MemorySSA &MSSA,
50 AliasAnalysis &AA, const Function &F)
51 : UA(&UA), MSSA(&MSSA), AA(&AA),
52 isEntryFunc(AMDGPU::isEntryFunctionCC(CC: F.getCallingConv())) {}
53
54 void visitCondBrInst(CondBrInst &I);
55 void visitLoadInst(LoadInst &I);
56
57 bool changed() const { return Changed; }
58};
59
60} // End anonymous namespace
61
62void AMDGPUAnnotateUniformValues::visitCondBrInst(CondBrInst &I) {
63 if (UA->isUniformTerminator(I: &I))
64 setUniformMetadata(&I);
65}
66
67void AMDGPUAnnotateUniformValues::visitLoadInst(LoadInst &I) {
68 Value *Ptr = I.getPointerOperand();
69 if (UA->isDivergentAtDef(V: Ptr))
70 return;
71 Instruction *PtrI = dyn_cast<Instruction>(Val: Ptr);
72 if (PtrI)
73 setUniformMetadata(PtrI);
74
75 // We're tracking up to the Function boundaries, and cannot go beyond because
76 // of FunctionPass restrictions. We can ensure that is memory not clobbered
77 // for memory operations that are live in to entry points only.
78 if (!isEntryFunc)
79 return;
80
81 // If I is atomic or volatile, it might see the effects of concurrent
82 // clobbering accesses, so local clobber analysis is not sufficient to ensure
83 // that it sees the initial value.
84 if (!I.isSimple())
85 return;
86
87 bool GlobalLoad = I.getPointerAddressSpace() == AMDGPUAS::GLOBAL_ADDRESS;
88 if (GlobalLoad && !AMDGPU::isClobberedInFunction(Load: &I, MSSA, AA))
89 setNoClobberMetadata(&I);
90}
91
92PreservedAnalyses
93AMDGPUAnnotateUniformValuesPass::run(Function &F,
94 FunctionAnalysisManager &FAM) {
95 UniformityInfo &UI = FAM.getResult<UniformityInfoAnalysis>(IR&: F);
96 MemorySSA &MSSA = FAM.getResult<MemorySSAAnalysis>(IR&: F).getMSSA();
97 AAResults &AA = FAM.getResult<AAManager>(IR&: F);
98
99 AMDGPUAnnotateUniformValues Impl(UI, MSSA, AA, F);
100 Impl.visit(F);
101
102 if (!Impl.changed())
103 return PreservedAnalyses::all();
104
105 PreservedAnalyses PA = PreservedAnalyses::none();
106 // TODO: Should preserve nearly everything
107 PA.preserveSet<CFGAnalyses>();
108 return PA;
109}
110
111class AMDGPUAnnotateUniformValuesLegacy : public FunctionPass {
112public:
113 static char ID;
114
115 AMDGPUAnnotateUniformValuesLegacy() : FunctionPass(ID) {}
116
117 bool doInitialization(Module &M) override { return false; }
118
119 bool runOnFunction(Function &F) override;
120 StringRef getPassName() const override {
121 return "AMDGPU Annotate Uniform Values";
122 }
123
124 void getAnalysisUsage(AnalysisUsage &AU) const override {
125 AU.addRequired<UniformityInfoWrapperPass>();
126 AU.addRequired<MemorySSAWrapperPass>();
127 AU.addRequired<AAResultsWrapperPass>();
128 AU.setPreservesAll();
129 }
130};
131
132bool AMDGPUAnnotateUniformValuesLegacy::runOnFunction(Function &F) {
133 if (skipFunction(F))
134 return false;
135
136 UniformityInfo &UI =
137 getAnalysis<UniformityInfoWrapperPass>().getUniformityInfo();
138 MemorySSA &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
139 AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
140
141 AMDGPUAnnotateUniformValues Impl(UI, MSSA, AA, F);
142 Impl.visit(F);
143 return Impl.changed();
144}
145
146INITIALIZE_PASS_BEGIN(AMDGPUAnnotateUniformValuesLegacy, DEBUG_TYPE,
147 "Add AMDGPU uniform metadata", false, false)
148INITIALIZE_PASS_DEPENDENCY(UniformityInfoWrapperPass)
149INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)
150INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
151INITIALIZE_PASS_END(AMDGPUAnnotateUniformValuesLegacy, DEBUG_TYPE,
152 "Add AMDGPU uniform metadata", false, false)
153
154char AMDGPUAnnotateUniformValuesLegacy::ID = 0;
155
156FunctionPass *llvm::createAMDGPUAnnotateUniformValuesLegacy() {
157 return new AMDGPUAnnotateUniformValuesLegacy();
158}
159