Make GlobalsModRef more aggressive in finding allocations associated with globals by looking through bitcasts and all-zero GEPs.i

[chandlerc]

Summary

Also switches it to use a worklist so that it doesn't recurse too
deeply.

I wrote this because I was hunting for any place where we failed to look
through poniter casts feeding loads or stores, and saw this. I have no
idea if this really matters at all, if it helps, etc. I'm not really
looking at LTO stuff at the moment and don't have time to dig into the
details, figure out if this is a worthwhile change, or write test cases.
Mailing it to the list in case someone else wants to play with it.

lib/Analysis/IPA/GlobalsModRef.cpp

 /// GV to be owned by GV and can disambiguate other pointers from it.
 bool GlobalsModRef::AnalyzeIndirectGlobalMemory(GlobalValue *GV) {
   // Keep track of values related to the allocation of the memory, f.e. the
   // value produced by the malloc call and any casts.
   std::vector<Value*> AllocRelatedValues;
 
   // Walk the user list of the global.  If we find anything other than a direct
   // load or store, bail out.
-  for (User *U : GV->users()) {
+  SmallVector<Value *, 16> Users;
+  SmallPtrSet<Value *, 16> Visited;
+  Users.push_back(GV);
+  Visited.insert(GV);
+  while (!Users.empty()) {
+    Value *V = Users.pop_back_val();
+    for (User *U : V->users()) {
+      // Recurse through no-op GEPs and bitcasts.
+      if (auto *GEP = dyn_cast<GEPOperator>(U)) {
+        if (!GEP->hasAllZeroIndices())
+          return false;
+        if (Visited.insert(GEP))
+          Users.push_back(GEP);
+        continue;
+      }
+      if (Operator::getOpcode(U) == Instruction::BitCast) {
+        if (Visited.insert(U))
+          Users.push_back(U);
+        continue;
+      }
+
       if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
         // The pointer loaded from the global can only be used in simple ways:
-      // we allow addressing of it and loading storing to it.  We do *not* allow
-      // storing the loaded pointer somewhere else or passing to a function.
-      std::vector<Function*> ReadersWriters;
+        // we allow addressing of it and loading storing to it.  We do *not*
+        // allow storing the loaded pointer somewhere else or passing to
+        // a function.
+        std::vector<Function *> ReadersWriters;
         if (AnalyzeUsesOfPointer(LI, ReadersWriters, ReadersWriters))
-        return false;  // Loaded pointer escapes.
+          return false; // Loaded pointer escapes.
         // TODO: Could try some IP mod/ref of the loaded pointer.
       } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
         // Storing the global itself.
-      if (SI->getOperand(0) == GV) return false;
+        if (SI->getOperand(0) == GV)
+          return false;
 
         // If storing the null pointer, ignore it.
         if (isa<ConstantPointerNull>(SI->getOperand(0)))
           continue;
 
         // Check the value being stored.
         Value *Ptr = GetUnderlyingObject(SI->getOperand(0));
 
         if (!isAllocLikeFn(Ptr, TLI))
-        return false;  // Too hard to analyze.
+          return false; // Too hard to analyze.
 
-      // Analyze all uses of the allocation.  If any of them are used in a
-      // non-simple way (e.g. stored to another global) bail out.
-      std::vector<Function*> ReadersWriters;
+        // Analyze all uses of the allocation.  If any of them are used in
+        // a non-simple way (e.g. stored to another global) bail out.
+        std::vector<Function *> ReadersWriters;
         if (AnalyzeUsesOfPointer(Ptr, ReadersWriters, ReadersWriters, GV))
-        return false;  // Loaded pointer escapes.
+          return false; // Loaded pointer escapes.
 
         // Remember that this allocation is related to the indirect global.
         AllocRelatedValues.push_back(Ptr);
       } else {
         // Something complex, bail out.
         return false;
       }
     }
+  }
 
   // Okay, this is an indirect global.  Remember all of the allocations for
   // this global in AllocsForIndirectGlobals.
   while (!AllocRelatedValues.empty()) {
     AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
     AllocRelatedValues.pop_back();
   }
   IndirectGlobals.insert(GV);
if (GV1 || GV2) {
     // can't know the two accesses don't overlap.
   }
 
   // These pointers may be based on the memory owned by an indirect global.  If
   // so, we may be able to handle this.  First check to see if the base pointer
   // is a direct load from an indirect global.
   GV1 = GV2 = nullptr;
   if (const LoadInst *LI = dyn_cast<LoadInst>(UV1))
-    if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
+    if (GlobalVariable *GV =
+            dyn_cast<GlobalVariable>(LI->getOperand(0)->stripPointerCasts()))
       if (IndirectGlobals.count(GV))
         GV1 = GV;
   if (const LoadInst *LI = dyn_cast<LoadInst>(UV2))
-    if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
+    if (const GlobalVariable *GV =
+            dyn_cast<GlobalVariable>(LI->getOperand(0)->stripPointerCasts()))
       if (IndirectGlobals.count(GV))
         GV2 = GV;
 
   // These pointers may also be from an allocation for the indirect global.  If
   // so, also handle them.
   if (AllocsForIndirectGlobals.count(UV1))
     GV1 = AllocsForIndirectGlobals[UV1];
   if (AllocsForIndirectGlobals.count(UV2))