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

125

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

/// @}
   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,
                                            SmallVectorImpl<GlobalValue *> &Set,
                                            bool CompilerUsed);
-GlobalVariable *collectUsedGlobalVariables(const Module &M,
-                                           SmallPtrSetImpl<GlobalValue *> &Set,
-                                           bool CompilerUsed);
 
 /// An raw_ostream inserter for modules.
 inline raw_ostream &operator<<(raw_ostream &O, const Module &M) {
   M.print(O, nullptr);
   return O;
 }
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).

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

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);
+    for (GlobalValue *V : Vec)
+      Used.insert(V);
 #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

ModuleSummaryIndex llvm::buildModuleSummaryIndex(
   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;
+  SmallVector<GlobalValue *, 8> 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());
     Set.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

struct Builder {
   Error build(ArrayRef<Module *> Mods);
 };
 
 Error Builder::addModule(Module *M) {
   if (M->getDataLayoutStr().empty())
     return make_error<StringError>("input module has no datalayout",
                                    inconvertibleErrorCode());
 
+  SmallVector<GlobalValue *, 8> UsedV;
   SmallPtrSet<GlobalValue *, 8> Used;
-  collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
+  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);
+  for (GlobalValue *V : UsedV)
+    Used.insert(V);
 
   ModuleSymbolTable Msymtab;
   Msymtab.addModule(M);
 
   storage::Module Mod;
   Mod.Begin = Syms.size();
   Mod.End = Syms.size() + Msymtab.symbols().size();
   Mod.UncBegin = Uncommons.size();

llvm/lib/Transforms/IPO/GlobalOpt.cpp

 class LLVMUsed {
   SmallPtrSet<GlobalValue *, 8> Used;
   SmallPtrSet<GlobalValue *, 8> CompilerUsed;
   GlobalVariable *UsedV;
   GlobalVariable *CompilerUsedV;
 
 public:
   LLVMUsed(Module &M) {
-    UsedV = collectUsedGlobalVariables(M, Used, false);
-    CompilerUsedV = collectUsedGlobalVariables(M, CompilerUsed, true);
+    SmallVector<GlobalValue *, 8> Vec;
+    UsedV = collectUsedGlobalVariables(M, Vec, false);
+    for (GlobalValue *V : Vec)
+      Used.insert(V);
+    Vec.clear();
+    CompilerUsedV = collectUsedGlobalVariables(M, Vec, true);
+    for (GlobalValue *V : Vec)
+      CompilerUsed.insert(V);
   }
 
   using iterator = SmallPtrSet<GlobalValue *, 8>::iterator;
   using used_iterator_range = iterator_range<iterator>;
 
   iterator usedBegin() { return Used.begin(); }
   iterator usedEnd() { return Used.end(); }
 

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 *, 8> 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())