[GlobalOpt] Ignore only loaded / only stored global parts in global SRA heuristic

[nikic]

Summary

When limiting the number of parts we split a global into, ignore any parts that are either only loaded or only stored, because we expect these to be optimized away after SRA.

This is intended as an alternative to D129525.

[fhahn]

I just tried this on the original reproducer and it's not sufficient unfortunately. I'll extract an updated reproducer.

[fhahn]

I added a reduced test case from https://github.com/llvm/llvm-project/issues/56762 which has a single store to the global which makes the logic here not trigger unfortunately: https://github.com/llvm/llvm-project/commit/91e67c074922cc667fa1c43fc1f01acb96faa0f9

To solve this in general, we could probably track which fields of a global are never modified and then ignore such loads from the count. I'm still wondering if we should re-introduce the previous logic until we are able to completely address this properly to avoid regressions.

[nikic]

I've updated the patch to treat loads and stores symmetrically: We only count the part if it is both loaded and stored. In other cases, we expect it to be optimized away.

[fhahn]

In D129857#3852044, @nikic wrote:

I've updated the patch to treat loads and stores symmetrically: We only count the part if it is both loaded and stored. In other cases, we expect it to be optimized away.

Thanks, I finally had some time to track down the cases missed by the current version of the heuristic for the larger reproducer. I added a set of test case, rebased the change here (https://github.com/fhahn/llvm-project/commit/1053ab2c24811bfc2bdf4b8b0bf5da15c2772de3) and put up D144468, D144476, D144477. With those, we get the expected optimizations without D129525. So I think we should move ahead with this patch and the follow-ups.

[nikic]

Rebase

[fhahn]

LGTM, thanks!

llvm/lib/Transforms/IPO/GlobalOpt.cpp

340

might be good to document the struct

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static bool CleanupConstantGlobalUsers(GlobalVariable *GV,
   }
 
   Changed |=
       RecursivelyDeleteTriviallyDeadInstructionsPermissive(MaybeDeadInsts);
   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;
+  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,
                             GlobalValue *GV, const DataLayout &DL) {
   SmallVector<Use *, 16> Worklist;
   SmallPtrSet<Use *, 16> Visited;
if (Value *Ptr = getLoadStorePointerOperand(V)) {
       auto It = Parts.try_emplace(Offset.getZExtValue(), GlobalPart{Ty}).first;
       if (Ty != It->second.Ty)
         return false;
 
       // Scalable types not currently supported.
       if (isa<ScalableVectorType>(Ty))
         return false;
 
+      It->second.IsLoaded |= isa<LoadInst>(V);
+      It->second.IsStored |= isa<StoreInst>(V);
       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) {
   DenseMap<uint64_t, GlobalPart> Parts;
   if (!collectSRATypes(Parts, GV, DL) || Parts.empty())
     return nullptr;
 
   // Make sure we don't SRA back to the same type.
   if (Parts.size() == 1 && Parts.begin()->second.Ty == GV->getValueType())
     return nullptr;
 
-  // Don't perform SRA if we would have to split into many globals.
-  if (Parts.size() > 16)
+  // Don't perform SRA if we would have to split into many globals. Ignore
+  // parts that are either only loaded or only stored, because we expect them
+  // 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;
   for (const auto &Pair : Parts)
     TypesVector.push_back({Pair.first, Pair.second.Ty});
   sort(TypesVector, llvm::less_first());
 

llvm/test/Transforms/GlobalOpt/sra-many-stores.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -passes=globalopt -S %s | FileCheck %s
 
 %struct.widget = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
 
 @global = internal global %struct.widget zeroinitializer
 
 
 ;.
-; CHECK: @[[GLOBAL:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_WIDGET:%.*]] zeroinitializer
-; CHECK: @[[GLOBAL_ARRAY_IN_STRUCT:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_WITH_ARRAY:%.*]] zeroinitializer
-; CHECK: @[[GLOBAL_ARRAY:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [100 x i64] zeroinitializer
 ; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = global i8 0, align 4
-; CHECK: @[[B:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20I8:%.*]] { i8 4, i8 4, i8 4, i8 5, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 5, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4 }
 ; CHECK: @[[GLOBAL_20PTR:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[STRUCT_20PTR:%.*]] zeroinitializer
 ; CHECK: @[[C:[a-zA-Z0-9_$"\\.-]+]] = global ptr null
 ;.
 define internal void @read_struct() {
 ; CHECK-LABEL: @read_struct(
-; CHECK-NEXT:    [[TMP:%.*]] = load ptr, ptr getelementptr inbounds ([[STRUCT_WIDGET:%.*]], ptr @global, i64 0, i32 16), align 8
 ; CHECK-NEXT:    ret void
 ;
   %tmp = load ptr, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 16), align 8
   ret void
 }
 
 define void @write_struct() {
 ; CHECK-LABEL: @write_struct(
-; CHECK-NEXT:    store ptr null, ptr @global, align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET:%.*]], ptr @global, i64 0, i32 1), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 2), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 3), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 4), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 5), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 6), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 7), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 8), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 9), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 10), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 11), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 12), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 13), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 14), align 8
-; CHECK-NEXT:    store ptr null, ptr getelementptr inbounds ([[STRUCT_WIDGET]], ptr @global, i64 0, i32 15), align 8
 ; CHECK-NEXT:    tail call fastcc void @read_struct()
 ; CHECK-NEXT:    ret void
 ;
   store ptr null, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 0), align 8
   store ptr null, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 1), align 8
   store ptr null, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 2), align 8
   store ptr null, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 3), align 8
   store ptr null, ptr getelementptr inbounds (%struct.widget, ptr @global, i64 0, i32 4), align 8

 
 
 %struct.with.array = type { [100 x i64], i64 }
 
 @global.array_in_struct = internal global %struct.with.array zeroinitializer
 
 define internal void @read_non_array_field() {
 ; CHECK-LABEL: @read_non_array_field(
-; CHECK-NEXT:    [[TMP:%.*]] = load i64, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY:%.*]], ptr @global.array_in_struct, i64 0, i32 1), align 8
 ; CHECK-NEXT:    ret void
 ;
   %tmp = load i64, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 1), align 8
   ret void
 }
 
 define void @store_to_struct_array() {
 ; CHECK-LABEL: @store_to_struct_array(
-; CHECK-NEXT:    store i64 0, ptr @global.array_in_struct, align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY:%.*]], ptr @global.array_in_struct, i64 0, i32 0, i32 1), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 2), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 3), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 4), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 5), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 6), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 7), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 8), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 9), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 10), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 11), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 12), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 13), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 14), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([[STRUCT_WITH_ARRAY]], ptr @global.array_in_struct, i64 0, i32 0, i32 15), align 8
 ; CHECK-NEXT:    tail call fastcc void @read_non_array_field()
 ; CHECK-NEXT:    ret void
 ;
   store i64 0, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 0, i32 0), align 8
   store i64 0, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 0, i32 1), align 8
   store i64 0, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 0, i32 2), align 8
   store i64 0, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 0, i32 3), align 8
   store i64 0, ptr getelementptr inbounds (%struct.with.array, ptr @global.array_in_struct, i64 0, i32 0, i32 4), align 8
;
   tail call void @read_non_array_field()
   ret void
 }
 
 @global.array = internal global [100 x i64] zeroinitializer
 
 define internal void @read_array() {
 ; CHECK-LABEL: @read_array(
-; CHECK-NEXT:    [[TMP:%.*]] = load i64, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 99), align 8
 ; CHECK-NEXT:    ret void
 ;
   %tmp = load i64, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 99), align 8
   ret void
 }
 
 define void @store_to_array() {
 ; CHECK-LABEL: @store_to_array(
-; CHECK-NEXT:    store i64 0, ptr @global.array, align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 1), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 2), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 3), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 4), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 5), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 6), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 7), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 8), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 9), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 10), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 11), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 12), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 13), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 14), align 8
-; CHECK-NEXT:    store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 15), align 8
 ; CHECK-NEXT:    tail call fastcc void @read_array()
 ; CHECK-NEXT:    ret void
 ;
   store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 0), align 8
   store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 1), align 8
   store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 2), align 8
   store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 3), align 8
   store i64 0, ptr getelementptr inbounds ([100 x i64], ptr @global.array, i64 0, i32 4), align 8

 
 
 %struct.20i8 = type { i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8 }
 @a = global i8 0, align 4
 @b = internal global  %struct.20i8 { i8 4, i8 4, i8 4, i8 5, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 5, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4 }
 
 define void @test_single_write_to_global_b() {
 ; CHECK-LABEL: @test_single_write_to_global_b(
-; CHECK-NEXT:    store i8 0, ptr getelementptr inbounds ([[STRUCT_20I8:%.*]], ptr @b, i64 0, i32 1), align 1
-; CHECK-NEXT:    [[I3:%.*]] = load i8, ptr @b, align 16
-; CHECK-NEXT:    store volatile i8 [[I3]], ptr @a, align 4
-; CHECK-NEXT:    [[I4:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 2), align 2
-; CHECK-NEXT:    store volatile i8 [[I4]], ptr @a, align 4
-; CHECK-NEXT:    [[I5:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 3), align 1
-; CHECK-NEXT:    store volatile i8 [[I5]], ptr @a, align 4
-; CHECK-NEXT:    [[I6:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 4), align 4
-; CHECK-NEXT:    store volatile i8 [[I6]], ptr @a, align 4
-; CHECK-NEXT:    [[I7:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 5), align 1
-; CHECK-NEXT:    store volatile i8 [[I7]], ptr @a, align 4
-; CHECK-NEXT:    [[I8:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 7), align 1
-; CHECK-NEXT:    store volatile i8 [[I8]], ptr @a, align 4
-; CHECK-NEXT:    [[I9:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 8), align 8
-; CHECK-NEXT:    store volatile i8 [[I9]], ptr @a, align 4
-; CHECK-NEXT:    [[I10:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 9), align 1
-; CHECK-NEXT:    store volatile i8 [[I10]], ptr @a, align 4
-; CHECK-NEXT:    [[I11:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 10), align 2
-; CHECK-NEXT:    store volatile i8 [[I11]], ptr @a, align 4
-; CHECK-NEXT:    [[I12:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 11), align 1
-; CHECK-NEXT:    store volatile i8 [[I12]], ptr @a, align 4
-; CHECK-NEXT:    [[I13:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 12), align 4
-; CHECK-NEXT:    store volatile i8 [[I13]], ptr @a, align 4
-; CHECK-NEXT:    [[I14:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 13), align 1
-; CHECK-NEXT:    store volatile i8 [[I14]], ptr @a, align 4
-; CHECK-NEXT:    [[I15:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 14), align 2
-; CHECK-NEXT:    store volatile i8 [[I15]], ptr @a, align 4
-; CHECK-NEXT:    [[I16:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 15), align 1
-; CHECK-NEXT:    store volatile i8 [[I16]], ptr @a, align 4
-; CHECK-NEXT:    [[I17:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 16), align 16
-; CHECK-NEXT:    store volatile i8 [[I17]], ptr @a, align 4
-; CHECK-NEXT:    [[I18:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 17), align 1
-; CHECK-NEXT:    store volatile i8 [[I18]], ptr @a, align 4
-; CHECK-NEXT:    [[I19:%.*]] = load i8, ptr getelementptr inbounds ([[STRUCT_20I8]], ptr @b, i64 0, i32 18), align 2
-; CHECK-NEXT:    store volatile i8 [[I19]], ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 5, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 5, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
+; CHECK-NEXT:    store volatile i8 4, ptr @a, align 4
 ; CHECK-NEXT:    ret void
 ;
   store i8 0, ptr getelementptr inbounds (%struct.20i8, ptr @b, i64 0, i32 1), align 1
   %i3 = load i8, ptr @b, align 16
   store volatile i8 %i3, ptr @a, align 4
   %i4 = load i8, ptr getelementptr inbounds (%struct.20i8, ptr @b, i64 0, i32 2), align 2
   store volatile i8 %i4, ptr @a, align 4
   %i5 = load i8, ptr getelementptr inbounds (%struct.20i8, ptr @b, i64 0, i32 3), align 1