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

[vporpo]

Summary

This patch adds several missing AliasList modifier functions, like
removeAlias(), eraseAlias() and insertAlias().
There is no longer need to access the list directly so it also makes
getAliaList() private.

[aeubanks]

llvm/include/llvm/IR/Module.h

573

this isn't used outside tests, remove?

[vporpo]

llvm/include/llvm/IR/Module.h

573

Isn't it better to keep it for completeness? I don't feel strongly about it though, either way is fine with me.

[aeubanks]

llvm/include/llvm/IR/Module.h

566

use the imperative Detach instead of Detaches (same below)

573

I think it's better to add it only if we actually use it. Besides, I don't think people generally care about the order of aliases.

576

I'd drop the Please

577

[vporpo]

Addressed comments

[aeubanks]

lgtm

lldb/source/Expression/IRExecutionUnit.cpp

if (val.hasExternalLinkage() && !val.isDeclaration()) {
             val.getName().str().c_str(), LLDB_INVALID_ADDRESS, remote_addr));
     }
   };
 
   for (llvm::GlobalVariable &global_var : m_module->getGlobalList()) {
     RegisterOneValue(global_var);
   }
 
-  for (llvm::GlobalAlias &global_alias : m_module->getAliasList()) {
+  for (llvm::GlobalAlias &global_alias : m_module->getAliases()) {
     RegisterOneValue(global_alias);
   }
 
   WriteData(process_sp);
 
   if (m_failed_lookups.size()) {
     StreamString ss;
 

llvm/include/llvm/IR/Module.h

/// @{
   /// Get the Module's list of functions (constant).
   const FunctionListType &getFunctionList() const     { return FunctionList; }
   /// Get the Module's list of functions.
   FunctionListType       &getFunctionList()           { return FunctionList; }
   static FunctionListType Module::*getSublistAccess(Function*) {
     return &Module::FunctionList;
   }
 
+  /// Detach \p Alias from the list but don't delete it.
+  void removeAlias(GlobalAlias *Alias) { AliasList.remove(Alias); }
+  /// Remove \p Alias from the list and delete it.
+  void eraseAlias(GlobalAlias *Alias) { AliasList.erase(Alias); }
+  /// Insert \p Alias at the end of the alias list and take ownership.
+  void insertAlias(GlobalAlias *Alias) { AliasList.insert(AliasList.end(), Alias); }
+  // Use alias_size() to get the size of AliasList.
+  // Use aliases() to get a range of all Alias objects in AliasList.
+
+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;
   }

llvm/lib/AsmParser/LLParser.cpp

if (GVal) {
     // If they agree, just RAUW the old value with the alias and remove the
     // forward ref info.
     GVal->replaceAllUsesWith(GV);
     GVal->eraseFromParent();
   }
 
   // Insert into the module, we know its name won't collide now.
   if (IsAlias)
-    M->getAliasList().push_back(GA.release());
+    M->insertAlias(GA.release());
   else
     M->getIFuncList().push_back(GI.release());
   assert(GV->getName() == Name && "Should not be a name conflict!");
 
   return false;
 }
 
 static bool isSanitizer(lltok::Kind Kind) {

llvm/lib/IR/Globals.cpp

 
 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
                          const Twine &Name, Constant *Aliasee,
                          Module *ParentModule)
     : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
                   AddressSpace) {
   setAliasee(Aliasee);
   if (ParentModule)
-    ParentModule->getAliasList().push_back(this);
+    ParentModule->insertAlias(this);
 }
 
 GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
                                  LinkageTypes Link, const Twine &Name,
                                  Constant *Aliasee, Module *ParentModule) {
   return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
 }
 
return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
                 Aliasee);
 }
 
 GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) {
   return create(Aliasee->getLinkage(), Name, Aliasee);
 }
 
 void GlobalAlias::removeFromParent() {
-  getParent()->getAliasList().remove(getIterator());
+  getParent()->removeAlias(this);
 }
 
 void GlobalAlias::eraseFromParent() {
-  getParent()->getAliasList().erase(getIterator());
+  getParent()->eraseAlias(this);
 }
 
 void GlobalAlias::setAliasee(Constant *Aliasee) {
   assert((!Aliasee || Aliasee->getType() == getType()) &&
          "Alias and aliasee types should match!");
   Op<0>().set(Aliasee);
 }
 

llvm/lib/Transforms/IPO/GlobalOpt.cpp

if (RenameTarget) {
         Used.usedInsert(Target);
 
       if (Used.compilerUsedErase(&J))
         Used.compilerUsedInsert(Target);
     } else if (mayHaveOtherReferences(J, Used))
       continue;
 
     // Delete the alias.
-    M.getAliasList().erase(&J);
+    M.eraseAlias(&J);
     ++NumAliasesRemoved;
     Changed = true;
   }
 
   Used.syncVariablesAndSets();
 
   return Changed;
 }

llvm/unittests/IR/ModuleTest.cpp

TEST(ModuleTest, setPartialSampleProfileRatio) {
   Index.setBlockCount(BlockCount);
   M->setPartialSampleProfileRatio(Index);
   double Ratio = (double)BlockCount / NumCounts;
   std::unique_ptr<ProfileSummary> ProfileSummary(
       ProfileSummary::getFromMD(M->getProfileSummary(/*IsCS*/ false)));
   EXPECT_EQ(Ratio, ProfileSummary->getPartialProfileRatio());
 }
 
+TEST(ModuleTest, AliasList) {
+  // This tests all Module's functions that interact with Module::AliasList.
+  LLVMContext C;
+  SMDiagnostic Err;
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssemblyString(R"(
+declare void @Foo()
+@GA = alias void (), ptr @Foo
+)",
+                                                  Err, Context);
+  Function *Foo = M->getFunction("Foo");
+  auto *GA = M->getNamedAlias("GA");
+  EXPECT_EQ(M->alias_size(), 1u);
+  auto *NewGA =
+      GlobalAlias::create(Foo->getType(), 0, GlobalValue::ExternalLinkage,
+                          "NewGA", Foo, /*Parent=*/nullptr);
+  EXPECT_EQ(M->alias_size(), 1u);
+
+  M->insertAlias(NewGA);
+  EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);
+
+  M->removeAlias(NewGA);
+  EXPECT_EQ(M->alias_size(), 1u);
+  M->insertAlias(NewGA);
+  EXPECT_EQ(M->alias_size(), 2u);
+  EXPECT_EQ(&*std::prev(M->aliases().end()), NewGA);
+
+  auto Range = M->aliases();
+  EXPECT_EQ(&*Range.begin(), GA);
+  EXPECT_EQ(&*std::next(Range.begin()), NewGA);
+  EXPECT_EQ(std::next(Range.begin(), 2), Range.end());
+
+  M->removeAlias(NewGA);
+  EXPECT_EQ(M->alias_size(), 1u);
+
+  M->insertAlias(NewGA);
+  M->eraseAlias(NewGA);
+  EXPECT_EQ(M->alias_size(), 1u);
+}
+
 } // end namespace