GlobalDCE: Delete available_externally initializers if it allows removing the value...

[oota-llvm.git] / lib / Transforms / IPO / GlobalDCE.cpp

diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp
index 9decddcff80d358d3139cbdd3c217b875822054e..cdad155a0b3f3b9deec13a97d717589ab4a2f6ff 100644 (file)
--- a/lib/Transforms/IPO/GlobalDCE.cpp
+++ b/lib/Transforms/IPO/GlobalDCE.cpp
@@ -44,14 +44,19 @@ namespace {
     bool runOnModule(Module &M) override;
 
   private:
-    SmallPtrSet<GlobalValue*, 32> AliveGlobals;
+    SmallPtrSet<Constant *, 32> AliveGlobals;
     SmallPtrSet<Constant *, 8> SeenConstants;
+    SmallPtrSet<GlobalVariable *, 8> DiscardableGlobalInitializers;
 
     /// GlobalIsNeeded - mark the specific global value as needed, and
     /// recursively mark anything that it uses as also needed.
     void GlobalIsNeeded(GlobalValue *GV);
     void MarkUsedGlobalsAsNeeded(Constant *C);
 
+    /// \brief Checks if C is alive or is a ConstantExpr that refers to an alive
+    /// value.
+    bool ContainsUsedGlobal(Constant *C);
+
     bool RemoveUnusedGlobalValue(GlobalValue &GV);
   };
 }
@@ -62,7 +67,7 @@ static bool isEmptyFunction(Function *F) {
   if (Entry.size() != 1 || !isa<ReturnInst>(Entry.front()))
     return false;
   ReturnInst &RI = cast<ReturnInst>(Entry.front());
-  return RI.getReturnValue() == NULL;
+  return RI.getReturnValue() == nullptr;
 }
 
 char GlobalDCE::ID = 0;
@@ -77,13 +82,19 @@ bool GlobalDCE::runOnModule(Module &M) {
   // Remove empty functions from the global ctors list.
   Changed |= optimizeGlobalCtorsList(M, isEmptyFunction);
 
+  typedef std::multimap<const Comdat *, GlobalValue *> ComdatGVPairsTy;
+  ComdatGVPairsTy ComdatGVPairs;
+
   // Loop over the module, adding globals which are obviously necessary.
   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
     Changed |= RemoveUnusedGlobalValue(*I);
     // Functions with external linkage are needed if they have a body
-    if (!I->isDiscardableIfUnused() &&
-        !I->isDeclaration() && !I->hasAvailableExternallyLinkage())
-      GlobalIsNeeded(I);
+    if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage()) {
+      if (!I->isDiscardableIfUnused())
+        GlobalIsNeeded(I);
+      else if (const Comdat *C = I->getComdat())
+        ComdatGVPairs.insert(std::make_pair(C, I));
+    }
   }
 
   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
@@ -91,17 +102,38 @@ bool GlobalDCE::runOnModule(Module &M) {
     Changed |= RemoveUnusedGlobalValue(*I);
     // Externally visible & appending globals are needed, if they have an
     // initializer.
-    if (!I->isDiscardableIfUnused() &&
-        !I->isDeclaration() && !I->hasAvailableExternallyLinkage())
-      GlobalIsNeeded(I);
+    if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage()) {
+      if (!I->isDiscardableIfUnused())
+        GlobalIsNeeded(I);
+      else if (const Comdat *C = I->getComdat())
+        ComdatGVPairs.insert(std::make_pair(C, I));
+    }
   }
 
   for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
        I != E; ++I) {
     Changed |= RemoveUnusedGlobalValue(*I);
     // Externally visible aliases are needed.
-    if (!I->isDiscardableIfUnused())
+    if (!I->isDiscardableIfUnused()) {
       GlobalIsNeeded(I);
+    } else if (const Comdat *C = I->getComdat()) {
+      ComdatGVPairs.insert(std::make_pair(C, I));
+    }
+  }
+
+  for (ComdatGVPairsTy::iterator I = ComdatGVPairs.begin(),
+                                 E = ComdatGVPairs.end();
+       I != E;) {
+    ComdatGVPairsTy::iterator UB = ComdatGVPairs.upper_bound(I->first);
+    bool CanDiscard = std::all_of(I, UB, [](ComdatGVPairsTy::value_type Pair) {
+      return Pair.second->isDiscardableIfUnused();
+    });
+    if (!CanDiscard) {
+      std::for_each(I, UB, [this](ComdatGVPairsTy::value_type Pair) {
+        GlobalIsNeeded(Pair.second);
+      });
+    }
+    I = UB;
   }
 
   // Now that all globals which are needed are in the AliveGlobals set, we loop
@@ -135,6 +167,19 @@ bool GlobalDCE::runOnModule(Module &M) {
       I->setAliasee(nullptr);
     }
 
+  // Look for available externally constants that we can turn into normal
+  // externals by deleting their initalizers. This allows us to remove other
+  // globals that are referenced by the initializer.
+  if (!DiscardableGlobalInitializers.empty()) {
+    for (GlobalVariable *GV : DiscardableGlobalInitializers) {
+      if (!ContainsUsedGlobal(GV->getInitializer())) {
+        GV->setInitializer(nullptr);
+        GV->setLinkage(GlobalValue::ExternalLinkage);
+        Changed = true;
+      }
+    }
+  }
+
   if (!DeadFunctions.empty()) {
     // Now that all interferences have been dropped, delete the actual objects
     // themselves.
@@ -182,8 +227,12 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(G)) {
     // If this is a global variable, we must make sure to add any global values
     // referenced by the initializer to the alive set.
-    if (GV->hasInitializer())
-      MarkUsedGlobalsAsNeeded(GV->getInitializer());
+    if (GV->hasInitializer()) {
+      if (GV->hasAvailableExternallyLinkage())
+        DiscardableGlobalInitializers.insert(GV);
+      else
+        MarkUsedGlobalsAsNeeded(GV->getInitializer());
+    }
   } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(G)) {
     // The target of a global alias is needed.
     MarkUsedGlobalsAsNeeded(GA->getAliasee());
@@ -221,6 +270,21 @@ void GlobalDCE::MarkUsedGlobalsAsNeeded(Constant *C) {
   }
 }
 
+bool GlobalDCE::ContainsUsedGlobal(Constant *C) {
+  // C contains a used global If C is alive or we visited it while marking
+  // values alive.
+  if (AliveGlobals.count(C) || SeenConstants.count(C))
+    return true;
+
+  // Now check all operands of a ConstantExpr.
+  for (User::op_iterator I = C->op_begin(), E = C->op_end(); I != E; ++I) {
+    Constant *Op = dyn_cast<Constant>(*I);
+    if (Op && ContainsUsedGlobal(Op))
+      return true;
+  }
+  return false;
+}
+
 // 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