[GlobalOpt] Collect initializer when building GlobalPart.

[fhahn]

Summary

Update the code to collect the initializer when collecting the types for
a global, as suggested by @nikic in D144476.

This replaces code which bailed out if *any* part doesn't have an
initializer with a continue to just skip parts which don't have an
initializer.

Depends on D145489.

[nikic]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

388–390

or so to only compute this once?

[fhahn]

Only call ConstantFoldLoadFromConst when new entry has been inserted.

[fhahn]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

388–390

Yeah that's better, updated!

[nikic]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

393

Can drop braces

549

Hm, if this happens, won't we leave behind references to a removed global? I think we need to make sure all initializers are known upfront, e.g. in the above offset checking loop.

[fhahn]

Bail out if global initializer cannot be evaluated (test added in a011823bff4d5399).

[fhahn]

Ping :)

[nikic]

LGTM

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static bool CleanupConstantGlobalUsers(GlobalVariable *GV,
   GV->removeDeadConstantUsers();
   return Changed;
 }
 
 /// Part of the global at a specific offset, which is only accessed through
 /// loads and stores with the given type.
 struct GlobalPart {
   Type *Ty;
+  Constant *Initializer = nullptr;
   bool IsLoaded = false;
   bool IsStored = false;
 };
 
 /// Look at all uses of the global and determine which (offset, type) pairs it
 /// can be split into.
 static bool collectSRATypes(DenseMap<uint64_t, GlobalPart> &Parts,
                             GlobalVariable *GV, const DataLayout &DL) {
if (Value *Ptr = getLoadStorePointerOperand(V)) {
       Ptr = Ptr->stripAndAccumulateConstantOffsets(DL, Offset,
                                                    /* AllowNonInbounds */ true);
       if (Ptr != GV || Offset.getActiveBits() >= 64)
         return false;
 
       // TODO: We currently require that all accesses at a given offset must
       // use the same type. This could be relaxed.
       Type *Ty = getLoadStoreType(V);
-      auto It = Parts.try_emplace(Offset.getZExtValue(), GlobalPart{Ty}).first;
+      const auto &[It, Inserted] =
+          Parts.try_emplace(Offset.getZExtValue(), GlobalPart{Ty});
       if (Ty != It->second.Ty)
         return false;
 
+      if (Inserted) {
+        It->second.Initializer =
+            ConstantFoldLoadFromConst(GV->getInitializer(), Ty, Offset, DL);
+      }
+
       // Scalable types not currently supported.
       if (isa<ScalableVectorType>(Ty))
         return false;
 
-      auto IsStored = [GV, &DL, &Offset](Value *V) {
+      auto IsStored = [](Value *V, Constant *Initializer) {
         auto *SI = dyn_cast<StoreInst>(V);
         if (!SI)
           return false;
 
         Constant *StoredConst = dyn_cast<Constant>(SI->getOperand(0));
         if (!StoredConst)
           return true;
 
         // Don't consider stores that only write the initializer value.
-        if (Constant *Result = ConstantFoldLoadFromConst(
-                GV->getInitializer(), StoredConst->getType(), Offset, DL))
-          return Result != StoredConst;
-
-        return true;
+        return Initializer != StoredConst;
       };
 
       It->second.IsLoaded |= isa<LoadInst>(V);
-      It->second.IsStored |= IsStored(V);
+      It->second.IsStored |= IsStored(V, It->second.Initializer);
       continue;
     }
 
     // Ignore dead constant users.
     if (auto *C = dyn_cast<Constant>(V)) {
       if (!isSafeToDestroyConstant(C))
         return false;
       continue;
static GlobalVariable *SRAGlobal(GlobalVariable *GV, const DataLayout &DL) {
   // to be optimized away.
   unsigned NumParts = count_if(Parts, [](const auto &Pair) {
     return Pair.second.IsLoaded && Pair.second.IsStored;
   });
   if (NumParts > 16)
     return nullptr;
 
   // Sort by offset.
-  SmallVector<std::pair<uint64_t, Type *>, 16> TypesVector;
+  SmallVector<std::tuple<uint64_t, Type *, Constant *>, 16> TypesVector;
   for (const auto &Pair : Parts)
-    TypesVector.push_back({Pair.first, Pair.second.Ty});
+    TypesVector.push_back(
+        {Pair.first, Pair.second.Ty, Pair.second.Initializer});
   sort(TypesVector, llvm::less_first());
 
   // Check that the types are non-overlapping.
   uint64_t Offset = 0;
-  for (const auto &[OffsetForTy, Ty] : TypesVector) {
+  for (const auto &[OffsetForTy, Ty, _] : TypesVector) {
     // Overlaps with previous type.
     if (OffsetForTy < Offset)
       return nullptr;
 
     Offset = OffsetForTy + DL.getTypeAllocSize(Ty);
   }
 
   // Some accesses go beyond the end of the global, don't bother.
   if (Offset > DL.getTypeAllocSize(GV->getValueType()))
     return nullptr;
 
-  // Collect initializers for new globals.
-  Constant *OrigInit = GV->getInitializer();
-  DenseMap<uint64_t, Constant *> Initializers;
-  for (const auto &[OffsetForTy, Ty] : TypesVector) {
-    Constant *NewInit =
-        ConstantFoldLoadFromConst(OrigInit, Ty, APInt(64, OffsetForTy), DL);
-    if (!NewInit) {
-      LLVM_DEBUG(dbgs() << "Global SRA: Failed to evaluate initializer of "
-                        << *GV << " with type " << *Ty << " at offset "
-                        << OffsetForTy << "\n");
-      return nullptr;
-    }
-    Initializers.insert({OffsetForTy, NewInit});
-  }
-
   LLVM_DEBUG(dbgs() << "PERFORMING GLOBAL SRA ON: " << *GV << "\n");
 
   // Get the alignment of the global, either explicit or target-specific.
   Align StartAlignment =
       DL.getValueOrABITypeAlignment(GV->getAlign(), GV->getValueType());
   uint64_t VarSize = DL.getTypeSizeInBits(GV->getValueType());
 
   // Create replacement globals.
   DenseMap<uint64_t, GlobalVariable *> NewGlobals;
   unsigned NameSuffix = 0;
-  for (auto &[OffsetForTy, Ty] : TypesVector) {
+  for (auto &[OffsetForTy, Ty, Initializer] : TypesVector) {
+    if (!Initializer) {
+      LLVM_DEBUG(dbgs() << "Global SRA: Failed to evaluate initializer of "
+                        << *GV << " with type " << *Ty << " at offset "
+                        << OffsetForTy << "\n");
+      continue;
+    }
     GlobalVariable *NGV = new GlobalVariable(
         *GV->getParent(), Ty, false, GlobalVariable::InternalLinkage,
-        Initializers[OffsetForTy], GV->getName() + "." + Twine(NameSuffix++),
-        GV, GV->getThreadLocalMode(), GV->getAddressSpace());
+        Initializer, GV->getName() + "." + Twine(NameSuffix++), GV,
+        GV->getThreadLocalMode(), GV->getAddressSpace());
     NGV->copyAttributesFrom(GV);
     NewGlobals.insert({OffsetForTy, NGV});
 
     // Calculate the known alignment of the field.  If the original aggregate
     // had 256 byte alignment for example, something might depend on that:
     // propagate info to each field.
     Align NewAlign = commonAlignment(StartAlignment, OffsetForTy);
     if (NewAlign > DL.getABITypeAlign(Ty))