[NVPTX] Move PropertyAnnotationNames into a cc file.

[jlebar]

Summary

Previously they were defined as a 2D char array in a header file. This
is kind of overkill -- we can let the linker lay out these strings
however it pleases. While we're at it, we might as well just inline
these constants where they're used, as each of them is used only once.

[tra]

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXBaseInfo.cpp

14

Do we really need a separate file for this? Why not just put it into NVPTXUtilities.cpp where it's used. For all practical purposes we can even make it static there as there are no other users.

[jlebar]

Inline all the constants.

[jlebar]

Sure, let's just get rid of these constants altogether. Simple is better than complex.

[jlebar]

Revert changes to CMakeLists.txt.

[jlebar]

...and remove empty file I didn't see in the git diff.

[tra]

Nice!

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

270–271

if (findOneNVVMAnnotation()) ... ? Here and in getAlign() below?

[jlebar]

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

270–271

Ugh, I accidentally merged two patches, the one moving this file into namespace llvm and the other getting rid of the constants.

I guess what's done is done. I'll send another patch for the retval thing, though, as this is already bigger than I would like.

llvm/lib/Target/NVPTX/MCTargetDesc/CMakeLists.txt

 add_llvm_library(LLVMNVPTXDesc
+  NVPTXBaseInfo.cpp
   NVPTXMCAsmInfo.cpp
   NVPTXMCTargetDesc.cpp
-  )

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXBaseInfo.h

enum AddressSpace {
   ADDRESS_SPACE_SHARED = 3,
   ADDRESS_SPACE_CONST = 4,
   ADDRESS_SPACE_LOCAL = 5,
 
   // NVVM Internal
   ADDRESS_SPACE_PARAM = 101
 };
 
-enum PropertyAnnotation {
-  PROPERTY_MAXNTID_X = 0,
-  PROPERTY_MAXNTID_Y,
-  PROPERTY_MAXNTID_Z,
-  PROPERTY_REQNTID_X,
-  PROPERTY_REQNTID_Y,
-  PROPERTY_REQNTID_Z,
-  PROPERTY_MINNCTAPERSM,
-  PROPERTY_ISTEXTURE,
-  PROPERTY_ISSURFACE,
-  PROPERTY_ISSAMPLER,
-  PROPERTY_ISREADONLY_IMAGE_PARAM,
-  PROPERTY_ISWRITEONLY_IMAGE_PARAM,
-  PROPERTY_ISREADWRITE_IMAGE_PARAM,
-  PROPERTY_ISKERNEL_FUNCTION,
-  PROPERTY_ALIGN,
-  PROPERTY_MANAGED,
-
-  // last property
-  PROPERTY_LAST
-};
-
-const unsigned AnnotationNameLen = 9; // length of each annotation name
-const char PropertyAnnotationNames[PROPERTY_LAST + 1][AnnotationNameLen + 1] = {
-  "maxntidx",                         // PROPERTY_MAXNTID_X
-  "maxntidy",                         // PROPERTY_MAXNTID_Y
-  "maxntidz",                         // PROPERTY_MAXNTID_Z
-  "reqntidx",                         // PROPERTY_REQNTID_X
-  "reqntidy",                         // PROPERTY_REQNTID_Y
-  "reqntidz",                         // PROPERTY_REQNTID_Z
-  "minctasm",                         // PROPERTY_MINNCTAPERSM
-  "texture",                          // PROPERTY_ISTEXTURE
-  "surface",                          // PROPERTY_ISSURFACE
-  "sampler",                          // PROPERTY_ISSAMPLER
-  "rdoimage",                         // PROPERTY_ISREADONLY_IMAGE_PARAM
-  "wroimage",                         // PROPERTY_ISWRITEONLY_IMAGE_PARAM
-  "rdwrimage",                        // PROPERTY_ISREADWRITE_IMAGE_PARAM
-  "kernel",                           // PROPERTY_ISKERNEL_FUNCTION
-  "align",                            // PROPERTY_ALIGN
-  "managed",                          // PROPERTY_MANAGED
-
-              // last property
-  "proplast", // PROPERTY_LAST
-};
-
-// name of named metadata used for global annotations
-#if defined(__GNUC__)
-// As this is declared to be static but some of the .cpp files that
-// include NVVM.h do not use this array, gcc gives a warning when
-// compiling those .cpp files, hence __attribute__((unused)).
-__attribute__((unused))
-#endif
-    static const char *NamedMDForAnnotations = "nvvm.annotations";
-
 namespace NVPTXII {
 enum {
   // These must be kept in sync with TSFlags in NVPTXInstrFormats.td
   IsTexFlag = 0x80,
   IsSuldMask = 0x300,
   IsSuldShift = 8,
   IsSustFlag = 0x400,
   IsSurfTexQueryFlag = 0x800,
   IsTexModeUnifiedFlag = 0x1000
 };
-}
-}
+} // namespace NVPTXII
 
+} // namespace llvm
 #endif

llvm/lib/Target/NVPTX/NVPTXUtilities.cpp

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("nvvm.annotations");
   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)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
     return false;
   retval = (*annotationCache)[m][gv][prop];
   return true;
 }
 
 bool llvm::isTexture(const llvm::Value &val) {
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationNames[llvm::PROPERTY_ISTEXTURE],
-            annot)) {
+    if (llvm::findOneNVVMAnnotation(gv, "texture", annot)) {
       assert((annot == 1) && "Unexpected annotation on a texture symbol");
       return true;
     }
   }
   return false;
 }
 
 bool llvm::isSurface(const llvm::Value &val) {
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationNames[llvm::PROPERTY_ISSURFACE],
-            annot)) {
+    if (llvm::findOneNVVMAnnotation(gv, "surface", annot)) {
       assert((annot == 1) && "Unexpected annotation on a surface symbol");
       return true;
     }
   }
   return false;
 }
 
 bool llvm::isSampler(const llvm::Value &val) {
+  const char *AnnotationName = "sampler";
+
   if (const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if (llvm::findOneNVVMAnnotation(
-            gv, llvm::PropertyAnnotationNames[llvm::PROPERTY_ISSAMPLER],
-            annot)) {
+    if (llvm::findOneNVVMAnnotation(gv, AnnotationName, 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::PropertyAnnotationNames[llvm::PROPERTY_ISSAMPLER],
-            annot)) {
+    if (llvm::findAllNVVMAnnotation(func, AnnotationName, annot)) {
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
 bool llvm::isImageReadOnly(const llvm::Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(func,
-                                    llvm::PropertyAnnotationNames[
-                                        llvm::PROPERTY_ISREADONLY_IMAGE_PARAM],
-                                    annot)) {
+    if (llvm::findAllNVVMAnnotation(func, "rdoimage", annot)) {
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
 bool llvm::isImageWriteOnly(const llvm::Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(func,
-                                    llvm::PropertyAnnotationNames[
-                                        llvm::PROPERTY_ISWRITEONLY_IMAGE_PARAM],
-                                    annot)) {
+    if (llvm::findAllNVVMAnnotation(func, "wroimage", annot)) {
       if (is_contained(annot, arg->getArgNo()))
         return true;
     }
   }
   return false;
 }
 
 bool llvm::isImageReadWrite(const llvm::Value &val) {
   if (const Argument *arg = dyn_cast<Argument>(&val)) {
     const Function *func = arg->getParent();
     std::vector<unsigned> annot;
-    if (llvm::findAllNVVMAnnotation(func,
-                                    llvm::PropertyAnnotationNames[
-                                        llvm::PROPERTY_ISREADWRITE_IMAGE_PARAM],
-                                    annot)) {
+    if (llvm::findAllNVVMAnnotation(func, "rdwrimage", annot)) {
       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 llvm::isManaged(const llvm::Value &val) {
   if(const GlobalValue *gv = dyn_cast<GlobalValue>(&val)) {
     unsigned annot;
-    if(llvm::findOneNVVMAnnotation(gv,
-                          llvm::PropertyAnnotationNames[llvm::PROPERTY_MANAGED],
-                                   annot)) {
+    if (llvm::findOneNVVMAnnotation(gv, "managed", annot)) {
       assert((annot == 1) && "Unexpected annotation on a managed symbol");
       return true;
     }
   }
   return false;
 }
 
 std::string llvm::getTextureName(const llvm::Value &val) {
   assert(val.hasName() && "Found texture variable with no name");
   return val.getName();
 }
 
 std::string llvm::getSurfaceName(const llvm::Value &val) {
   assert(val.hasName() && "Found surface variable with no name");
   return val.getName();
 }
 
 std::string llvm::getSamplerName(const llvm::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::PropertyAnnotationNames[llvm::PROPERTY_MAXNTID_X], x));
+  return llvm::findOneNVVMAnnotation(&F, "maxntidx", x);
 }
 
 bool llvm::getMaxNTIDy(const Function &F, unsigned &y) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_MAXNTID_Y], y));
+  return llvm::findOneNVVMAnnotation(&F, "maxntidy", y);
 }
 
 bool llvm::getMaxNTIDz(const Function &F, unsigned &z) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_MAXNTID_Z], z));
+  return llvm::findOneNVVMAnnotation(&F, "maxntidz", z);
 }
 
 bool llvm::getReqNTIDx(const Function &F, unsigned &x) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_REQNTID_X], x));
+  return llvm::findOneNVVMAnnotation(&F, "reqntidx", x);
 }
 
 bool llvm::getReqNTIDy(const Function &F, unsigned &y) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_REQNTID_Y], y));
+  return llvm::findOneNVVMAnnotation(&F, "reqntidy", y);
 }
 
 bool llvm::getReqNTIDz(const Function &F, unsigned &z) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_REQNTID_Z], z));
+  return llvm::findOneNVVMAnnotation(&F, "reqntidz", z);
 }
 
 bool llvm::getMinCTASm(const Function &F, unsigned &x) {
-  return (llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_MINNCTAPERSM], x));
+  return llvm::findOneNVVMAnnotation(&F, "minctasm", x);
 }
 
 bool llvm::isKernelFunction(const Function &F) {
   unsigned x = 0;
-  bool retval = llvm::findOneNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_ISKERNEL_FUNCTION], x);
+  bool retval = llvm::findOneNVVMAnnotation(&F, "kernel", x);
   if (!retval) {
     // There is no NVVM metadata, check the calling convention
     return F.getCallingConv() == llvm::CallingConv::PTX_Kernel;
   }
   return (x == 1);
 }
 
 bool llvm::getAlign(const Function &F, unsigned index, unsigned &align) {
   std::vector<unsigned> Vs;
-  bool retval = llvm::findAllNVVMAnnotation(
-      &F, llvm::PropertyAnnotationNames[llvm::PROPERTY_ALIGN], Vs);
+  bool retval = llvm::findAllNVVMAnnotation(&F, "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;
     }