[NFC][IR] Make Module::getNamedMDList() private

[vporpo]

Summary

This patch adds several missing NamedMDList modifier functions, like
removeNamedMDNode(), eraseNamedMDNode() and insertNamedMDNode().
There is no longer need to access the list directly so it also makes
getNamedMDList() private.

[vporpo]

Rebase

llvm/include/llvm/IR/Module.h

/// @{
   void removeIFunc(GlobalIFunc *IFunc) { IFuncList.remove(IFunc); }
   /// Remove \p IFunc from the list and delete it.
   void eraseIFunc(GlobalIFunc *IFunc) { IFuncList.erase(IFunc); }
   /// Insert \p IFunc at the end of the alias list and take ownership.
   void insertIFunc(GlobalIFunc *IFunc) { IFuncList.push_back(IFunc); }
   // Use ifunc_size() to get the number of functions in IFuncList.
   // Use ifuncs() to get the range of all IFuncs.
 
+  /// Detach \p MDNode from the list but don't delete it.
+  void removeNamedMDNode(NamedMDNode *MDNode) { NamedMDList.remove(MDNode); }
+  /// Remove \p MDNode from the list and delete it.
+  void eraseNamedMDNode(NamedMDNode *MDNode) { NamedMDList.erase(MDNode); }
+  /// Insert \p MDNode at the end of the alias list and take ownership.
+  void insertNamedMDNode(NamedMDNode *MDNode) {
+    NamedMDList.push_back(MDNode);
+  }
+  // Use named_metadata_size() to get the size of the named meatadata list.
+  // Use named_metadata() to get the range of all named metadata.
+
 private: // Please use functions like insertAlias(), removeAlias() etc.
   /// Get the Module's list of aliases (constant).
   const AliasListType    &getAliasList() const        { return AliasList; }
   /// Get the Module's list of aliases.
   AliasListType          &getAliasList()              { return AliasList; }
 
   static AliasListType Module::*getSublistAccess(GlobalAlias*) {
     return &Module::AliasList;
   }
   friend class llvm::SymbolTableListTraits<llvm::GlobalAlias>;
 
 public:
   /// Get the Module's list of ifuncs (constant).
   const IFuncListType    &getIFuncList() const        { return IFuncList; }
   /// Get the Module's list of ifuncs.
   IFuncListType          &getIFuncList()              { return IFuncList; }
 
   static IFuncListType Module::*getSublistAccess(GlobalIFunc*) {
     return &Module::IFuncList;
   }
   friend class llvm::SymbolTableListTraits<llvm::GlobalIFunc>;
 
-public:
   /// Get the Module's list of named metadata (constant).
   const NamedMDListType  &getNamedMDList() const      { return NamedMDList; }
   /// Get the Module's list of named metadata.
   NamedMDListType        &getNamedMDList()            { return NamedMDList; }
 
   static NamedMDListType Module::*getSublistAccess(NamedMDNode*) {
     return &Module::NamedMDList;
   }
 
+public:
   /// Get the symbol table of global variable and function identifiers
   const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
   /// Get the Module's symbol table of global variable and function identifiers.
   ValueSymbolTable       &getValueSymbolTable()       { return *ValSymTab; }
 
   /// Get the Module's symbol table for COMDATs (constant).
   const ComdatSymTabType &getComdatSymbolTable() const { return ComdatSymTab; }
   /// Get the Module's symbol table for COMDATs.

llvm/lib/IR/DebugInfo.cpp

for (auto &BB : F) {
         if (I.hasMetadataOtherThanDebugLoc())
           I.setMetadata("heapallocsite", nullptr);
       }
     }
   }
 
   // Create a new llvm.dbg.cu, which is equivalent to the one
   // -gline-tables-only would have created.
-  for (auto &NMD : M.getNamedMDList()) {
+  for (auto &NMD : M.named_metadata()) {
     SmallVector<MDNode *, 8> Ops;
     for (MDNode *Op : NMD.operands())
       Ops.push_back(remap(Op));
 
     if (!Changed)
       continue;
 
     NMD.clearOperands();

llvm/lib/IR/Module.cpp

 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
 /// with the specified name. This method returns a new NamedMDNode if a
 /// NamedMDNode with the specified name is not found.
 NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
   NamedMDNode *&NMD = NamedMDSymTab[Name];
   if (!NMD) {
     NMD = new NamedMDNode(Name);
     NMD->setParent(this);
-    NamedMDList.push_back(NMD);
+    insertNamedMDNode(NMD);
   }
   return NMD;
 }
 
 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
 /// delete it.
 void Module::eraseNamedMetadata(NamedMDNode *NMD) {
   NamedMDSymTab.erase(NMD->getName());
-  NamedMDList.erase(NMD->getIterator());
+  eraseNamedMDNode(NMD);
 }
 
 bool Module::isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB) {
   if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
     uint64_t Val = Behavior->getLimitedValue();
     if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
       MFB = static_cast<ModFlagBehavior>(Val);
       return true;

llvm/unittests/IR/ModuleTest.cpp

)",
   M->removeIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 1u);
 
   M->insertIFunc(NewGIF);
   M->eraseIFunc(NewGIF);
   EXPECT_EQ(M->ifunc_size(), 1u);
 }
 
+TEST(ModuleTest, NamedMDList) {
+  // This tests all Module's functions that interact with Module::NamedMDList.
+  LLVMContext C;
+  SMDiagnostic Err;
+  LLVMContext Context;
+  auto M = std::make_unique<Module>("M", C);
+  NamedMDNode *MDN1 = M->getOrInsertNamedMetadata("MDN1");
+  EXPECT_EQ(M->named_metadata_size(), 1u);
+  NamedMDNode *MDN2 = M->getOrInsertNamedMetadata("MDN2");
+  EXPECT_EQ(M->named_metadata_size(), 2u);
+  auto *NewMDN = M->getOrInsertNamedMetadata("NewMDN");
+  EXPECT_EQ(M->named_metadata_size(), 3u);
+
+  M->removeNamedMDNode(NewMDN);
+  EXPECT_EQ(M->named_metadata_size(), 2u);
+
+  M->insertNamedMDNode(NewMDN);
+  EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);
+
+  M->removeNamedMDNode(NewMDN);
+  M->insertNamedMDNode(NewMDN);
+  EXPECT_EQ(M->named_metadata_size(), 3u);
+  EXPECT_EQ(&*std::prev(M->named_metadata().end()), NewMDN);
+
+  auto Range = M->named_metadata();
+  EXPECT_EQ(&*Range.begin(), MDN1);
+  EXPECT_EQ(&*std::next(Range.begin(), 1), MDN2);
+  EXPECT_EQ(&*std::next(Range.begin(), 2), NewMDN);
+  EXPECT_EQ(std::next(Range.begin(), 3), Range.end());
+
+  M->eraseNamedMDNode(NewMDN);
+  EXPECT_EQ(M->named_metadata_size(), 2u);
+}
+
 } // end namespace