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 (unsigned v : Vs) { 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 318