collectUsedGlobalVariables: migrate SmallPtrSetImpl overload to SmallVecImpl overload after D97128

[MaskRay]

Summary

And delete the SmallPtrSetImpl overload.

While here, decrease inline element counts from 8 to 4. See D97128 for the choice.

[tejohnson]

llvm/lib/Object/IRSymtab.cpp

123

Can you simply use a different constructor for Used that takes the begin and end iterator to avoid a loop? Here and other places where possible.

[MaskRay]

Simplify with begin/end constructor

[tejohnson]

Add that it depends on D97128 to summary (which will help point to context for anyone looking at this later).
lgtm

[MaskRay]

rebase

llvm/include/llvm/IR/Module.h

/// @}
   /// Take ownership of the given memory buffer.
   void setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB);
 
   /// Set the partial sample profile ratio in the profile summary module flag,
   /// if applicable.
   void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index);
 };
 
-/// Given "llvm.used" or "llvm.compiler.used" as a global name, collect
-/// the initializer elements of that global in Set and return the global itself.
-GlobalVariable *collectUsedGlobalVariables(const Module &M,
-                                           SmallPtrSetImpl<GlobalValue *> &Set,
-                                           bool CompilerUsed);
 /// Given "llvm.used" or "llvm.compiler.used" as a global name, collect the
 /// initializer elements of that global in a SmallVector and return the global
 /// itself.
 GlobalVariable *collectUsedGlobalVariables(const Module &M,
                                            SmallVectorImpl<GlobalValue *> &Vec,
                                            bool CompilerUsed);
 
 /// An raw_ostream inserter for modules.

llvm/include/llvm/Transforms/Utils/FunctionImportUtils.h

class FunctionImportGlobalProcessing {
   /// dso_local to disable direct access.
   ///
   /// This flag should not be set for -fno-pic or -fpie, which would
   /// unnecessarily disable direct access.
   bool ClearDSOLocalOnDeclarations;
 
   /// Set of llvm.*used values, in order to validate that we don't try
   /// to promote any non-renamable values.
-  SmallPtrSet<GlobalValue *, 8> Used;
+  SmallPtrSet<GlobalValue *, 4> Used;
 
   /// Keep track of any COMDATs that require renaming (because COMDAT
   /// leader was promoted and renamed). Maps from original COMDAT to one
   /// with new name.
   DenseMap<const Comdat *, Comdat *> RenamedComdats;
 
   /// Check if we should promote the given local value to global scope.
   bool shouldPromoteLocalToGlobal(const GlobalValue *SGV, ValueInfo VI);
FunctionImportGlobalProcessing(Module &M, const ModuleSummaryIndex &Index,
     // If we have a ModuleSummaryIndex but no function to import,
     // then this is the primary module being compiled in a ThinLTO
     // backend compilation, and we need to see if it has functions that
     // may be exported to another backend compilation.
     if (!GlobalsToImport)
       HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
 
 #ifndef NDEBUG
+    SmallVector<GlobalValue *, 4> Vec;
     // First collect those in the llvm.used set.
-    collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
+    collectUsedGlobalVariables(M, Vec, /*CompilerUsed=*/false);
     // Next collect those in the llvm.compiler.used set.
-    collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
+    collectUsedGlobalVariables(M, Vec, /*CompilerUsed=*/true);
+    Used = {Vec.begin(), Vec.end()};
 #endif
   }
 
   bool run();
 };
 
 /// Perform in-place global value handling on the given Module for
 /// exported local functions renamed and promoted for ThinLTO.

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

if (auto *MD = mdconst::extract_or_null<ConstantInt>(
     EnableSplitLTOUnit = MD->getZExtValue();
   ModuleSummaryIndex Index(/*HaveGVs=*/true, EnableSplitLTOUnit);
 
   // Identify the local values in the llvm.used and llvm.compiler.used sets,
   // which should not be exported as they would then require renaming and
   // promotion, but we may have opaque uses e.g. in inline asm. We collect them
   // here because we use this information to mark functions containing inline
   // assembly calls as not importable.
-  SmallPtrSet<GlobalValue *, 8> LocalsUsed;
-  SmallPtrSet<GlobalValue *, 8> Used;
+  SmallPtrSet<GlobalValue *, 4> LocalsUsed;
+  SmallVector<GlobalValue *, 4> Used;
   // First collect those in the llvm.used set.
-  collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
+  collectUsedGlobalVariables(M, Used, /*CompilerUsed=*/false);
   // Next collect those in the llvm.compiler.used set.
-  collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
+  collectUsedGlobalVariables(M, Used, /*CompilerUsed=*/true);
   DenseSet<GlobalValue::GUID> CantBePromoted;
   for (auto *V : Used) {
     if (V->hasLocalLinkage()) {
       LocalsUsed.insert(V);
       CantBePromoted.insert(V->getGUID());
     }
   }
 

llvm/lib/IR/Module.cpp

GlobalVariable *llvm::collectUsedGlobalVariables(
   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
   for (Value *Op : Init->operands()) {
     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
     Vec.push_back(G);
   }
   return GV;
 }
 
-GlobalVariable *llvm::collectUsedGlobalVariables(
-    const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
-  const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
-  GlobalVariable *GV = M.getGlobalVariable(Name);
-  if (!GV || !GV->hasInitializer())
-    return GV;
-
-  const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
-  for (Value *Op : Init->operands()) {
-    GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
-    Set.insert(G);
-  }
-  return GV;
-}
-
 void Module::setPartialSampleProfileRatio(const ModuleSummaryIndex &Index) {
   if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
     std::unique_ptr<ProfileSummary> ProfileSummary(
         ProfileSummary::getFromMD(SummaryMD));
     if (ProfileSummary) {
       if (ProfileSummary->getKind() != ProfileSummary::PSK_Sample ||
           !ProfileSummary->isPartialProfile())
         return;

llvm/lib/Object/IRSymtab.cpp

void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
     Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
                   reinterpret_cast<const char *>(Objs.data() + Objs.size()));
   }
 
   Expected<int> getComdatIndex(const Comdat *C, const Module *M);
 
   Error addModule(Module *M);
   Error addSymbol(const ModuleSymbolTable &Msymtab,
-                  const SmallPtrSet<GlobalValue *, 8> &Used,
+                  const SmallPtrSet<GlobalValue *, 4> &Used,
                   ModuleSymbolTable::Symbol Sym);
 
   Error build(ArrayRef<Module *> Mods);
 };
 
 Error Builder::addModule(Module *M) {
   if (M->getDataLayoutStr().empty())
     return make_error<StringError>("input module has no datalayout",
                                    inconvertibleErrorCode());
 
-  SmallPtrSet<GlobalValue *, 8> Used;
-  collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
+  SmallVector<GlobalValue *, 4> UsedV;
+  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);
+  SmallPtrSet<GlobalValue *, 4> Used(UsedV.begin(), UsedV.end());
 
   ModuleSymbolTable Msymtab;
   Msymtab.addModule(M);
 
   storage::Module Mod;
   Mod.Begin = Syms.size();
   Mod.End = Syms.size() + Msymtab.symbols().size();
   Mod.UncBegin = Uncommons.size();
if (P.second) {
     setStr(Comdat.Name, Saver.save(Name));
     Comdats.push_back(Comdat);
   }
 
   return P.first->second;
 }
 
 Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
-                         const SmallPtrSet<GlobalValue *, 8> &Used,
+                         const SmallPtrSet<GlobalValue *, 4> &Used,
                          ModuleSymbolTable::Symbol Msym) {
   Syms.emplace_back();
   storage::Symbol &Sym = Syms.back();
   Sym = {};
 
   storage::Uncommon *Unc = nullptr;
   auto Uncommon = [&]() -> storage::Uncommon & {
     if (Unc)

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static void setUsedInitializer(GlobalVariable &V,
   NV->setSection("llvm.metadata");
   delete &V;
 }
 
 namespace {
 
 /// An easy to access representation of llvm.used and llvm.compiler.used.
 class LLVMUsed {
-  SmallPtrSet<GlobalValue *, 8> Used;
-  SmallPtrSet<GlobalValue *, 8> CompilerUsed;
+  SmallPtrSet<GlobalValue *, 4> Used;
+  SmallPtrSet<GlobalValue *, 4> CompilerUsed;
   GlobalVariable *UsedV;
   GlobalVariable *CompilerUsedV;
 
 public:
   LLVMUsed(Module &M) {
-    UsedV = collectUsedGlobalVariables(M, Used, false);
-    CompilerUsedV = collectUsedGlobalVariables(M, CompilerUsed, true);
+    SmallVector<GlobalValue *, 4> Vec;
+    UsedV = collectUsedGlobalVariables(M, Vec, false);
+    Used = {Vec.begin(), Vec.end()};
+    Vec.clear();
+    CompilerUsedV = collectUsedGlobalVariables(M, Vec, true);
+    CompilerUsed = {Vec.begin(), Vec.end()};
   }
 
-  using iterator = SmallPtrSet<GlobalValue *, 8>::iterator;
+  using iterator = SmallPtrSet<GlobalValue *, 4>::iterator;
   using used_iterator_range = iterator_range<iterator>;
 
   iterator usedBegin() { return Used.begin(); }
   iterator usedEnd() { return Used.end(); }
 
   used_iterator_range used() {
     return used_iterator_range(usedBegin(), usedEnd());
   }

llvm/lib/Transforms/IPO/Internalize.cpp

void InternalizePass::checkComdatVisibility(
   if (shouldPreserveGV(GV))
     ExternalComdats.insert(C);
 }
 
 bool InternalizePass::internalizeModule(Module &M, CallGraph *CG) {
   bool Changed = false;
   CallGraphNode *ExternalNode = CG ? CG->getExternalCallingNode() : nullptr;
 
-  SmallPtrSet<GlobalValue *, 8> Used;
+  SmallVector<GlobalValue *, 4> Used;
   collectUsedGlobalVariables(M, Used, false);
 
   // Collect comdat visiblity information for the module.
   DenseSet<const Comdat *> ExternalComdats;
   if (!M.getComdatSymbolTable().empty()) {
     for (Function &F : M)
       checkComdatVisibility(F, ExternalComdats);
     for (GlobalVariable &GV : M.globals())