[NVPTX] Move NVPTXUtilities.{h,cpp} into namespace llvm.

[jlebar]

Summary

All of the non-static functions in the cpp file were already in
namespace llvm, and this lets us get rid of a bunch of unnecessary
"llvm::"'s.

[jlebar]

Accidentally merged this into another revision -- this is now no longer relevant.

llvm/lib/Target/NVPTX/NVPTXUtilities.h

 #include <string>
 #include <vector>
 
 namespace llvm {
 
 #define NVCL_IMAGE2D_READONLY_FUNCNAME "__is_image2D_readonly"
 #define NVCL_IMAGE3D_READONLY_FUNCNAME "__is_image3D_readonly"
 
-void clearAnnotationCache(const llvm::Module *);
+void clearAnnotationCache(const Module *);
 
-bool findOneNVVMAnnotation(const llvm::GlobalValue *, const std::string &,
+bool findOneNVVMAnnotation(const GlobalValue *, const std::string &,
                            unsigned &);
-bool findAllNVVMAnnotation(const llvm::GlobalValue *, const std::string &,
+bool findAllNVVMAnnotation(const GlobalValue *, const std::string &,
                            std::vector<unsigned> &);
 
-bool isTexture(const llvm::Value &);
-bool isSurface(const llvm::Value &);
-bool isSampler(const llvm::Value &);
-bool isImage(const llvm::Value &);
-bool isImageReadOnly(const llvm::Value &);
-bool isImageWriteOnly(const llvm::Value &);
-bool isImageReadWrite(const llvm::Value &);
-bool isManaged(const llvm::Value &);
-
-std::string getTextureName(const llvm::Value &);
-std::string getSurfaceName(const llvm::Value &);
-std::string getSamplerName(const llvm::Value &);
-
-bool getMaxNTIDx(const llvm::Function &, unsigned &);
-bool getMaxNTIDy(const llvm::Function &, unsigned &);
-bool getMaxNTIDz(const llvm::Function &, unsigned &);
-
-bool getReqNTIDx(const llvm::Function &, unsigned &);
-bool getReqNTIDy(const llvm::Function &, unsigned &);
-bool getReqNTIDz(const llvm::Function &, unsigned &);
+bool isTexture(const Value &);
+bool isSurface(const Value &);
+bool isSampler(const Value &);
+bool isImage(const Value &);
+bool isImageReadOnly(const Value &);
+bool isImageWriteOnly(const Value &);
+bool isImageReadWrite(const Value &);
+bool isManaged(const Value &);
+
+std::string getTextureName(const Value &);
+std::string getSurfaceName(const Value &);
+std::string getSamplerName(const Value &);
+
+bool getMaxNTIDx(const Function &, unsigned &);
+bool getMaxNTIDy(const Function &, unsigned &);
+bool getMaxNTIDz(const Function &, unsigned &);
+
+bool getReqNTIDx(const Function &, unsigned &);
+bool getReqNTIDy(const Function &, unsigned &);
+bool getReqNTIDz(const Function &, unsigned &);
 
-bool getMinCTASm(const llvm::Function &, unsigned &);
-bool isKernelFunction(const llvm::Function &);
+bool getMinCTASm(const Function &, unsigned &);
+bool isKernelFunction(const Function &);
 
-bool getAlign(const llvm::Function &, unsigned index, unsigned &);
-bool getAlign(const llvm::CallInst &, unsigned index, unsigned &);
+bool getAlign(const Function &, unsigned index, unsigned &);
+bool getAlign(const CallInst &, unsigned index, unsigned &);
 
 BasicBlock *getParentBlock(Value *v);
 Function *getParentFunction(Value *v);
 void dumpBlock(Value *v, char *blockName);
 Instruction *getInst(Value *base, char *instName);
 void dumpInst(Value *base, char *instName);
 void dumpInstRec(Value *v, std::set<Instruction *> *visited);
 void dumpInstRec(Value *v);
 void dumpParent(Value *v);
 
 }
 
 #endif

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MutexGuard.h"
 #include <algorithm>
 #include <cstring>
 #include <map>
 #include <string>
 #include <vector>
 
-using namespace llvm;
+namespace llvm {
 
+namespace {
 typedef std::map<std::string, std::vector<unsigned> > key_val_pair_t;
 typedef std::map<const GlobalValue *, key_val_pair_t> global_val_annot_t;
 typedef std::map<const Module *, global_val_annot_t> per_module_annot_t;
+} // anonymous namespace
 
-ManagedStatic<per_module_annot_t> annotationCache;
+static ManagedStatic<per_module_annot_t> annotationCache;
 static sys::Mutex Lock;
 
-void llvm::clearAnnotationCache(const llvm::Module *Mod) {
+void clearAnnotationCache(const Module *Mod) {
   MutexGuard Guard(Lock);
   annotationCache->erase(Mod);
 }
 
 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
   MutexGuard Guard(Lock);
   assert(md && "Invalid mdnode for annotation");
   assert((md->getNumOperands() % 2) == 1 && "Invalid number of operands");
else {
       tmp.push_back(Val->getZExtValue());
       retval[keyname] = tmp;
     }
   }
 }
 
 static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
   MutexGuard Guard(Lock);
-  NamedMDNode *NMD = m->getNamedMetadata(llvm::NamedMDForAnnotations);
+  NamedMDNode *NMD = m->getNamedMetadata(NamedMDForAnnotations);
   if (!NMD)
     return;
   key_val_pair_t tmp;
   for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
     const MDNode *elem = NMD->getOperand(i);
 
     GlobalValue *entity =
         mdconst::dyn_extract_or_null<GlobalValue>(elem->getOperand(0));
if ((*annotationCache).find(m) != (*annotationCache).end())
     (*annotationCache)[m][gv] = std::move(tmp);
   else {
     global_val_annot_t tmp1;
     tmp1[gv] = std::move(tmp);
     (*annotationCache)[m] = std::move(tmp1);
   }
 }
 
-bool llvm::findOneNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
-                                 unsigned &retval) {
+bool findOneNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
   MutexGuard Guard(Lock);
   const Module *m = gv->getParent();
   if ((*annotationCache).find(m) == (*annotationCache).end())
     cacheAnnotationFromMD(m, gv);
   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
     cacheAnnotationFromMD(m, gv);
   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
     return false;
   retval = (*annotationCache)[m][gv][prop][0];
   return true;
 }
 
-bool llvm::findAllNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
-                                 std::vector<unsigned> &retval) {
+bool findAllNVVMAnnotation(const GlobalValue *gv, const std::string &prop,
   MutexGuard Guard(Lock);
   const Module *m = gv->getParent();
   if ((*annotationCache).find(m) == (*annotationCache).end())
     cacheAnnotationFromMD(m, gv);
   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
     cacheAnnotationFromMD(m, gv);
   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
     return false;
   retval = (*annotationCache)[m][gv][prop];
   return true;
 }
 
-bool llvm::isTexture(const llvm::Value &val) {
+bool isTexture(const Value &val) {
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationName(llvm::PROPERTY_ISTEXTURE),
+    if (findOneNVVMAnnotation(gv, PropertyAnnotationName(PROPERTY_ISTEXTURE),
                               annot)) {
       assert((annot == 1) && "Unexpected annotation on a texture symbol");
       return true;
     }
   }
   return false;
 }
 
-bool llvm::isSurface(const llvm::Value &val) {
+bool isSurface(const Value &val) {
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationName(llvm::PROPERTY_ISSURFACE),
+    if (findOneNVVMAnnotation(gv, PropertyAnnotationName(PROPERTY_ISSURFACE),
                               annot)) {
       assert((annot == 1) && "Unexpected annotation on a surface symbol");
       return true;
     }
   }
   return false;
 }
 
-bool llvm::isSampler(const llvm::Value &val) {
+bool isSampler(const Value &val) {
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationName(llvm::PROPERTY_ISSAMPLER),
+    if (findOneNVVMAnnotation(gv, PropertyAnnotationName(PROPERTY_ISSAMPLER),
                               annot)) {
       assert((annot == 1) && "Unexpected annotation on a sampler symbol");
       return true;
     }
   }
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(
-            func, llvm::PropertyAnnotationName(llvm::PROPERTY_ISSAMPLER),
+    if (findAllNVVMAnnotation(func, PropertyAnnotationName(PROPERTY_ISSAMPLER),
                               annot)) {
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
-bool llvm::isImageReadOnly(const llvm::Value &val) {
+bool isImageReadOnly(const Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(
-            func,
-            llvm::PropertyAnnotationName(llvm::PROPERTY_ISREADONLY_IMAGE_PARAM),
+    if (findAllNVVMAnnotation(
+            func, PropertyAnnotationName(PROPERTY_ISREADONLY_IMAGE_PARAM),
             annot)) {
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
-bool llvm::isImageWriteOnly(const llvm::Value &val) {
+bool isImageWriteOnly(const Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(func,
-                                    llvm::PropertyAnnotationName(
-                                        llvm::PROPERTY_ISWRITEONLY_IMAGE_PARAM),
-                                    annot)) {
+    if (findAllNVVMAnnotation(
+            func, PropertyAnnotationName(PROPERTY_ISWRITEONLY_IMAGE_PARAM),
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
-bool llvm::isImageReadWrite(const llvm::Value &val) {
+bool isImageReadWrite(const Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(func,
-                                    llvm::PropertyAnnotationName(
-                                        llvm::PROPERTY_ISREADWRITE_IMAGE_PARAM),
-                                    annot)) {
+    if (findAllNVVMAnnotation(
+            func, PropertyAnnotationName(PROPERTY_ISREADWRITE_IMAGE_PARAM),
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
-bool llvm::isImage(const llvm::Value &val) {
-  return llvm::isImageReadOnly(val) || llvm::isImageWriteOnly(val) ||
-         llvm::isImageReadWrite(val);
+bool isImage(const Value &val) {
+  return isImageReadOnly(val) || isImageWriteOnly(val) || isImageReadWrite(val);
 }
 
-bool llvm::isManaged(const llvm::Value &val) {
+bool isManaged(const Value &val) {
   if(const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationName(llvm::PROPERTY_MANAGED), annot)) {
+    if (findOneNVVMAnnotation(gv, PropertyAnnotationName(PROPERTY_MANAGED),
+                              annot)) {
       assert((annot == 1) && "Unexpected annotation on a managed symbol");
       return true;
     }
   }
   return false;
 }
 
-std::string llvm::getTextureName(const llvm::Value &val) {
+std::string getTextureName(const Value &val) {
   assert(val.hasName() && "Found texture variable with no name");
   return val.getName();
 }
 
-std::string llvm::getSurfaceName(const llvm::Value &val) {
+std::string getSurfaceName(const Value &val) {
   assert(val.hasName() && "Found surface variable with no name");
   return val.getName();
 }
 
-std::string llvm::getSamplerName(const llvm::Value &val) {
+std::string getSamplerName(const Value &val) {
   assert(val.hasName() && "Found sampler variable with no name");
   return val.getName();
 }
 
-bool llvm::getMaxNTIDx(const Function &F, unsigned &x) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_MAXNTID_X), x));
+bool getMaxNTIDx(const Function &F, unsigned &x) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_MAXNTID_X), x));
 }
 
-bool llvm::getMaxNTIDy(const Function &F, unsigned &y) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_MAXNTID_Y), y));
+bool getMaxNTIDy(const Function &F, unsigned &y) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_MAXNTID_Y), y));
 }
 
-bool llvm::getMaxNTIDz(const Function &F, unsigned &z) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_MAXNTID_Z), z));
+bool getMaxNTIDz(const Function &F, unsigned &z) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_MAXNTID_Z), z));
 }
 
-bool llvm::getReqNTIDx(const Function &F, unsigned &x) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_REQNTID_X), x));
+bool getReqNTIDx(const Function &F, unsigned &x) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_REQNTID_X), x));
 }
 
-bool llvm::getReqNTIDy(const Function &F, unsigned &y) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_REQNTID_Y), y));
+bool getReqNTIDy(const Function &F, unsigned &y) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_REQNTID_Y), y));
 }
 
-bool llvm::getReqNTIDz(const Function &F, unsigned &z) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_REQNTID_Z), z));
+bool getReqNTIDz(const Function &F, unsigned &z) {
+  return (
+      findOneNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_REQNTID_Z), z));
 }
 
-bool llvm::getMinCTASm(const Function &F, unsigned &x) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_MINNCTAPERSM), x));
+bool getMinCTASm(const Function &F, unsigned &x) {
+  return (findOneNVVMAnnotation(
+      &F, PropertyAnnotationName(PROPERTY_MINNCTAPERSM), x));
 }
 
-bool llvm::isKernelFunction(const Function &F) {
+bool isKernelFunction(const Function &F) {
   unsigned x = 0;
-  bool retval = llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_ISKERNEL_FUNCTION), x);
+  bool retval = findOneNVVMAnnotation(
+      &F, PropertyAnnotationName(PROPERTY_ISKERNEL_FUNCTION), x);
   if (!retval) {
     // There is no NVVM metadata, check the calling convention
-    return F.getCallingConv() == llvm::CallingConv::PTX_Kernel;
+    return F.getCallingConv() == CallingConv::PTX_Kernel;
   }
   return (x == 1);
 }
 
-bool llvm::getAlign(const Function &F, unsigned index, unsigned &align) {
+bool getAlign(const Function &F, unsigned index, unsigned &align) {
   std::vector<unsigned> Vs;
-  bool retval = llvm::findAllNVVMAnnotation(
-      &F, llvm::PropertyAnnotationName(llvm::PROPERTY_ALIGN), Vs);
+  bool retval =
+      findAllNVVMAnnotation(&F, PropertyAnnotationName(PROPERTY_ALIGN), Vs);
   if (!retval)
     return false;
   for (int i = 0, e = Vs.size(); i < e; i++) {
     unsigned v = Vs[i];
     if ((v >> 16) == index) {
       align = v & 0xFFFF;
       return true;
     }
   }
   return false;
 }
 
-bool llvm::getAlign(const CallInst &I, unsigned index, unsigned &align) {
+bool getAlign(const CallInst &I, unsigned index, unsigned &align) {
   if (MDNode *alignNode = I.getMetadata("callalign")) {
     for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
       if (const ConstantInt *CI =
               mdconst::dyn_extract<ConstantInt>(alignNode->getOperand(i))) {
         unsigned v = CI->getZExtValue();
         if ((v >> 16) == index) {
           align = v & 0xFFFF;
           return true;
         }
         if ((v >> 16) > index) {
           return false;
         }
       }
     }
   }
   return false;
 }
 
 // The following are some useful utilities for debugging
 
-BasicBlock *llvm::getParentBlock(Value *v) {
+BasicBlock *getParentBlock(Value *v) {
   if (BasicBlock *B = dyn_cast<BasicBlock>(v))
     return B;
 
   if (Instruction *I = dyn_cast<Instruction>(v))
     return I->getParent();
 
   return nullptr;
 }
 
-Function *llvm::getParentFunction(Value *v) {
+Function *getParentFunction(Value *v) {
   if (Function *F = dyn_cast<Function>(v))
     return F;
 
   if (Instruction *I = dyn_cast<Instruction>(v))
     return I->getParent()->getParent();
 
   if (BasicBlock *B = dyn_cast<BasicBlock>(v))
     return B->getParent();
 
   return nullptr;
 }
 
 // Dump a block by name
-void llvm::dumpBlock(Value *v, char *blockName) {
+void dumpBlock(Value *v, char *blockName) {
   Function *F = getParentFunction(v);
   if (!F)
     return;
 
   for (Function::iterator it = F->begin(), ie = F->end(); it != ie; ++it) {
     BasicBlock *B = &*it;
     if (strcmp(B->getName().data(), blockName) == 0) {
       B->dump();
       return;
     }
   }
 }
 
 // Find an instruction by name
-Instruction *llvm::getInst(Value *base, char *instName) {
+Instruction *getInst(Value *base, char *instName) {
   Function *F = getParentFunction(base);
   if (!F)
     return nullptr;
 
   for (inst_iterator it = inst_begin(F), ie = inst_end(F); it != ie; ++it) {
     Instruction *I = &*it;
     if (strcmp(I->getName().data(), instName) == 0) {
       return I;
     }
   }
 
   return nullptr;
 }
 
 // Dump an instruction by name
-void llvm::dumpInst(Value *base, char *instName) {
+void dumpInst(Value *base, char *instName) {
   Instruction *I = getInst(base, instName);
   if (I)
     I->dump();
 }
 
 // Dump an instruction and all dependent instructions
-void llvm::dumpInstRec(Value *v, std::set<Instruction *> *visited) {
+void dumpInstRec(Value *v, std::set<Instruction *> *visited) {
   if (Instruction *I = dyn_cast<Instruction>(v)) {
 
     if (visited->find(I) != visited->end())
       return;
 
     visited->insert(I);
 
     for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
       dumpInstRec(I->getOperand(i), visited);
 
     I->dump();
   }
 }
 
 // Dump an instruction and all dependent instructions
-void llvm::dumpInstRec(Value *v) {
+void dumpInstRec(Value *v) {
   std::set<Instruction *> visited;
 
   //BasicBlock *B = getParentBlock(v);
 
   dumpInstRec(v, &visited);
 }
 
 // Dump the parent for Instruction, block or function
-void llvm::dumpParent(Value *v) {
+void dumpParent(Value *v) {
   if (Instruction *I = dyn_cast<Instruction>(v)) {
     I->getParent()->dump();
     return;
   }
 
   if (BasicBlock *B = dyn_cast<BasicBlock>(v)) {
     B->getParent()->dump();
     return;
   }
 
   if (Function *F = dyn_cast<Function>(v)) {
     F->getParent()->dump();
     return;
   }
 }
+
+} // namespace llvm