[GlobalOpt] Support "stored once" optimization for different types

[nikic]

Summary

GlobalOpt can optimize a global with undef initializer and a single store to put the stored value into the initializer instead. Currently, this requires the type of the global and the store to match.

This patch extends support to cases with different types (but same size), in which case we create a new global to replace the old one.

[aeubanks]

lg

llvm/lib/Transforms/IPO/GlobalOpt.cpp

bool CanHaveNonUndefGlobalInitializer =
             GV->getType()->getAddressSpace());
     // If the initial value for the global was an undef value, and if only
     // one other value was stored into it, we can just change the
     // initializer to be the stored value, then delete all stores to the
     // global.  This allows us to mark it constant.
     // This is restricted to address spaces that allow globals to have
     // initializers. NVPTX, for example, does not support initializers for
     // shared memory (AS 3).
-    if (SOVConstant && SOVConstant->getType() == GV->getValueType() &&
-        isa<UndefValue>(GV->getInitializer()) &&
+    if (SOVConstant && isa<UndefValue>(GV->getInitializer()) &&
+        DL.getTypeAllocSize(SOVConstant->getType()) ==
+            DL.getTypeAllocSize(GV->getValueType()) &&
         CanHaveNonUndefGlobalInitializer) {
-      // Change the initial value here.
+      if (SOVConstant->getType() == GV->getValueType()) {
+        // Change the initializer in place.
         GV->setInitializer(SOVConstant);
+      } else {
+        // Create a new global with adjusted type.
+        auto *NGV = new GlobalVariable(
+            *GV->getParent(), SOVConstant->getType(), GV->isConstant(),
+            GV->getLinkage(), SOVConstant, "", GV, GV->getThreadLocalMode(),
+            GV->getAddressSpace());
+        NGV->takeName(GV);
+        NGV->copyAttributesFrom(GV);
+        GV->replaceAllUsesWith(ConstantExpr::getBitCast(NGV, GV->getType()));
+        GV->eraseFromParent();
+        GV = NGV;
+      }
 
       // Clean up any obviously simplifiable users now.
       CleanupConstantGlobalUsers(GV, DL);
 
       if (GV->use_empty()) {
         LLVM_DEBUG(dbgs() << "   *** Substituting initializer allowed us to "
                           << "simplify all users and delete global!\n");
         GV->eraseFromParent();

llvm/test/Transforms/GlobalOpt/stored-once-different-type.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
+; RUN: opt -S -globalopt < %s | FileCheck %s
+
+@g = internal global [4 x i8] undef
+
+;.
+; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr constant i32 42
+;.
+define void @store() {
+; CHECK-LABEL: @store(
+; CHECK-NEXT:    ret void
+;
+  store i32 42, i32* bitcast ([4 x i8]* @g to i32*)
+  ret void
+}
+
+define i32 @load1() {
+; CHECK-LABEL: @load1(
+; CHECK-NEXT:    ret i32 42
+;
+  %v = load i32, i32* bitcast ([4 x i8]* @g to i32*)
+  ret i32 %v
+}
+
+define i16 @load2() {
+; CHECK-LABEL: @load2(
+; CHECK-NEXT:    ret i16 42
+;
+  %v = load i16, i16* bitcast ([4 x i8]* @g to i16*)
+  ret i16 %v
+}
+
+define [4 x i8] @load3() {
+; CHECK-LABEL: @load3(
+; CHECK-NEXT:    [[V:%.*]] = load [4 x i8], [4 x i8]* bitcast (i32* @g to [4 x i8]*), align 1
+; CHECK-NEXT:    ret [4 x i8] [[V]]
+;
+  %v = load [4 x i8], [4 x i8]* @g
+  ret [4 x i8] %v
+}

llvm/test/Transforms/GlobalOpt/stored-once-value-type.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -passes=globalopt < %s -S | FileCheck %s
 
 ; Check that we don't try to set a global initializer to a value of a different type.
 ; In this case, we were trying to set @0's initializer to be i32* null.
 
 %T = type { i32* }
 
 @0 = internal global %T* null
 
-;.
-; CHECK: @[[_BODY:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global [[T:%.*]] undef
-;.
 define void @a() {
 ; CHECK-LABEL: @a(
-; CHECK-NEXT:    store i32* null, i32** getelementptr inbounds ([[T:%.*]], %T* @.body, i64 0, i32 0), align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = load atomic i64, i64* bitcast (%T* @.body to i64*) acquire, align 8
 ; CHECK-NEXT:    ret void
 ;
   %1 = tail call i8* @_Znwm(i64 8)
   %2 = bitcast i8* %1 to %T*
   %3 = getelementptr inbounds %T, %T* %2, i64 0, i32 0
   store i32* null, i32** %3, align 8
   store i8* %1, i8** bitcast (%T** @0 to i8**), align 8
   %4 = load i64*, i64** bitcast (%T** @0 to i64**), align 8
   %5 = load atomic i64, i64* %4 acquire, align 8
   ret void
 }
 
 declare i8* @_Znwm(i64)