Home | History | Annotate | Line # | Download | only in NVPTX 
      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