Fix unstable SmallPtrSet iteration issues due to collectUsedGlobalVariables

[MaskRay]

Summary

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

Depends on D97128 (which added a new SmallVecImpl overload for collectUsedGlobalVariables).

[MaskRay]

Rebase

[tejohnson]

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

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static const char *getSectionNameForCommandline(const Triple &T) {
   llvm_unreachable("Unimplemented ObjectFormatType");
 }
 
 void llvm::EmbedBitcodeInModule(llvm::Module &M, llvm::MemoryBufferRef Buf,
                                 bool EmbedBitcode, bool EmbedCmdline,
                                 const std::vector<uint8_t> &CmdArgs) {
   // Save llvm.compiler.used and remove it.
   SmallVector<Constant *, 2> UsedArray;
-  SmallPtrSet<GlobalValue *, 4> UsedGlobals;
+  SmallVector<GlobalValue *, 4> UsedGlobals;
   Type *UsedElementType = Type::getInt8Ty(M.getContext())->getPointerTo(0);
   GlobalVariable *Used = collectUsedGlobalVariables(M, UsedGlobals, true);
   for (auto *GV : UsedGlobals) {
     if (GV->getName() != "llvm.embedded.module" &&
         GV->getName() != "llvm.cmdline")
       UsedArray.push_back(
           ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
   }
   if (Used)
     Used->eraseFromParent();

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

struct ICallBranchFunnel final
   unsigned UniqueId;
 
 private:
   size_t NTargets;
 };
 
 struct ScopedSaveAliaseesAndUsed {
   Module &M;
-  SmallPtrSet<GlobalValue *, 16> Used, CompilerUsed;
+  SmallVector<GlobalValue *, 16> Used, CompilerUsed;
   std::vector<std::pair<GlobalIndirectSymbol *, Function *>> FunctionAliases;
 
   ScopedSaveAliaseesAndUsed(Module &M) : M(M) {
     // The users of this class want to replace all function references except
     // for aliases and llvm.used/llvm.compiler.used with references to a jump
     // table. We avoid replacing aliases in order to avoid introducing a double
     // indirection (or an alias pointing to a declaration in ThinLTO mode), and
     // we avoid replacing llvm.used/llvm.compiler.used because these global
     // variables describe properties of the global, not the jump table (besides,
     // offseted references to the jump table in llvm.used are invalid).
     // Unfortunately, LLVM doesn't have a "RAUW except for these (possibly
     // indirect) users", so what we do is save the list of globals referenced by
     // llvm.used/llvm.compiler.used and aliases, erase the used lists, let RAUW
     // replace the aliasees and then set them back to their original values at
     // the end.
     if (GlobalVariable *GV = collectUsedGlobalVariables(M, Used, false))
       GV->eraseFromParent();
     if (GlobalVariable *GV = collectUsedGlobalVariables(M, CompilerUsed, true))
       GV->eraseFromParent();
 
     for (auto &GIS : concat<GlobalIndirectSymbol>(M.aliases(), M.ifuncs())) {
       // FIXME: This should look past all aliases not just interposable ones,
       // see discussion on D65118.
       if (auto *F =
               dyn_cast<Function>(GIS.getIndirectSymbol()->stripPointerCasts()))
         FunctionAliases.push_back({&GIS, F});
     }
   }
 
   ~ScopedSaveAliaseesAndUsed() {
-    appendToUsed(M, std::vector<GlobalValue *>(Used.begin(), Used.end()));
-    appendToCompilerUsed(M, std::vector<GlobalValue *>(CompilerUsed.begin(),
-                                                       CompilerUsed.end()));
+    appendToUsed(M, Used);
+    appendToCompilerUsed(M, CompilerUsed);
 
     for (auto P : FunctionAliases)
       P.first->setIndirectSymbol(
           ConstantExpr::getBitCast(P.second, P.first->getType()));
   }
 };
 
 class LowerTypeTestsModule {