LLVM  6.0.0svn
NVPTXUtilities.cpp
Go to the documentation of this file.
1 //===- NVPTXUtilities.cpp - Utility Functions -----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains miscellaneous utility functions
11 //===----------------------------------------------------------------------===//
12 
13 #include "NVPTXUtilities.h"
14 #include "NVPTX.h"
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/GlobalVariable.h"
18 #include "llvm/IR/InstIterator.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/IR/Operator.h"
23 #include <algorithm>
24 #include <cstring>
25 #include <map>
26 #include <string>
27 #include <vector>
28 
29 namespace llvm {
30 
31 namespace {
32 typedef std::map<std::string, std::vector<unsigned> > key_val_pair_t;
33 typedef std::map<const GlobalValue *, key_val_pair_t> global_val_annot_t;
34 typedef std::map<const Module *, global_val_annot_t> per_module_annot_t;
35 } // anonymous namespace
36 
39 
40 void clearAnnotationCache(const Module *Mod) {
41  MutexGuard Guard(Lock);
42  annotationCache->erase(Mod);
43 }
44 
45 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
46  MutexGuard Guard(Lock);
47  assert(md && "Invalid mdnode for annotation");
48  assert((md->getNumOperands() % 2) == 1 && "Invalid number of operands");
49  // start index = 1, to skip the global variable key
50  // increment = 2, to skip the value for each property-value pairs
51  for (unsigned i = 1, e = md->getNumOperands(); i != e; i += 2) {
52  // property
53  const MDString *prop = dyn_cast<MDString>(md->getOperand(i));
54  assert(prop && "Annotation property not a string");
55 
56  // value
57  ConstantInt *Val = mdconst::dyn_extract<ConstantInt>(md->getOperand(i + 1));
58  assert(Val && "Value operand not a constant int");
59 
60  std::string keyname = prop->getString().str();
61  if (retval.find(keyname) != retval.end())
62  retval[keyname].push_back(Val->getZExtValue());
63  else {
64  std::vector<unsigned> tmp;
65  tmp.push_back(Val->getZExtValue());
66  retval[keyname] = tmp;
67  }
68  }
69 }
70 
71 static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
72  MutexGuard Guard(Lock);
73  NamedMDNode *NMD = m->getNamedMetadata("nvvm.annotations");
74  if (!NMD)
75  return;
76  key_val_pair_t tmp;
77  for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
78  const MDNode *elem = NMD->getOperand(i);
79 
80  GlobalValue *entity =
81  mdconst::dyn_extract_or_null<GlobalValue>(elem->getOperand(0));
82  // entity may be null due to DCE
83  if (!entity)
84  continue;
85  if (entity != gv)
86  continue;
87 
88  // accumulate annotations for entity in tmp
89  cacheAnnotationFromMD(elem, tmp);
90  }
91 
92  if (tmp.empty()) // no annotations for this gv
93  return;
94 
95  if ((*annotationCache).find(m) != (*annotationCache).end())
96  (*annotationCache)[m][gv] = std::move(tmp);
97  else {
98  global_val_annot_t tmp1;
99  tmp1[gv] = std::move(tmp);
100  (*annotationCache)[m] = std::move(tmp1);
101  }
102 }
103 
104 bool findOneNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
105  unsigned &retval) {
106  MutexGuard Guard(Lock);
107  const Module *m = gv->getParent();
108  if ((*annotationCache).find(m) == (*annotationCache).end())
109  cacheAnnotationFromMD(m, gv);
110  else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
111  cacheAnnotationFromMD(m, gv);
112  if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
113  return false;
114  retval = (*annotationCache)[m][gv][prop][0];
115  return true;
116 }
117 
118 bool findAllNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
119  std::vector<unsigned> &retval) {
120  MutexGuard Guard(Lock);
121  const Module *m = gv->getParent();
122  if ((*annotationCache).find(m) == (*annotationCache).end())
123  cacheAnnotationFromMD(m, gv);
124  else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
125  cacheAnnotationFromMD(m, gv);
126  if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
127  return false;
128  retval = (*annotationCache)[m][gv][prop];
129  return true;
130 }
131 
132 bool isTexture(const Value &val) {
133  if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
134  unsigned annot;
135  if (findOneNVVMAnnotation(gv, "texture", annot)) {
136  assert((annot == 1) && "Unexpected annotation on a texture symbol");
137  return true;
138  }
139  }
140  return false;
141 }
142 
143 bool isSurface(const Value &val) {
144  if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
145  unsigned annot;
146  if (findOneNVVMAnnotation(gv, "surface", annot)) {
147  assert((annot == 1) && "Unexpected annotation on a surface symbol");
148  return true;
149  }
150  }
151  return false;
152 }
153 
154 bool isSampler(const Value &val) {
155  const char *AnnotationName = "sampler";
156 
157  if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
158  unsigned annot;
159  if (findOneNVVMAnnotation(gv, AnnotationName, annot)) {
160  assert((annot == 1) && "Unexpected annotation on a sampler symbol");
161  return true;
162  }
163  }
164  if (const Argument *arg = dyn_cast<Argument>(&val)) {
165  const Function *func = arg->getParent();
166  std::vector<unsigned> annot;
167  if (findAllNVVMAnnotation(func, AnnotationName, annot)) {
168  if (is_contained(annot, arg->getArgNo()))
169  return true;
170  }
171  }
172  return false;
173 }
174 
175 bool isImageReadOnly(const Value &val) {
176  if (const Argument *arg = dyn_cast<Argument>(&val)) {
177  const Function *func = arg->getParent();
178  std::vector<unsigned> annot;
179  if (findAllNVVMAnnotation(func, "rdoimage", annot)) {
180  if (is_contained(annot, arg->getArgNo()))
181  return true;
182  }
183  }
184  return false;
185 }
186 
187 bool isImageWriteOnly(const Value &val) {
188  if (const Argument *arg = dyn_cast<Argument>(&val)) {
189  const Function *func = arg->getParent();
190  std::vector<unsigned> annot;
191  if (findAllNVVMAnnotation(func, "wroimage", annot)) {
192  if (is_contained(annot, arg->getArgNo()))
193  return true;
194  }
195  }
196  return false;
197 }
198 
199 bool isImageReadWrite(const Value &val) {
200  if (const Argument *arg = dyn_cast<Argument>(&val)) {
201  const Function *func = arg->getParent();
202  std::vector<unsigned> annot;
203  if (findAllNVVMAnnotation(func, "rdwrimage", annot)) {
204  if (is_contained(annot, arg->getArgNo()))
205  return true;
206  }
207  }
208  return false;
209 }
210 
211 bool isImage(const Value &val) {
212  return isImageReadOnly(val) || isImageWriteOnly(val) || isImageReadWrite(val);
213 }
214 
215 bool isManaged(const Value &val) {
216  if(const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
217  unsigned annot;
218  if (findOneNVVMAnnotation(gv, "managed", annot)) {
219  assert((annot == 1) && "Unexpected annotation on a managed symbol");
220  return true;
221  }
222  }
223  return false;
224 }
225 
226 std::string getTextureName(const Value &val) {
227  assert(val.hasName() && "Found texture variable with no name");
228  return val.getName();
229 }
230 
231 std::string getSurfaceName(const Value &val) {
232  assert(val.hasName() && "Found surface variable with no name");
233  return val.getName();
234 }
235 
236 std::string getSamplerName(const Value &val) {
237  assert(val.hasName() && "Found sampler variable with no name");
238  return val.getName();
239 }
240 
241 bool getMaxNTIDx(const Function &F, unsigned &x) {
242  return findOneNVVMAnnotation(&F, "maxntidx", x);
243 }
244 
245 bool getMaxNTIDy(const Function &F, unsigned &y) {
246  return findOneNVVMAnnotation(&F, "maxntidy", y);
247 }
248 
249 bool getMaxNTIDz(const Function &F, unsigned &z) {
250  return findOneNVVMAnnotation(&F, "maxntidz", z);
251 }
252 
253 bool getReqNTIDx(const Function &F, unsigned &x) {
254  return findOneNVVMAnnotation(&F, "reqntidx", x);
255 }
256 
257 bool getReqNTIDy(const Function &F, unsigned &y) {
258  return findOneNVVMAnnotation(&F, "reqntidy", y);
259 }
260 
261 bool getReqNTIDz(const Function &F, unsigned &z) {
262  return findOneNVVMAnnotation(&F, "reqntidz", z);
263 }
264 
265 bool getMinCTASm(const Function &F, unsigned &x) {
266  return findOneNVVMAnnotation(&F, "minctasm", x);
267 }
268 
269 bool getMaxNReg(const Function &F, unsigned &x) {
270  return findOneNVVMAnnotation(&F, "maxnreg", x);
271 }
272 
274  unsigned x = 0;
275  bool retval = findOneNVVMAnnotation(&F, "kernel", x);
276  if (!retval) {
277  // There is no NVVM metadata, check the calling convention
279  }
280  return (x == 1);
281 }
282 
283 bool getAlign(const Function &F, unsigned index, unsigned &align) {
284  std::vector<unsigned> Vs;
285  bool retval = findAllNVVMAnnotation(&F, "align", Vs);
286  if (!retval)
287  return false;
288  for (int i = 0, e = Vs.size(); i < e; i++) {
289  unsigned v = Vs[i];
290  if ((v >> 16) == index) {
291  align = v & 0xFFFF;
292  return true;
293  }
294  }
295  return false;
296 }
297 
298 bool getAlign(const CallInst &I, unsigned index, unsigned &align) {
299  if (MDNode *alignNode = I.getMetadata("callalign")) {
300  for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
301  if (const ConstantInt *CI =
302  mdconst::dyn_extract<ConstantInt>(alignNode->getOperand(i))) {
303  unsigned v = CI->getZExtValue();
304  if ((v >> 16) == index) {
305  align = v & 0xFFFF;
306  return true;
307  }
308  if ((v >> 16) > index) {
309  return false;
310  }
311  }
312  }
313  }
314  return false;
315 }
316 
317 } // namespace llvm
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:228
bool getAlign(const Function &F, unsigned index, unsigned &align)
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1073
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
bool getMaxNReg(const Function &F, unsigned &x)
bool findOneNVVMAnnotation(const GlobalValue *gv, const std::string &prop, unsigned &retval)
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
bool findAllNVVMAnnotation(const GlobalValue *gv, const std::string &prop, std::vector< unsigned > &retval)
bool isTexture(const Value &val)
This class represents a function call, abstracting a target machine&#39;s calling convention.
static sys::Mutex Lock
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:115
Metadata node.
Definition: Metadata.h:862
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
A tuple of MDNodes.
Definition: Metadata.h:1316
void clearAnnotationCache(const Module *Mod)
unsigned getNumOperands() const
Definition: Metadata.cpp:1069
bool getMaxNTIDz(const Function &F, unsigned &z)
bool isKernelFunction(const Function &F)
#define F(x, y, z)
Definition: MD5.cpp:55
bool isSurface(const Value &val)
bool getMaxNTIDx(const Function &F, unsigned &x)
std::string getTextureName(const Value &val)
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:242
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:190
bool isSampler(const Value &val)
StringRef getString() const
Definition: Metadata.cpp:456
Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruct...
Definition: MutexGuard.h:27
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:149
bool hasName() const
Definition: Value.h:251
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool getMaxNTIDy(const Function &F, unsigned &y)
bool getReqNTIDx(const Function &F, unsigned &x)
bool isImage(const Value &val)
bool getReqNTIDz(const Function &F, unsigned &z)
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:186
Module.h This file contains the declarations for the Module class.
bool isImageReadWrite(const Value &val)
std::string getSurfaceName(const Value &val)
std::string getSamplerName(const Value &val)
bool isManaged(const Value &val)
bool getReqNTIDy(const Function &F, unsigned &y)
bool isImageReadOnly(const Value &val)
static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval)
static ManagedStatic< per_module_annot_t > annotationCache
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:218
#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:323
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:545
LLVM Value Representation.
Definition: Value.h:73
A single uniqued string.
Definition: Metadata.h:602
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
bool getMinCTASm(const Function &F, unsigned &x)
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1073
bool isImageWriteOnly(const Value &val)
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:872