[GlobalOpt] Optimize comdat dynamic initializers on Windows

[rnk]

Summary

The motivation is to be able to optimize dynamic initialization of
things with vague linkage, as in this C++ code:

struct my_id {
  my_id() : v_(0) {}
  int v_;
};
template <typename T> struct Foo { static my_id id; };
template <typename T> my_id Foo<T>::id;
int main() { Foo<char>::id.v_++; }

Here, we have a class with a non-trivial, non-constexpr default
constructor, and we instantiate a static data member of a class template
of that type.

Normally, globalopt refuses to modify initializers of globals with weak
linkage because it has no way of knowing if the linker will select the
modified or unmodified global, or if there will be some duplicate
initializer that performs the same effect twice.

However, when the initializer modifies the global used as its comdat key
in llvm.global_ctors, we know that, in the Microsoft C++ ABI, if
globalopt succeeds and the modified global prevails at link time, all of
the other initializers will be discarded.

The Itanium C++ ABI does not (currently) provide a guarantee that the
.init_array entry will be in the same comdat group as the global, so it
instead requires that the compiler emit a guard variable check to
prevent double initialization as described here:
https://itanium-cxx-abi.github.io/cxx-abi/abi.html#guards

I felt it was best to make globalopt check the triple, even though in
practice, the Itanium guard variable check blocks globalopt because the
guard variable is in its own comdat group and has weak linkage.

Fixes PR39712

[efriedma]

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

If the IR doesn't have enough information to distinguish between the Microsoft and Itanium ABI cases, we should extend the IR to contain more information. Checking the triple means we're depending on semantic guarantees which are not documented in LangRef, and many not apply to non-C++ languages.

[rjmccall]

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

I agree with Eli. This is clearly a frontend-originated guarantee, not a target-wide guarantee, and should be reflected in the IR.

[rnk]

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

For platforms with comdats, I wanted to push this same idea through the Itanium C++ ABI. It completely eliminates the need for guard variables for initializers of variables with vague linkage, although only if they are hidden, so other DSOs don't try to initialize them.

What do you think of some kind of global named metadata node for this? This is such a complicated guarantee to express, I've tried and failed to write it down concisely three times. !llvm.assume_comdat_ctors? !llvm.comdat_initializers = !{i32 0, i32 1}? I like "comdat_initializers".

[rjmccall]

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

For platforms with comdats, I wanted to push this same idea through the Itanium C++ ABI. It completely eliminates the need for guard variables for initializers of variables with vague linkage, although only if they are hidden, so other DSOs don't try to initialize them.

Okay, but it's still not a target-wide thing, it's a rule of a specific language ABI. That's a higher level of abstraction than LLVM IR and should be opt-in on a variable-by-variable basis.

This is such a complicated guarantee to express, I've tried and failed to write it down concisely three times.

"If this definition of the global variable is chosen by the linker, there is an associated global constructor function that will also be chosen by the linker, and it is undefined behavior if any other global constructor accesses the variable before the associated constructor runs." I'd call it comdat_global_ctor, but the "comdat" in the name is just suggestive, not a core aspect of the semantics.

[efriedma]

Global metadata pointing to what, exactly? The global variables?

The comdat key in global_ctors provides some sort of guarantee that the global variable definitions in that comdat are "strong", in some sense: if the comdat were discarded, the ctor would also be discarded. Do we really need any additional guarantee from the frontend?

llvm/lib/Transforms/Utils/Evaluator.cpp

131

Actually, if we have a ComdatGV, isn't it illegal to update globals where hasUniqueInitializer() is true? The constructor could be discarded. For example, something like this:

void foo();
struct S { S() { foo(); } static S s; };
inline S S::s;
S *ss = &S::s;
int x;
void foo(){ x++; }

[rnk]

It would be nice if globalopt could do a better job on these kinds of things, too:

inline int foo() { return 42; }
int bar();
static int block_globalopt = bar();
static int g1 = foo();
static int g2 = foo();
static int g3 = foo();
int *arr[] = {&block_globalopt, &g1, &g2, &g3};

C++ requires that these globals are initialized in order, but (I think?) it's UB if any of the globals are accessed before they are constructed. Right now, to provide the order guarantee, we lump all the non-comdat initializers into a _GLOBAL__sub_I_ function. As a consequence, globalopt is all or nothing: either everything can be optimized, or nothing can be. In this example, because it can't see through bar, it won't fire.

Maybe we should consider giving a stronger guarantee for the order in which global_ctors entries run, so that clang can instead emit these all separately.

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

I wasn't going to go so far as to make it variable-by-variable, I was just going to make it a global named metadata tuple. I guess a metadata attachment on the global variable being initialized would be OK, since removing just blocks the optimization, which is semantics preserving. I don't like it that much, since I really feel like this optimization should be done as a matter of course. It sounds like you folks think that's the way to go, though?

llvm/lib/Transforms/Utils/Evaluator.cpp

131

You're right. Initially I was thinking this definition of x will always prevail so modifying it is safe, but the initializer may not prevail, and we could now double-increment x. I think it's fixable. Basically, if this is an initializer for something in a comdat, we can only touch globals in that comdat group, so they all go together.

[rjmccall]

In D54774#1308714, @rnk wrote:

It would be nice if globalopt could do a better job on these kinds of things, too:

inline int foo() { return 42; }
int bar();
static int block_globalopt = bar();
static int g1 = foo();
static int g2 = foo();
static int g3 = foo();
int *arr[] = {&block_globalopt, &g1, &g2, &g3};

C++ requires that these globals are initialized in order, but (I think?) it's UB if any of the globals are accessed before they are constructed.

As seen in the example at the end of [basic.start.static], no, this is not UB. If block_globalopt's initializer reads from any of these variables, it's unspecified what value it gets, but it's not actually UB. According to [class.cdtor], it's UB if the variable is "an object with a non-trivial constructor", but I think that has to be read as limited to class types at a minimum.

You're right that we're supposed to be able to emit the g variables in your example with constant initialization, although you have to check very specific conditions (no modifications of other variables, restricted dependencies on other variables' values) before you can.

Right now, to provide the order guarantee, we lump all the non-comdat initializers into a _GLOBAL__sub_I_ function. As a consequence, globalopt is all or nothing: either everything can be optimized, or nothing can be. In this example, because it can't see through bar, it won't fire.

Maybe we should consider giving a stronger guarantee for the order in which global_ctors entries run, so that clang can instead emit these all separately.

That could be useful.

llvm/lib/Transforms/Utils/CtorUtils.cpp

116

Right. I feel that this is a language-specific optimization that needs language-specific permission to enable.

llvm/include/llvm/Transforms/Utils/CtorUtils.h

 namespace llvm {
 
 class GlobalVariable;
 class Function;
 class Module;
 
 /// Call "ShouldRemove" for every entry in M's global_ctor list and remove the
 /// entries for which it returns true.  Return true if anything changed.
-bool optimizeGlobalCtorsList(Module &M,
-                             function_ref<bool(Function *)> ShouldRemove);
+bool optimizeGlobalCtorsList(
+    Module &M, function_ref<bool(Function *, GlobalVariable *GV)> ShouldRemove);
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Transforms/Utils/Evaluator.h

 class TargetLibraryInfo;
 
 /// This class evaluates LLVM IR, producing the Constant representing each SSA
 /// instruction.  Changes to global variables are stored in a mapping that can
 /// be iterated over after the evaluation is complete.  Once an evaluation call
 /// fails, the evaluation object should not be reused.
 class Evaluator {
 public:
-  Evaluator(const DataLayout &DL, const TargetLibraryInfo *TLI)
-      : DL(DL), TLI(TLI) {
+  Evaluator(const DataLayout &DL, const TargetLibraryInfo *TLI,
+            GlobalVariable *ComdatGV = nullptr)
+      : DL(DL), TLI(TLI), ComdatGV(ComdatGV) {
     ValueStack.emplace_back();
   }
 
   ~Evaluator() {
     for (auto &Tmp : AllocaTmps)
       // If there are still users of the alloca, the program is doing something
       // silly, e.g. storing the address of the alloca somewhere and using it
       // later.  Since this is undefined, we'll just make it be null.
private:
   SmallPtrSet<GlobalVariable*, 8> Invariants;
 
   /// These are constants we have checked and know to be simple enough to live
   /// in a static initializer of a global.
   SmallPtrSet<Constant*, 8> SimpleConstants;
 
   const DataLayout &DL;
   const TargetLibraryInfo *TLI;
+
+  /// If non-null, the function being evaluated is in the comdat group of this
+  /// global. Typically, that means it is the code to dynamically initailize it.
+  /// We can update the value of this global even if it has vague
+  /// (linkonce/weak/odr) linkage.
+  GlobalVariable *ComdatGV;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_EVALUATOR_H

llvm/lib/Transforms/IPO/GlobalDCE.cpp

 INITIALIZE_PASS(GlobalDCELegacyPass, "globaldce",
                 "Dead Global Elimination", false, false)
 
 // Public interface to the GlobalDCEPass.
 ModulePass *llvm::createGlobalDCEPass() {
   return new GlobalDCELegacyPass();
 }
 
-/// Returns true if F is effectively empty.
-static bool isEmptyFunction(Function *F) {
+/// Returns true if F is effectively empty. Even if this is an initializer for
+/// some comdat global variable, we can eliminate it.
+static bool isEmptyFunction(Function *F, GlobalVariable *GV) {
   BasicBlock &Entry = F->getEntryBlock();
   for (auto &I : Entry) {
     if (isa<DbgInfoIntrinsic>(I))
       continue;
     if (auto *RI = dyn_cast<ReturnInst>(&I))
       return !RI->getReturnValue();
     break;
   }

llvm/lib/Transforms/IPO/GlobalOpt.cpp

static void BatchCommitValueTo(const DenseMap<Constant*, Constant*> &Mem) {
   }
   // The last initializer in the list needs to be committed, others
   // will be committed on a new initializer being processed.
   commitAndSetupCache(CurrentGV, true);
 }
 
 /// Evaluate static constructors in the function, if we can.  Return true if we
 /// can, false otherwise.
-static bool EvaluateStaticConstructor(Function *F, const DataLayout &DL,
+static bool EvaluateStaticConstructor(Function *F, GlobalVariable *ComdatGV,
+                                      const DataLayout &DL,
                                       TargetLibraryInfo *TLI) {
   // Call the function.
-  Evaluator Eval(DL, TLI);
+  Evaluator Eval(DL, TLI, ComdatGV);
   Constant *RetValDummy;
   bool EvalSuccess = Eval.EvaluateFunction(F, RetValDummy,
                                            SmallVector<Constant*, 0>());
 
   if (EvalSuccess) {
     ++NumCtorsEvaluated;
 
     // We succeeded at evaluation: commit the result.
for (GlobalAlias &GA : M.aliases())
         if (!GA.isDiscardableIfUnused() || !GA.use_empty())
           NotDiscardableComdats.insert(C);
 
     // Delete functions that are trivially dead, ccc -> fastcc
     LocalChange |= OptimizeFunctions(M, TLI, GetTTI, GetBFI, LookupDomTree,
                                      NotDiscardableComdats);
 
     // Optimize global_ctors list.
-    LocalChange |= optimizeGlobalCtorsList(M, [&](Function *F) {
-      return EvaluateStaticConstructor(F, DL, TLI);
+    LocalChange |=
+        optimizeGlobalCtorsList(M, [&](Function *F, GlobalVariable *GV) {
+          return EvaluateStaticConstructor(F, GV, DL, TLI);
         });
 
     // Optimize non-address-taken globals.
     LocalChange |= OptimizeGlobalVars(M, TLI, LookupDomTree,
                                       NotDiscardableComdats);
 
     // Resolve aliases, when possible.
     LocalChange |= OptimizeGlobalAliases(M, NotDiscardableComdats);
 

llvm/lib/Transforms/Utils/CtorUtils.cpp

 //===- CtorUtils.cpp - Helpers for working with global_ctors ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines functions that are used to process llvm.global_ctors.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/CtorUtils.h"
 #include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "ctor_utils"
if (!GCL->use_empty()) {
     Constant *V = NGV;
     if (V->getType() != GCL->getType())
       V = ConstantExpr::getBitCast(V, GCL->getType());
     GCL->replaceAllUsesWith(V);
   }
   GCL->eraseFromParent();
 }
 
-/// Given a llvm.global_ctors list that we can understand,
-/// return a list of the functions and null terminator as a vector.
-static std::vector<Function *> parseGlobalCtors(GlobalVariable *GV) {
-  if (GV->getInitializer()->isNullValue())
-    return std::vector<Function *>();
-  ConstantArray *CA = cast<ConstantArray>(GV->getInitializer());
-  std::vector<Function *> Result;
-  Result.reserve(CA->getNumOperands());
-  for (auto &V : CA->operands()) {
-    ConstantStruct *CS = cast<ConstantStruct>(V);
-    Result.push_back(dyn_cast<Function>(CS->getOperand(1)));
-  }
-  return Result;
-}
-
 /// Find the llvm.global_ctors list, verifying that all initializers have an
 /// init priority of 65535.
 static GlobalVariable *findGlobalCtors(Module &M) {
   GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors");
   if (!GV)
     return nullptr;
 
   // Verify that the initializer is simple enough for us to handle. We are
static GlobalVariable *findGlobalCtors(Module &M) {
   }
 
   return GV;
 }
 
 /// Call "ShouldRemove" for every entry in M's global_ctor list and remove the
 /// entries for which it returns true.  Return true if anything changed.
 bool llvm::optimizeGlobalCtorsList(
-    Module &M, function_ref<bool(Function *)> ShouldRemove) {
+    Module &M, function_ref<bool(Function *, GlobalVariable *)> ShouldRemove) {
   GlobalVariable *GlobalCtors = findGlobalCtors(M);
   if (!GlobalCtors)
     return false;
 
-  std::vector<Function *> Ctors = parseGlobalCtors(GlobalCtors);
-  if (Ctors.empty())
-    return false;
+  // Check if we can assume that all initializers across the program for a vague
+  // linkage global will be in the comdat group of the global. This allows us to
+  // optimize dynamic initializers of globals with vague linkage, because we
+  // know that if the global in the current TU prevails, no other initializers
+  // will run, preventing double initialization. The Microsoft C++ ABI provides
+  // this guarantee.
+  bool AssumeComdatInitializers =
+      Triple(M.getTargetTriple()).isWindowsMSVCEnvironment();
+
+  ConstantArray *Ctors = cast<ConstantArray>(GlobalCtors->getInitializer());
 
   bool MadeChange = false;
 
   // Loop over global ctors, optimizing them when we can.
-  unsigned NumCtors = Ctors.size();
+  unsigned NumCtors = Ctors->getNumOperands();
   BitVector CtorsToRemove(NumCtors);
-  for (unsigned i = 0; i != Ctors.size() && NumCtors > 0; ++i) {
-    Function *F = Ctors[i];
-    // Found a null terminator in the middle of the list, prune off the rest of
-    // the list.
-    if (!F)
+  for (unsigned i = 0; i != NumCtors; ++i) {
+    ConstantStruct *CS = cast<ConstantStruct>(Ctors->getOperand(i));
+    Function *F = dyn_cast<Function>(CS->getOperand(1));
+
+    // If we can assume that initializers are always in the global's comdat
+    // group, then we can modify the global being initialized. Pass the global
+    // down to the evaluator so it knows it can be modified.
+    GlobalVariable *GV = nullptr;
+    if (AssumeComdatInitializers)
+      GV = dyn_cast<GlobalVariable>(CS->getOperand(2)->stripPointerCasts());
+
+    // Ignore null initializers and external functions.
+    if (!F || F->empty())
       continue;
 
     LLVM_DEBUG(dbgs() << "Optimizing Global Constructor: " << *F << "\n");
 
-    // We cannot simplify external ctor functions.
-    if (F->empty())
-      continue;
-
     // If we can evaluate the ctor at compile time, do.
-    if (ShouldRemove(F)) {
-      Ctors[i] = nullptr;
+    if (ShouldRemove(F, GV)) {
       CtorsToRemove.set(i);
-      NumCtors--;
       MadeChange = true;
       continue;
     }
   }
 
   if (!MadeChange)
     return false;
 
   removeGlobalCtors(GlobalCtors, CtorsToRemove);
   return true;
 }

llvm/lib/Transforms/Utils/Evaluator.cpp

isSimpleEnoughValueToCommit(Constant *C,
                             const DataLayout &DL) {
   // If we already checked this constant, we win.
   if (!SimpleConstants.insert(C).second)
     return true;
   // Check the constant.
   return isSimpleEnoughValueToCommitHelper(C, SimpleConstants, DL);
 }
 
+/// Check if this is a global we can update. The global can be updated if it has
+/// a unique initializer (i.e. internal or strong external) or if the
+/// initializer we are evaluating is in the same comdat group as the global.
+static bool canUpdateGlobal(GlobalVariable *GV, GlobalVariable *ComdatGV) {
+  return GV == ComdatGV || GV->hasUniqueInitializer();
+}
+
 /// Return true if this constant is simple enough for us to understand.  In
 /// particular, if it is a cast to anything other than from one pointer type to
 /// another pointer type, we punt.  We basically just support direct accesses to
 /// globals and GEP's of globals.  This should be kept up to date with
 /// CommitValueTo.
-static bool isSimpleEnoughPointerToCommit(Constant *C) {
+static bool isSimpleEnoughPointerToCommit(Constant *C,
+                                          GlobalVariable *ComdatGV) {
   // Conservatively, avoid aggregate types. This is because we don't
   // want to worry about them partially overlapping other stores.
   if (!cast<PointerType>(C->getType())->getElementType()->isSingleValueType())
     return false;
 
-  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
-    // Do not allow weak/*_odr/linkonce linkage or external globals.
-    return GV->hasUniqueInitializer();
+  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
+    return canUpdateGlobal(GV, ComdatGV);
+  }
 
   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
     // Handle a constantexpr gep.
     if (CE->getOpcode() == Instruction::GetElementPtr &&
         isa<GlobalVariable>(CE->getOperand(0)) &&
         cast<GEPOperator>(CE)->isInBounds()) {
       GlobalVariable *GV = cast<GlobalVariable>(CE->getOperand(0));
-      // Do not allow weak/*_odr/linkonce/dllimport/dllexport linkage or
-      // external globals.
-      if (!GV->hasUniqueInitializer())
+      if (!canUpdateGlobal(GV, ComdatGV))
         return false;
 
       // The first index must be zero.
       ConstantInt *CI = dyn_cast<ConstantInt>(*std::next(CE->op_begin()));
       if (!CI || !CI->isZero()) return false;
 
       // The remaining indices must be compile-time known integers within the
       // notional bounds of the corresponding static array types.
       if (!CE->isGEPWithNoNotionalOverIndexing())
         return false;
 
       return ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE);
 
     // A constantexpr bitcast from a pointer to another pointer is a no-op,
     // and we know how to evaluate it by moving the bitcast from the pointer
     // operand to the value operand.
     } else if (CE->getOpcode() == Instruction::BitCast &&
                isa<GlobalVariable>(CE->getOperand(0))) {
-      // Do not allow weak/*_odr/linkonce/dllimport/dllexport linkage or
-      // external globals.
-      return cast<GlobalVariable>(CE->getOperand(0))->hasUniqueInitializer();
+      return canUpdateGlobal(cast<GlobalVariable>(CE->getOperand(0)), ComdatGV);
     }
   }
 
   return false;
 }
 
 static Constant *getInitializer(Constant *C) {
   auto *GV = dyn_cast<GlobalVariable>(C);
if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
         return false;  // no volatile/atomic accesses.
       }
       Constant *Ptr = getVal(SI->getOperand(1));
       if (auto *FoldedPtr = ConstantFoldConstant(Ptr, DL, TLI)) {
         LLVM_DEBUG(dbgs() << "Folding constant ptr expression: " << *Ptr);
         Ptr = FoldedPtr;
         LLVM_DEBUG(dbgs() << "; To: " << *Ptr << "\n");
       }
-      if (!isSimpleEnoughPointerToCommit(Ptr)) {
+      if (!isSimpleEnoughPointerToCommit(Ptr, ComdatGV)) {
         // If this is too complex for us to commit, reject it.
         LLVM_DEBUG(
             dbgs() << "Pointer is too complex for us to evaluate store.");
         return false;
       }
 
       Constant *Val = getVal(SI->getOperand(0));
 

llvm/test/Transforms/GlobalOpt/comdat-global.ll

+; RUN: opt -globalopt -S < %s | FileCheck %s
+
+target triple = "x86_64-pc-windows-msvc19.14.26433"
+
+$basic = comdat any
+$basic_init = comdat any
+
+$cross = comdat any
+$cross_init = comdat any
+
+$intern = comdat any
+$intern_init = comdat any
+
+$struct = comdat any
+$struct_init = comdat any
+
+@basic = weak_odr global i8 0, comdat
+; CHECK: @basic = weak_odr local_unnamed_addr global i8 42, comdat
+
+@cross = weak_odr global i8 0, comdat
+; CHECK: @cross = weak_odr global i8 0, comdat
+
+@intern = weak_odr global i8 0, comdat
+@intern_other_internal = internal global i8 0
+; CHECK: @intern = weak_odr local_unnamed_addr global i8 42, comdat
+; CHECK: @intern_other_internal = internal global i8 13
+
+@struct = weak_odr global { i8, i8 } zeroinitializer, comdat
+; CHECK: @struct = weak_odr local_unnamed_addr global { i8, i8 } { i8 13, i8 42 }, comdat
+
[e-mail]_ctors = appending global [4 x { i32, void ()*, i8* }] [
+    { i32, void ()*, i8* } { i32 65535, void ()* @basic_init, i8* @basic },
+    { i32, void ()*, i8* } { i32 65535, void ()* @cross_init, i8* @cross },
+    { i32, void ()*, i8* } { i32 65535, void ()* @intern_init, i8* @intern },
+    { i32, void ()*, i8* } { i32 65535, void ()* @struct_init, i8* bitcast ({ i8, i8 }* @struct to i8*) }
+]
+
[e-mail] = appending global [1 x i8*] [ i8* @intern_other_internal ]
+
+; CHECK: @llvm.global_ctors = appending global [{{[0-9]*}} x { i32, void ()*, i8* }] [
+; CHECK-SAME:   { i32 65535, void ()* @cross_init, i8* @cross }
+; CHECK-SAME: ]
+
+; GlobalOpt should fire for this.
+define linkonce_odr void @basic_init() comdat {
+  store i8 42, i8* @basic
+  ret void
+}
+; CHECK-NOT: define {{.*}}@basic_init()
+
+; GlobalOpt should not fire, it can't store to a separate weak_odr global.
+define linkonce_odr void @cross_init() comdat {
+  store i8 13, i8* @basic
+  store i8 42, i8* @cross
+  ret void
+}
+; CHECK: define {{.*}}@cross_init()
+
+; We can store to two globals if one is internal (hasUniqueInitializer).
+define linkonce_odr void @intern_init() comdat {
+  store i8 13, i8* @intern_other_internal
+  store i8 42, i8* @intern
+  ret void
+}
+; CHECK-NOT: define {{.*}}@intern_init()
+
+
+; GlobalOpt works on structs, which are the common case for C++ initializers.
+define linkonce_odr void @struct_init() comdat {
+  store i8 13, i8* getelementptr ({ i8, i8 }, { i8, i8 }* @struct, i32 0, i32 0)
+  store i8 42, i8* getelementptr ({ i8, i8 }, { i8, i8 }* @struct, i32 0, i32 1)
+  ret void
+}
+; CHECK-NOT: define {{.*}}@struct_init()
+
+

llvm/test/Transforms/GlobalOpt/preserve-comdats.ll

 ; RUN: opt -globalopt -S < %s | FileCheck %s
 
 $comdat_global = comdat any
 
 @comdat_global = weak_odr global i8 0, comdat($comdat_global)
 @simple_global = internal global i8 0
 ; CHECK: @comdat_global = weak_odr global i8 0, comdat{{$}}
 ; CHECK: @simple_global = internal global i8 42
 
 @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [
     { i32, void ()*, i8* } { i32 65535, void ()* @init_comdat_global, i8* @comdat_global },
     { i32, void ()*, i8* } { i32 65535, void ()* @init_simple_global, i8* null }
 ]
 ; CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }]
 ; CHECK: [{ i32, void ()*, i8* } { i32 65535, void ()* @init_comdat_global, i8* @comdat_global }]
 
+declare void @do_not_optimize()
+
 define void @init_comdat_global() {
+  call void @do_not_optimize()
   store i8 42, i8* @comdat_global
   ret void
 }
 ; CHECK: define void @init_comdat_global()
 
 define internal void @init_simple_global() comdat($comdat_global) {
   store i8 42, i8* @simple_global
   ret void