1 //===- NVPTXUtilities.cpp - Utility Functions -----------------------------===//
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 // This file contains miscellaneous utility functions
10 //
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"
21 #include "llvm/Support/ManagedStatic.h"
22 #include "llvm/Support/Mutex.h"
23 #include <algorithm>
24 #include <cstring>
25 #include <map>
26 #include <mutex>
27 #include <string>
28 #include <vector>
29 
30 namespace llvm {
31 
32 namespace {
33 typedef std::map<std::string, std::vector<unsigned> > key_val_pair_t;
34 typedef std::map<const GlobalValue *, key_val_pair_t> global_val_annot_t;
35 typedef std::map<const Module *, global_val_annot_t> per_module_annot_t;
36 } // anonymous namespace
37 
38 static ManagedStatic<per_module_annot_t> annotationCache;
39 static sys::Mutex Lock;
40 
41 void clearAnnotationCache(const Module *Mod) {
42   std::lock_guard<sys::Mutex> Guard(Lock);
43   annotationCache->erase(Mod);
44 }
45 
46 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
47   std::lock_guard<sys::Mutex> Guard(Lock);
48   assert(md && "Invalid mdnode for annotation");
49   assert((md->getNumOperands() % 2) == 1 && "Invalid number of operands");
50   // start index = 1, to skip the global variable key
51   // increment = 2, to skip the value for each property-value pairs
52   for (unsigned i = 1, e = md->getNumOperands(); i != e; i += 2) {
53     // property
54     const MDString *prop = dyn_cast<MDString>(md->getOperand(i));
55     assert(prop && "Annotation property not a string");
56 
57     // value
58     ConstantInt *Val = mdconst::dyn_extract<ConstantInt>(md->getOperand(i + 1));
59     assert(Val && "Value operand not a constant int");
60 
61     std::string keyname = prop->getString().str();
62     if (retval.find(keyname) != retval.end())
63       retval[keyname].push_back(Val->getZExtValue());
64     else {
65       std::vector<unsigned> tmp;
66       tmp.push_back(Val->getZExtValue());
67       retval[keyname] = tmp;
68     }
69   }
70 }
71 
72 static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
73   std::lock_guard<sys::Mutex> Guard(Lock);
74   NamedMDNode *NMD = m->getNamedMetadata("nvvm.annotations");
75   if (!NMD)
76     return;
77   key_val_pair_t tmp;
78   for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
79     const MDNode *elem = NMD->getOperand(i);
80 
81     GlobalValue *entity =
82         mdconst::dyn_extract_or_null<GlobalValue>(elem->getOperand(0));
83     // entity may be null due to DCE
84     if (!entity)
85       continue;
86     if (entity != gv)
87       continue;
88 
89     // accumulate annotations for entity in tmp
90     cacheAnnotationFromMD(elem, tmp);
91   }
92 
93   if (tmp.empty()) // no annotations for this gv
94     return;
95 
96   if ((*annotationCache).find(m) != (*annotationCache).end())
97     (*annotationCache)[m][gv] = std::move(tmp);
98   else {
99     global_val_annot_t tmp1;
100     tmp1[gv] = std::move(tmp);
101     (*annotationCache)[m] = std::move(tmp1);
102   }
103 }
104 
105 bool findOneNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
106                            unsigned &retval) {
107   std::lock_guard<sys::Mutex> Guard(Lock);
108   const Module *m = gv->getParent();
109   if ((*annotationCache).find(m) == (*annotationCache).end())
110     cacheAnnotationFromMD(m, gv);
111   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
112     cacheAnnotationFromMD(m, gv);
113   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
114     return false;
115   retval = (*annotationCache)[m][gv][prop][0];
116   return true;
117 }
118 
119 bool findAllNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
120                            std::vector<unsigned> &retval) {
121   std::lock_guard<sys::Mutex> Guard(Lock);
122   const Module *m = gv->getParent();
123   if ((*annotationCache).find(m) == (*annotationCache).end())
124     cacheAnnotationFromMD(m, gv);
125   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
126     cacheAnnotationFromMD(m, gv);
127   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
128     return false;
129   retval = (*annotationCache)[m][gv][prop];
130   return true;
131 }
132 
133 bool isTexture(const Value &val) {
134   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
135     unsigned annot;
136     if (findOneNVVMAnnotation(gv, "texture", annot)) {
137       assert((annot == 1) && "Unexpected annotation on a texture symbol");
138       return true;
139     }
140   }
141   return false;
142 }
143 
144 bool isSurface(const Value &val) {
145   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
146     unsigned annot;
147     if (findOneNVVMAnnotation(gv, "surface", annot)) {
148       assert((annot == 1) && "Unexpected annotation on a surface symbol");
149       return true;
150     }
151   }
152   return false;
153 }
154 
155 bool isSampler(const Value &val) {
156   const char *AnnotationName = "sampler";
157 
158   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
159     unsigned annot;
160     if (findOneNVVMAnnotation(gv, AnnotationName, annot)) {
161       assert((annot == 1) && "Unexpected annotation on a sampler symbol");
162       return true;
163     }
164   }
165   if (const Argument *arg = dyn_cast<Argument>(&val)) {
166     const Function *func = arg->getParent();
167     std::vector<unsigned> annot;
168     if (findAllNVVMAnnotation(func, AnnotationName, annot)) {
169       if (is_contained(annot, arg->getArgNo()))
170         return true;
171     }
172   }
173   return false;
174 }
175 
176 bool isImageReadOnly(const Value &val) {
177   if (const Argument *arg = dyn_cast<Argument>(&val)) {
178     const Function *func = arg->getParent();
179     std::vector<unsigned> annot;
180     if (findAllNVVMAnnotation(func, "rdoimage", annot)) {
181       if (is_contained(annot, arg->getArgNo()))
182         return true;
183     }
184   }
185   return false;
186 }
187 
188 bool isImageWriteOnly(const Value &val) {
189   if (const Argument *arg = dyn_cast<Argument>(&val)) {
190     const Function *func = arg->getParent();
191     std::vector<unsigned> annot;
192     if (findAllNVVMAnnotation(func, "wroimage", annot)) {
193       if (is_contained(annot, arg->getArgNo()))
194         return true;
195     }
196   }
197   return false;
198 }
199 
200 bool isImageReadWrite(const Value &val) {
201   if (const Argument *arg = dyn_cast<Argument>(&val)) {
202     const Function *func = arg->getParent();
203     std::vector<unsigned> annot;
204     if (findAllNVVMAnnotation(func, "rdwrimage", annot)) {
205       if (is_contained(annot, arg->getArgNo()))
206         return true;
207     }
208   }
209   return false;
210 }
211 
212 bool isImage(const Value &val) {
213   return isImageReadOnly(val) || isImageWriteOnly(val) || isImageReadWrite(val);
214 }
215 
216 bool isManaged(const Value &val) {
217   if(const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
218     unsigned annot;
219     if (findOneNVVMAnnotation(gv, "managed", annot)) {
220       assert((annot == 1) && "Unexpected annotation on a managed symbol");
221       return true;
222     }
223   }
224   return false;
225 }
226 
227 std::string getTextureName(const Value &val) {
228   assert(val.hasName() && "Found texture variable with no name");
229   return std::string(val.getName());
230 }
231 
232 std::string getSurfaceName(const Value &val) {
233   assert(val.hasName() && "Found surface variable with no name");
234   return std::string(val.getName());
235 }
236 
237 std::string getSamplerName(const Value &val) {
238   assert(val.hasName() && "Found sampler variable with no name");
239   return std::string(val.getName());
240 }
241 
242 bool getMaxNTIDx(const Function &F, unsigned &x) {
243   return findOneNVVMAnnotation(&F, "maxntidx", x);
244 }
245 
246 bool getMaxNTIDy(const Function &F, unsigned &y) {
247   return findOneNVVMAnnotation(&F, "maxntidy", y);
248 }
249 
250 bool getMaxNTIDz(const Function &F, unsigned &z) {
251   return findOneNVVMAnnotation(&F, "maxntidz", z);
252 }
253 
254 bool getReqNTIDx(const Function &F, unsigned &x) {
255   return findOneNVVMAnnotation(&F, "reqntidx", x);
256 }
257 
258 bool getReqNTIDy(const Function &F, unsigned &y) {
259   return findOneNVVMAnnotation(&F, "reqntidy", y);
260 }
261 
262 bool getReqNTIDz(const Function &F, unsigned &z) {
263   return findOneNVVMAnnotation(&F, "reqntidz", z);
264 }
265 
266 bool getMinCTASm(const Function &F, unsigned &x) {
267   return findOneNVVMAnnotation(&F, "minctasm", x);
268 }
269 
270 bool getMaxNReg(const Function &F, unsigned &x) {
271   return findOneNVVMAnnotation(&F, "maxnreg", x);
272 }
273 
274 bool isKernelFunction(const Function &F) {
275   unsigned x = 0;
276   bool retval = findOneNVVMAnnotation(&F, "kernel", x);
277   if (!retval) {
278     // There is no NVVM metadata, check the calling convention
279     return F.getCallingConv() == CallingConv::PTX_Kernel;
280   }
281   return (x == 1);
282 }
283 
284 bool getAlign(const Function &F, unsigned index, unsigned &align) {
285   std::vector<unsigned> Vs;
286   bool retval = findAllNVVMAnnotation(&F, "align", Vs);
287   if (!retval)
288     return false;
289   for (int i = 0, e = Vs.size(); i < e; i++) {
290     unsigned v = Vs[i];
291     if ((v >> 16) == index) {
292       align = v & 0xFFFF;
293       return true;
294     }
295   }
296   return false;
297 }
298 
299 bool getAlign(const CallInst &I, unsigned index, unsigned &align) {
300   if (MDNode *alignNode = I.getMetadata("callalign")) {
301     for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
302       if (const ConstantInt *CI =
303               mdconst::dyn_extract<ConstantInt>(alignNode->getOperand(i))) {
304         unsigned v = CI->getZExtValue();
305         if ((v >> 16) == index) {
306           align = v & 0xFFFF;
307           return true;
308         }
309         if ((v >> 16) > index) {
310           return false;
311         }
312       }
313     }
314   }
315   return false;
316 }
317 
318 } // namespace llvm
319