LLVM  10.0.0svn
AMDGPUAnnotateUniformValues.cpp
Go to the documentation of this file.
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 "llvm/ADT/SetVector.h"
18 #include "llvm/Analysis/LoopInfo.h"
20 #include "llvm/IR/IRBuilder.h"
21 #include "llvm/IR/InstVisitor.h"
22 #include "llvm/Support/Debug.h"
24 
25 #define DEBUG_TYPE "amdgpu-annotate-uniform"
26 
27 using namespace llvm;
28 
29 namespace {
30 
31 class AMDGPUAnnotateUniformValues : public FunctionPass,
32  public InstVisitor<AMDGPUAnnotateUniformValues> {
35  LoopInfo *LI;
37  bool isKernelFunc;
38 
39 public:
40  static char ID;
41  AMDGPUAnnotateUniformValues() :
42  FunctionPass(ID) { }
43  bool doInitialization(Module &M) override;
44  bool runOnFunction(Function &F) override;
45  StringRef getPassName() const override {
46  return "AMDGPU Annotate Uniform Values";
47  }
48  void getAnalysisUsage(AnalysisUsage &AU) const override {
52  AU.setPreservesAll();
53  }
54 
55  void visitBranchInst(BranchInst &I);
56  void visitLoadInst(LoadInst &I);
57  bool isClobberedInFunction(LoadInst * Load);
58 };
59 
60 } // End anonymous namespace
61 
62 INITIALIZE_PASS_BEGIN(AMDGPUAnnotateUniformValues, DEBUG_TYPE,
63  "Add AMDGPU uniform metadata", false, false)
67 INITIALIZE_PASS_END(AMDGPUAnnotateUniformValues, DEBUG_TYPE,
69 
70 char AMDGPUAnnotateUniformValues::ID = 0;
71 
73  I->setMetadata("amdgpu.uniform", MDNode::get(I->getContext(), {}));
74 }
76  I->setMetadata("amdgpu.noclobber", MDNode::get(I->getContext(), {}));
77 }
78 
79 static void DFS(BasicBlock *Root, SetVector<BasicBlock*> & Set) {
80  for (auto I : predecessors(Root))
81  if (Set.insert(I))
82  DFS(I, Set);
83 }
84 
85 bool AMDGPUAnnotateUniformValues::isClobberedInFunction(LoadInst * Load) {
86  // 1. get Loop for the Load->getparent();
87  // 2. if it exists, collect all the BBs from the most outer
88  // loop and check for the writes. If NOT - start DFS over all preds.
89  // 3. Start DFS over all preds from the most outer loop header.
90  SetVector<BasicBlock *> Checklist;
91  BasicBlock *Start = Load->getParent();
92  Checklist.insert(Start);
93  const Value *Ptr = Load->getPointerOperand();
94  const Loop *L = LI->getLoopFor(Start);
95  if (L) {
96  const Loop *P = L;
97  do {
98  L = P;
99  P = P->getParentLoop();
100  } while (P);
101  Checklist.insert(L->block_begin(), L->block_end());
102  Start = L->getHeader();
103  }
104 
105  DFS(Start, Checklist);
106  for (auto &BB : Checklist) {
107  BasicBlock::iterator StartIt = (!L && (BB == Load->getParent())) ?
108  BasicBlock::iterator(Load) : BB->end();
109  auto Q = MDR->getPointerDependencyFrom(MemoryLocation(Ptr), true,
110  StartIt, BB, Load);
111  if (Q.isClobber() || Q.isUnknown())
112  return true;
113  }
114  return false;
115 }
116 
117 void AMDGPUAnnotateUniformValues::visitBranchInst(BranchInst &I) {
118  if (DA->isUniform(&I))
120 }
121 
122 void AMDGPUAnnotateUniformValues::visitLoadInst(LoadInst &I) {
123  Value *Ptr = I.getPointerOperand();
124  if (!DA->isUniform(Ptr))
125  return;
126  auto isGlobalLoad = [&](LoadInst &Load)->bool {
128  };
129  // We're tracking up to the Function boundaries
130  // We cannot go beyond because of FunctionPass restrictions
131  // Thus we can ensure that memory not clobbered for memory
132  // operations that live in kernel only.
133  bool NotClobbered = isKernelFunc && !isClobberedInFunction(&I);
134  Instruction *PtrI = dyn_cast<Instruction>(Ptr);
135  if (!PtrI && NotClobbered && isGlobalLoad(I)) {
136  if (isa<Argument>(Ptr) || isa<GlobalValue>(Ptr)) {
137  // Lookup for the existing GEP
138  if (noClobberClones.count(Ptr)) {
139  PtrI = noClobberClones[Ptr];
140  } else {
141  // Create GEP of the Value
142  Function *F = I.getParent()->getParent();
144  Type::getInt32Ty(Ptr->getContext()), APInt(64, 0));
145  // Insert GEP at the entry to make it dominate all uses
147  Ptr->getType()->getPointerElementType(), Ptr,
149  }
150  I.replaceUsesOfWith(Ptr, PtrI);
151  }
152  }
153 
154  if (PtrI) {
155  setUniformMetadata(PtrI);
156  if (NotClobbered)
157  setNoClobberMetadata(PtrI);
158  }
159 }
160 
161 bool AMDGPUAnnotateUniformValues::doInitialization(Module &M) {
162  return false;
163 }
164 
166  if (skipFunction(F))
167  return false;
168 
169  DA = &getAnalysis<LegacyDivergenceAnalysis>();
170  MDR = &getAnalysis<MemoryDependenceWrapperPass>().getMemDep();
171  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
172  isKernelFunc = F.getCallingConv() == CallingConv::AMDGPU_KERNEL;
173 
174  visit(F);
175  noClobberClones.clear();
176  return true;
177 }
178 
179 FunctionPass *
181  return new AMDGPUAnnotateUniformValues();
182 }
Provides a lazy, caching interface for making common memory aliasing information queries, backed by LLVM&#39;s alias analysis passes.
Base class for instruction visitors.
Definition: InstVisitor.h:80
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value *> IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:901
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:745
F(f)
An instruction for reading from memory.
Definition: Instructions.h:167
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.cpp:137
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:50
Type * getPointerElementType() const
Definition: Type.h:376
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Address space for global memory (RAT0, VTX0).
Definition: AMDGPU.h:270
T uniform(GenT &Gen, T Min, T Max)
Return a uniformly distributed random value between Min and Max.
Definition: Random.h:21
BlockT * getHeader() const
Definition: LoopInfo.h:105
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void replaceUsesOfWith(Value *From, Value *To)
Replace uses of one Value with another.
Definition: User.cpp:20
const BasicBlock & getEntryBlock() const
Definition: Function.h:664
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1165
static bool runOnFunction(Function &F, bool PostInlining)
#define P(N)
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:189
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
Conditional or Unconditional Branch instruction.
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
Value * getPointerOperand()
Definition: Instructions.h:284
static void setNoClobberMetadata(Instruction *I)
#define DEBUG_TYPE
A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance...
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Add AMDGPU uniform metadata
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1222
FunctionPass * createAMDGPUAnnotateUniformValues()
static Constant * getIntegerValue(Type *Ty, const APInt &V)
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value...
Definition: Constants.cpp:311
Representation for a specific memory location.
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:200
Iterator for intrusive lists based on ilist_node.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:212
pred_range predecessors(BasicBlock *BB)
Definition: CFG.h:124
INITIALIZE_PASS_BEGIN(AMDGPUAnnotateUniformValues, DEBUG_TYPE, "Add AMDGPU uniform metadata", false, false) INITIALIZE_PASS_END(AMDGPUAnnotateUniformValues
Class for arbitrary precision integers.
Definition: APInt.h:69
void setPreservesAll()
Set by analyses that do not transform their input at all.
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:89
static void DFS(BasicBlock *Root, SetVector< BasicBlock *> &Set)
LoopT * getParentLoop() const
Definition: LoopInfo.h:106
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:175
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:509
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
#define I(x, y, z)
Definition: MD5.cpp:58
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
block_iterator block_end() const
Definition: LoopInfo.h:160
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
Definition: Instructions.h:290
LLVM Value Representation.
Definition: Value.h:73
A vector that has set insertion semantics.
Definition: SetVector.h:40
The legacy pass manager&#39;s analysis pass to compute loop information.
Definition: LoopInfo.h:1208
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
block_iterator block_begin() const
Definition: LoopInfo.h:159
static void setUniformMetadata(Instruction *I)
const BasicBlock * getParent() const
Definition: Instruction.h:66