[GlobalDCE] Simplify and return Changed = true less often

[foad]

Summary

Removing dead constants should not count as making a change to the
module. This means that RemoveUnusedGlobalValue simplifies to just
calling removeDeadConstantUsers, so inline it.

[foad]

TBH I'm not even sure that any of these calls to removeDeadConstantUsers are required. Nothing seems to fail if I remove them. But I kept them for now to keep this patch conservative.

[serge-sans-paille]

Yeah, better keep this conservative, and this patch looks good. If you're brave you could try to craft an extra .ll that have multiple constant users and see if the algorithm can get rid of them without the calls to removeDeadConstantUsers.

llvm/lib/Transforms/IPO/GlobalDCE.cpp

if (Comdat *C = GA.getComdat())
       ComdatMembers.insert(std::make_pair(C, &GA));
 
   // Add dependencies between virtual call sites and the virtual functions they
   // might call, if we have that information.
   AddVirtualFunctionDependencies(M);
 
   // Loop over the module, adding globals which are obviously necessary.
   for (GlobalObject &GO : M.global_objects()) {
-    Changed |= RemoveUnusedGlobalValue(GO);
+    GO.removeDeadConstantUsers();
     // Functions with external linkage are needed if they have a body.
     // Externally visible & appending globals are needed, if they have an
     // initializer.
     if (!GO.isDeclaration())
       if (!GO.isDiscardableIfUnused())
         MarkLive(GO);
 
     UpdateGVDependencies(GO);
   }
 
   // Compute direct dependencies of aliases.
   for (GlobalAlias &GA : M.aliases()) {
-    Changed |= RemoveUnusedGlobalValue(GA);
+    GA.removeDeadConstantUsers();
     // Externally visible aliases are needed.
     if (!GA.isDiscardableIfUnused())
       MarkLive(GA);
 
     UpdateGVDependencies(GA);
   }
 
   // Compute direct dependencies of ifuncs.
   for (GlobalIFunc &GIF : M.ifuncs()) {
-    Changed |= RemoveUnusedGlobalValue(GIF);
+    GIF.removeDeadConstantUsers();
     // Externally visible ifuncs are needed.
     if (!GIF.isDiscardableIfUnused())
       MarkLive(GIF);
 
     UpdateGVDependencies(GIF);
   }
 
   // Propagate liveness from collected Global Values through the computed
for (GlobalIFunc &GIF : M.ifuncs())
     if (!AliveGlobals.count(&GIF)) {
       DeadIFuncs.push_back(&GIF);
       GIF.setResolver(nullptr);
     }
 
   // Now that all interferences have been dropped, delete the actual objects
   // themselves.
   auto EraseUnusedGlobalValue = [&](GlobalValue *GV) {
-    RemoveUnusedGlobalValue(*GV);
+    GV->removeDeadConstantUsers();
     GV->eraseFromParent();
     Changed = true;
   };
 
   NumFunctions += DeadFunctions.size();
   for (Function *F : DeadFunctions) {
     if (!F->use_empty()) {
       // Virtual functions might still be referenced by one or more vtables,
PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) {
   ComdatMembers.clear();
   TypeIdMap.clear();
   VFESafeVTables.clear();
 
   if (Changed)
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
-
-// RemoveUnusedGlobalValue - Loop over all of the uses of the specified
-// GlobalValue, looking for the constant pointer ref that may be pointing to it.
-// If found, check to see if the constant pointer ref is safe to destroy, and if
-// so, nuke it.  This will reduce the reference count on the global value, which
-// might make it deader.
-//
-bool GlobalDCEPass::RemoveUnusedGlobalValue(GlobalValue &GV) {
-  if (GV.use_empty())
-    return false;
-  GV.removeDeadConstantUsers();
-  return GV.use_empty();
-}