[ModuleUtils] Assert correct linkage and visibility of structors' COMDAT key

[melver]

Summary

Currently structors of various sanitizers have internal linkage, even
with a COMDAT set. This means that semantics is not the same with LTO,
because LTO uses linkage to deduplicate and not the COMDAT. The result
is that a target built with LTO currently has numerous duplicate
redundant constructors and destructors generated by the sanitizers.

This can be fixed by marking the structor as having external linkage.
However, care must be taken to also set hidden visibility, otherwise a
DSO may not call its own structor but another, which is usually wrong.

To allow the caller full flexibility over precise linkage and
visibility, we can't just set it for the caller.

Add an assertion that checks the various rules.

Along the way, we now have to fix up ASan, HWASan, and SanCov to emit
the right linkage.

See also: https://maskray.me/blog/2021-07-25-comdat-and-section-group#grp_comdat

[melver]

This is currently more an RFC - there might be other side-effects not yet accounted for, so please review carefully.

Although I have been able to reproduce the issue with an LTO and ASan build quite easily. If this is a common usecase for us, we might potentially save a good amount of .text size because of the 1000s of redundant structors.

[pcc]

I've always considered that this should be fixed by extending the resolution-based LTO API to also include resolutions for comdats.

clang/test/CodeGen/asan-destructor-kind.cpp

 
 int global;
 
 int main() {
   return global;
 }
 
 // CHECK-NONE-DTOR-NOT: llvm.global_dtor{{.+}}asan.module_dtor
-// CHECK-NONE-DTOR-NOT: define internal void @asan.module_dtor
+// CHECK-NONE-DTOR-NOT: define{{.*}}void @asan.module_dtor

clang/test/CodeGen/asan-no-globals-no-comdat.cpp

 // Test that on Linux asan constructor is placed in a comdat iff globals-gc is on.
 // Even if there are no globals in the module.
 
 // RUN: %clang_cc1 -fsanitize=address -fsanitize-address-globals-dead-stripping -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefix=WITH-GC
 // RUN: %clang_cc1 -fsanitize=address -fsanitize-address-globals-dead-stripping -fno-integrated-as -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefix=WITHOUT-GC
 // RUN: %clang_cc1 -fsanitize=address -fdata-sections -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefix=WITHOUT-GC
 
-// WITH-GC: define internal void @asan.module_ctor() #[[#]] comdat {
+// WITH-GC: define hidden void @asan.module_ctor() #[[#]] comdat {
 // WITHOUT-GC: define internal void @asan.module_ctor() #[[#]] {

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

bool ModuleAddressSanitizer::instrumentModule(Module &M) {
   const uint64_t Priority = GetCtorAndDtorPriority(TargetTriple);
 
   // Put the constructor and destructor in comdat if both
   // (1) global instrumentation is not TU-specific
   // (2) target is ELF.
   if (UseCtorComdat && TargetTriple.isOSBinFormatELF() && CtorComdat) {
     if (AsanCtorFunction) {
       AsanCtorFunction->setComdat(M.getOrInsertComdat(kAsanModuleCtorName));
+      AsanCtorFunction->setLinkage(GlobalValue::ExternalLinkage);
+      AsanCtorFunction->setVisibility(GlobalValue::HiddenVisibility);
       appendToGlobalCtors(M, AsanCtorFunction, Priority, AsanCtorFunction);
     }
     if (AsanDtorFunction) {
       AsanDtorFunction->setComdat(M.getOrInsertComdat(kAsanModuleDtorName));
+      AsanDtorFunction->setLinkage(GlobalValue::ExternalLinkage);
+      AsanDtorFunction->setVisibility(GlobalValue::HiddenVisibility);
       appendToGlobalDtors(M, AsanDtorFunction, Priority, AsanDtorFunction);
     }
   } else {
     if (AsanCtorFunction)
       appendToGlobalCtors(M, AsanCtorFunction, Priority);
     if (AsanDtorFunction)
       appendToGlobalDtors(M, AsanDtorFunction, Priority);
   }

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

std::tie(HwasanCtorFunction, std::ignore) =
           M, kHwasanModuleCtorName, kHwasanInitName,
           /*InitArgTypes=*/{},
           /*InitArgs=*/{},
           // This callback is invoked when the functions are created the first
           // time. Hook them into the global ctors list in that case:
           [&](Function *Ctor, FunctionCallee) {
             Comdat *CtorComdat = M.getOrInsertComdat(kHwasanModuleCtorName);
             Ctor->setComdat(CtorComdat);
+            Ctor->setLinkage(GlobalValue::ExternalLinkage);
+            Ctor->setVisibility(GlobalValue::HiddenVisibility);
             appendToGlobalCtors(M, Ctor, 0, Ctor);
           });
 
   // Create a note that contains pointers to the list of global
   // descriptors. Adding a note to the output file will cause the linker to
   // create a PT_NOTE program header pointing to the note that we can use to
   // find the descriptor list starting from the program headers. A function
   // provided by the runtime initializes the shadow memory for the globals by

llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp

Function *ModuleSanitizerCoverage::CreateInitCallsForSections(
   Type *PtrTy = PointerType::getUnqual(Ty);
   std::tie(CtorFunc, std::ignore) = createSanitizerCtorAndInitFunctions(
       M, CtorName, InitFunctionName, {PtrTy, PtrTy}, {SecStart, SecEnd});
   assert(CtorFunc->getName() == CtorName);
 
   if (TargetTriple.supportsCOMDAT()) {
     // Use comdat to dedup CtorFunc.
     CtorFunc->setComdat(M.getOrInsertComdat(CtorName));
+    CtorFunc->setLinkage(GlobalValue::ExternalLinkage);
+    CtorFunc->setVisibility(GlobalValue::HiddenVisibility);
     appendToGlobalCtors(M, CtorFunc, SanCtorAndDtorPriority, CtorFunc);
   } else {
     appendToGlobalCtors(M, CtorFunc, SanCtorAndDtorPriority);
   }
 
   if (TargetTriple.isOSBinFormatCOFF()) {
     // In COFF files, if the contructors are set as COMDAT (they are because
     // COFF supports COMDAT) and the linker flag /OPT:REF (strip unreferenced

llvm/lib/Transforms/Utils/ModuleUtils.cpp

 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/xxhash.h"
+#include "llvm/TargetParser/Triple.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "moduleutils"
 
-static void appendToGlobalArray(StringRef ArrayName, Module &M, Function *F,
+static void appendToGlobalStructors(StringRef ArrayName, Module &M, Function *F,
                                     int Priority, Constant *Data) {
   IRBuilder<> IRB(M.getContext());
   FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
 
-  // Get the current set of static global constructors and add the new ctor
+  // Get the current set of static global structors and add the new ctor
   // to the list.
   SmallVector<Constant *, 16> CurrentCtors;
   StructType *EltTy = StructType::get(
       IRB.getInt32Ty(), PointerType::get(FnTy, F->getAddressSpace()),
       IRB.getInt8PtrTy());
 
   if (GlobalVariable *GVCtor = M.getNamedGlobal(ArrayName)) {
-    if (Constant *Init = GVCtor->getInitializer()) {
-      unsigned n = Init->getNumOperands();
-      CurrentCtors.reserve(n + 1);
-      for (unsigned i = 0; i != n; ++i)
-        CurrentCtors.push_back(cast<Constant>(Init->getOperand(i)));
+    if (const Constant *Init = GVCtor->getInitializer()) {
+      CurrentCtors.reserve(Init->getNumOperands() + 1);
+      for (Value *Val : Init->operands())
+        CurrentCtors.push_back(cast<Constant>(Val));
     }
     GVCtor->eraseFromParent();
   }
 
-  // Build a 3 field global_ctor entry.  We don't take a comdat key.
-  Constant *CSVals[3];
-  CSVals[0] = IRB.getInt32(Priority);
-  CSVals[1] = F;
-  CSVals[2] = Data ? ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy())
-                   : Constant::getNullValue(IRB.getInt8PtrTy());
-  Constant *RuntimeCtorInit =
-      ConstantStruct::get(EltTy, ArrayRef(CSVals, EltTy->getNumElements()));
+  Constant *LinkedTo;
+  if (Data) {
+    // Structor will only run if Data is not discarded.
+    LinkedTo = ConstantExpr::getPointerCast(Data, IRB.getInt8PtrTy());
+
+    // Verify that on targets that support COMDAT and where Data has a COMDAT,
+    // Data has non-internal linkage, otherwise we're in for surprises with LTO:
+    // when multiple TUs are merged, LTO would use linkage to deduplicate. If
+    // linkage is set to internal linkage, we would end up with multiple
+    // identical symbols in the final binary (which without LTO, the linker
+    // would take care of due to the COMDAT, irrespective of linkage). Also
+    // verify that if linkage is external, visibility is hidden, so that DSOs
+    // don't call any other structor.
+    //
+    // We verify this here, rather than in the Verifier, since none of this is
+    // invalid, but for all users of appendToGlobalStructors() this should hold.
+    assert([&] {
+      Triple T(M.getTargetTriple());
+      if (!T.supportsCOMDAT())
+        return true;
+      if (const auto *Key = dyn_cast<GlobalValue>(Data)) {
+        if (!Key->hasComdat())
+          return true; // Nothing to check.
+        if (Key->getLinkage() == GlobalValue::ExternalLinkage) {
+          // Even with external linkage, a DSO should _not_ call any other
+          // structor but its own (which it has either way).
+          return Key->getVisibility() != GlobalValue::DefaultVisibility;
+        }
+        // Assert not internal linkage.
+        return Key->getLinkage() != GlobalValue::InternalLinkage &&
+               Key->getLinkage() != GlobalValue::PrivateLinkage;
+      }
+      return true;
+    }() && "GlobalValue used as COMDAT key for structor has incorrect linkage");
+  } else {
+    LinkedTo = Constant::getNullValue(IRB.getInt8PtrTy());
+  }
 
-  CurrentCtors.push_back(RuntimeCtorInit);
+  // Build a 3 field global_{c,d}tor entry.
+  const std::array<Constant *, 3> CSVals = {IRB.getInt32(Priority), F,
+                                            LinkedTo};
+  assert(CSVals.size() == EltTy->getNumElements());
+  CurrentCtors.push_back(ConstantStruct::get(EltTy, CSVals));
 
   // Create a new initializer.
   ArrayType *AT = ArrayType::get(EltTy, CurrentCtors.size());
   Constant *NewInit = ConstantArray::get(AT, CurrentCtors);
 
   // Create the new global variable and replace all uses of
   // the old global variable with the new one.
   (void)new GlobalVariable(M, NewInit->getType(), false,
                            GlobalValue::AppendingLinkage, NewInit, ArrayName);
 }
 
 void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) {
-  appendToGlobalArray("llvm.global_ctors", M, F, Priority, Data);
+  appendToGlobalStructors("llvm.global_ctors", M, F, Priority, Data);
 }
 
 void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) {
-  appendToGlobalArray("llvm.global_dtors", M, F, Priority, Data);
+  appendToGlobalStructors("llvm.global_dtors", M, F, Priority, Data);
 }
 
 static void collectUsedGlobals(GlobalVariable *GV,
                                SmallSetVector<Constant *, 16> &Init) {
   if (!GV || !GV->hasInitializer())
     return;
 
   auto *CA = cast<ConstantArray>(GV->getInitializer());

llvm/test/CodeGen/AArch64/pacbti-llvm-generated-funcs-1.ll

 ;; RUN: llc %s -o -| FileCheck %s
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux"
 
 @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @asan.module_ctor, ptr null }]
 
 define dso_local i32 @f() #0 {
 entry:
   ret i32 0
 }
 ;; CHECK-LABEL: f:
 ;; CHECK: hint #34
 
 declare void @__asan_init()
 declare void @__asan_version_mismatch_check_v8()
 
-define internal void @asan.module_ctor() {
+define hidden void @asan.module_ctor() {
   call void @__asan_init()
   call void @__asan_version_mismatch_check_v8()
   ret void
 }
 ;; CHECK-LABEL: asan.module_ctor:
 ;; CHECK: hint #34
 
 attributes #0 = { noinline nounwind optnone sanitize_address uwtable "branch-target-enforcement"="true" }
 
 !llvm.module.flags = !{!0, !1, !2, !3, !4}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{i32 4, !"branch-target-enforcement", i32 1}
 !2 = !{i32 4, !"sign-return-address", i32 0}
 !3 = !{i32 4, !"sign-return-address-all", i32 0}
 !4 = !{i32 4, !"sign-return-address-with-bkey", i32 0}
 No newline at end of file

llvm/test/DebugInfo/AArch64/asan-stack-vars.mir

--- |
   declare i8* @objc_msgSend(i8*, i8*, ...) #2
 
   declare i8* @objc_retainAutoreleasedReturnValue(i8* returned)
 
   declare void @objc_storeStrong(i8**, i8*)
 
   declare i8* @objc_autoreleaseReturnValue(i8* returned)
 
-  define internal void @asan.module_ctor() {
+  define hidden void @asan.module_ctor() {
     call void @__asan_init()
     call void @__asan_version_mismatch_check_v8()
     ret void
   }
 
   declare void @__asan_init()
 
   declare void @__asan_version_mismatch_check_v8()

llvm/test/DebugInfo/COFF/asan-module-ctor.ll

 @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @asan.module_ctor, ptr null }]
 
 ; Function Attrs: nounwind sanitize_address
 define i32 @foo() #0 !dbg !4 {
 entry:
   ret i32 0, !dbg !10
 }
 
-define internal void @asan.module_ctor() {
+define hidden void @asan.module_ctor() {
   call void @__asan_init_v3()
   ret void
 }
 
 declare void @__asan_init_v3()
 
 declare void @__asan_report_load1(i32)
 

llvm/test/DebugInfo/COFF/asan-module-without-functions.ll

 
 @c = global { i8, [63 x i8] } { i8 42, [63 x i8] zeroinitializer }, align 32
 @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @asan.module_ctor, ptr null }]
 @___asan_gen_ = private constant [7 x i8] c"asan.c\00", align 1
 @___asan_gen_1 = private unnamed_addr constant [2 x i8] c"c\00", align 1
 @0 = internal global [1 x { i32, i32, i32, i32, i32, i32 }] [{ i32, i32, i32, i32, i32, i32 } { i32 ptrtoint (ptr @c to i32), i32 1, i32 64, i32 ptrtoint (ptr @___asan_gen_1 to i32), i32 ptrtoint (ptr @___asan_gen_ to i32), i32 0 }]
 @llvm.global_dtors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @asan.module_dtor, ptr null }]
 
-define internal void @asan.module_ctor() {
+define hidden void @asan.module_ctor() {
   call void @__asan_init_v3()
   call void @__asan_register_globals(i32 ptrtoint (ptr @0 to i32), i32 1)
   ret void
 }
 
 declare void @__asan_init_v3()
 
 declare void @__asan_before_dynamic_init(i32)
 
 declare void @__asan_after_dynamic_init()
 
 declare void @__asan_register_globals(i32, i32)
 
 declare void @__asan_unregister_globals(i32, i32)
 
-define internal void @asan.module_dtor() {
+define hidden void @asan.module_dtor() {
   call void @__asan_unregister_globals(i32 ptrtoint (ptr @0 to i32), i32 1)
   ret void
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 !llvm.ident = !{!5}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: LineTablesOnly, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2)
 !1 = !DIFile(filename: "asan.c", directory: "D:\5C")
 !2 = !{}
 !3 = !{i32 2, !"CodeView", i32 1}
 !4 = !{i32 1, !"Debug Info Version", i32 3}
 !5 = !{!"clang version 3.5.0 "}

llvm/test/DebugInfo/Generic/incorrect-variable-debugloc.ll

; <label>:42                                      ; preds = %39, %32
   ret void, !dbg !52
 }
 
 declare i32 @_ZN1A5m_fn1Ev(ptr) #2
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) #3
 
-define internal void @asan.module_ctor() {
+define hidden void @asan.module_ctor() {
   tail call void @__asan_init_v3()
   ret void
 }
 
 declare void @__asan_init_v3()
 
 declare void @__asan_report_load1(i64)
 

llvm/test/DebugInfo/X86/dbg_value_direct.ll

; <label>:28                                      ; preds = %22, %entry
   ret void, !dbg !26
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 declare void @_ZN1AC1Ev(ptr) #2
 
-define internal void @asan.module_ctor()  "stack-protector-buffer-size"="1" {
+define hidden void @asan.module_ctor()  "stack-protector-buffer-size"="1" {
   call void @__asan_init_v3()
   %1 = load volatile i64, ptr @__asan_mapping_offset
   %2 = load volatile i64, ptr @__asan_mapping_scale
   ret void
 }
 
 declare void @__asan_init_v3()
 

llvm/test/Instrumentation/AddressSanitizer/AMDGPU/asan_do_not_instrument_lds.ll

 entry:
   ; CHECK-LABEL: @lds_load(
   ; CHECK-NOT: call {{[a-zA-Z]}}
   %arrayidx1 = getelementptr inbounds [100 x i32], ptr addrspace(3) @count, i32 0, i32 %i
   %0 = load i32, ptr addrspace(3) %arrayidx1, align 4
   ret void
 }
 
-; CHECK-LABEL: define internal void @asan.module_ctor()
+; CHECK-LABEL: define hidden void @asan.module_ctor()

llvm/test/Instrumentation/AddressSanitizer/basic.ll

define void @test_swifterror_3() sanitize_address {
   %swifterror_addr = alloca swifterror ptr
   store ptr null, ptr %swifterror_addr
   call void @test_swifterror_2(ptr swifterror %swifterror_addr)
   ret void
 }
 
 ;; ctor/dtor have the nounwind attribute. See uwtable.ll, they additionally have
 ;; the uwtable attribute with the module flag "uwtable".
-; CHECK: define internal void @asan.module_ctor() #[[#ATTR:]] {{(comdat )?}}{
+; CHECK: define hidden void @asan.module_ctor() #[[#ATTR:]] {{(comdat )?}}{
 ; CHECK: call void @__asan_init()
 
 ; CHECK: attributes #[[#ATTR]] = { nounwind }
 
 ; PROF
 ; CHECK: ![[PROF]] = !{!"branch_weights", i32 1, i32 100000}

llvm/test/Instrumentation/AddressSanitizer/instrument_global.ll

 entry:
     %0 = load i32, ptr getelementptr inbounds ([10 x i32], ptr @GlobEx, i64 0, i64 2), align 8
     ret i32 %0
 ; CHECK-LABEL: define i32 @AccessGlobEx_0_2
 ; CHECK: __asan_report
 ; CHECK: ret i32
 }
 
-; CHECK-LABEL: define internal void @asan.module_ctor
+; CHECK-LABEL: define hidden void @asan.module_ctor
 ; CHECK-NOT: ret
 ; CHECK: call void @__asan_register_elf_globals
 ; CHECK: ret
 
-; CHECK-LABEL: define internal void @asan.module_dtor
+; CHECK-LABEL: define hidden void @asan.module_dtor
 ; CHECK-NOT: ret
 ; CHECK: call void @__asan_unregister_elf_globals
 ; CHECK: ret

llvm/test/Instrumentation/AddressSanitizer/kcfi-offset.ll

 ;; Test that we set patchable-function-prefix for asan.module_ctor when kcfi-offset is defined.
 
 ; RUN: opt < %s -passes=asan -S | FileCheck %s
 
 ; CHECK: @llvm.global_ctors = {{.*}}{ i32 1, ptr @asan.module_ctor, ptr @asan.module_ctor }
 
-; CHECK: define internal void @asan.module_ctor()
+; CHECK: define hidden void @asan.module_ctor()
 ; CHECK-SAME: #[[#ATTR:]]
 ; CHECK-SAME: !kcfi_type
 
 ; CHECK: attributes #[[#ATTR]] = { {{.*}} "patchable-function-prefix"="3" }
 
 !llvm.module.flags = !{!0, !1}
 !0 = !{i32 4, !"kcfi", i32 1}
 !1 = !{i32 4, !"kcfi-offset", i32 3}

llvm/test/Instrumentation/AddressSanitizer/kcfi.ll

 ;; Test that we emit kcfi_type metadata for asan.module_ctor with KCFI.
 
 ; RUN: opt < %s -passes=asan -S | FileCheck %s
 
 ; CHECK: @llvm.global_ctors = {{.*}}{ i32 1, ptr @asan.module_ctor, ptr @asan.module_ctor }
 
-; CHECK: define internal void @asan.module_ctor()
+; CHECK: define hidden void @asan.module_ctor()
 ; CHECK-SAME: !kcfi_type
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 4, !"kcfi", i32 1}

llvm/test/Instrumentation/AddressSanitizer/module-flags.ll

 
 ;; Due to -fasynchronous-unwind-tables.
 !0 = !{i32 7, !"uwtable", i32 2}
 
 ;; Due to -fno-omit-frame-pointer.
 !1 = !{i32 7, !"frame-pointer", i32 2}
 
 ;; Set the uwtable attribute on ctor/dtor.
-; CHECK: define internal void @asan.module_ctor() #[[#ATTR:]]
-; CHECK: define internal void @asan.module_dtor() #[[#ATTR]]
+; CHECK: define hidden void @asan.module_ctor() #[[#ATTR:]]
+; CHECK: define hidden void @asan.module_dtor() #[[#ATTR]]
 ; CHECK: attributes #[[#ATTR]] = { nounwind uwtable "frame-pointer"="all" }

llvm/test/Instrumentation/AddressSanitizer/no-global-ctors.ll

 ; Check Default behaviour still emits ctors
 ; RUN: opt < %s -passes=asan -S | \
 ; RUN:   FileCheck -check-prefix=CHECK-DEFAULT %s
 ; CHECK-DEFAULT: llvm.global_ctor{{.+}}asan.module_ctor
 ; CHECK-DEFAULT: define internal void @asan.module_ctor
 
 ; Check with ctor emission disabled
 ; RUN: opt < %s -passes=asan \
 ; RUN:   -asan-constructor-kind=none -S | \
 ; RUN:   FileCheck %s
 ; CHECK-NOT: llvm.global_ctor{{.+}}asan.module_ctor
-; CHECK-NOT: define internal void @asan.module_ctor
+; CHECK-NOT: define{{.*}}void @asan.module_ctor
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx11.0.0"
 
 @foo = dso_local global i32 0, align 4

llvm/test/Instrumentation/AddressSanitizer/no-globals.ll

 ; A module with no asan-instrumented globals has no asan destructor, and has an asan constructor in a comdat.
 ; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -passes=asan -asan-with-comdat=1 -asan-globals-live-support=1 -S | FileCheck %s
 
 define void @f() {
   ret void
 }
 
 ; CHECK-NOT: @llvm.global_dtors
 ; CHECK: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 1, ptr @asan.module_ctor, ptr @asan.module_ctor }]
 ; CHECK-NOT: @llvm.global_dtors
-; CHECK: define internal void @asan.module_ctor() #[[#]] comdat
+; CHECK: define hidden void @asan.module_ctor() #[[#]] comdat
 ; CHECK-NOT: @llvm.global_dtors

llvm/test/Instrumentation/AddressSanitizer/no_global_dtors.ll

 ; Check Default behaviour still emits dtors
 ; RUN: opt < %s -passes=asan -S | \
 ; RUN:   FileCheck -check-prefix=CHECK-DEFAULT %s
 ; CHECK-DEFAULT: llvm.global_dtor{{.+}}asan.module_dtor
 ; CHECK-DEFAULT: define internal void @asan.module_dtor
 
 ; Check with dtor emission disabled
 ; RUN: opt < %s -passes=asan \
 ; RUN:   -asan-destructor-kind=none -S | \
 ; RUN:   FileCheck %s
 ; CHECK-NOT: llvm.global_dtor{{.+}}asan.module_dtor
-; CHECK-NOT: define internal void @asan.module_dtor
+; CHECK-NOT: define{{.*}}void @asan.module_dtor
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx11.0.0"
 
 @foo = dso_local global i32 0, align 4

llvm/test/Instrumentation/AddressSanitizer/program-addrspace.ll

 ; RUN: opt -S -passes=asan < %s | FileCheck %s
 
 ; Check behavior with a non-0 default program address space. The
 ; constructor should be in addrspace(1) and the global_ctors should
 ; pass the verifier.
 
 ; CHECK: @a = internal addrspace(42) global [1 x i32] zeroinitializer, align 4
 ; CHECK: @llvm.used = appending global [1 x ptr] [ptr addrspacecast (ptr addrspace(1) @asan.module_ctor to ptr)], section "llvm.metadata"
 ; CHECK: @llvm.global_ctors = appending global [1 x { i32, ptr addrspace(1), ptr }] [{ i32, ptr addrspace(1), ptr } { i32 1, ptr addrspace(1) @asan.module_ctor, ptr addrspacecast (ptr addrspace(1) @asan.module_ctor to ptr) }]
 
-; CHECK: define internal void @asan.module_ctor() addrspace(1) #0 comdat {
+; CHECK: define hidden void @asan.module_ctor() addrspace(1) #0 comdat {
 
 target datalayout = "P1"
 
 @a = internal addrspace(42) global [1 x i32] zeroinitializer, align 4
 
 define i1 @b(i64 %c) addrspace(1) {
   %cast = inttoptr i64 %c to ptr addrspace(42)
   %cmp = icmp ugt ptr addrspace(42) %cast, getelementptr inbounds ([1 x i32], ptr addrspace(42) @a, i64 0, i64 0)
   ret i1 %cmp
 }
 
 !llvm.asan.globals = !{!0}
 !0 = !{ptr addrspace(42) @a, null, !"a", i1 false, i1 false}

llvm/test/Instrumentation/AddressSanitizer/version-mismatch-check.ll

 ; Check that the ASan module constructor guards against compiler/runtime version
 ; mismatch.
 
 ; RUN: opt < %s -passes=asan                                        -S | FileCheck %s
 ; RUN: opt < %s -passes=asan -asan-guard-against-version-mismatch=0 -S | FileCheck %s --check-prefix=NOGUARD
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
-; CHECK-LABEL: define internal void @asan.module_ctor()
+; CHECK-LABEL: define hidden void @asan.module_ctor()
 ; CHECK:         call void @__asan_version_mismatch_check_
 ; NOGUARD-NOT:   call void @__asan_version_mismatch_check_

llvm/test/Instrumentation/HWAddressSanitizer/RISCV/basic.ll

 
 entry:
   %b = load i8, ptr addrspace(256) %a, align 4
   ret i8 %b
 }
 
 ; CHECK: declare void @__hwasan_init()
 
-; CHECK:      define internal void @hwasan.module_ctor() #[[#ATTR:]] comdat {
+; CHECK:      define hidden void @hwasan.module_ctor() #[[#ATTR:]] comdat {
 ; CHECK-NEXT:   call void @__hwasan_init()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }
 
 ; CHECK:      attributes #[[#ATTR]] = { nounwind }

llvm/test/Instrumentation/HWAddressSanitizer/RISCV/with-calls.ll

 
 entry:
   %b = load i8, ptr addrspace(256) %a, align 4
   ret i8 %b
 }
 
 ; CHECK: declare void @__hwasan_init()
 
-; CHECK:      define internal void @hwasan.module_ctor() #[[#]] comdat {
+; CHECK:      define hidden void @hwasan.module_ctor() #[[#]] comdat {
 ; CHECK-NEXT:   call void @__hwasan_init()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }

llvm/test/Instrumentation/HWAddressSanitizer/basic.ll

 
 entry:
   %b = load i8, ptr addrspace(256) %a, align 4
   ret i8 %b
 }
 
 ; CHECK: declare void @__hwasan_init()
 
-; CHECK:      define internal void @hwasan.module_ctor() #[[#ATTR:]] comdat {
+; CHECK:      define hidden void @hwasan.module_ctor() #[[#ATTR:]] comdat {
 ; CHECK-NEXT:   call void @__hwasan_init()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }
 
 ; CHECK:      attributes #[[#ATTR]] = { nounwind }

llvm/test/Instrumentation/HWAddressSanitizer/with-calls.ll

 
 entry:
   %b = load i8, ptr addrspace(256) %a, align 4
   ret i8 %b
 }
 
 ; CHECK: declare void @__hwasan_init()
 
-; CHECK:      define internal void @hwasan.module_ctor() #[[#]] comdat {
+; CHECK:      define hidden void @hwasan.module_ctor() #[[#]] comdat {
 ; CHECK-NEXT:   call void @__hwasan_init()
 ; CHECK-NEXT:   ret void
 ; CHECK-NEXT: }

llvm/test/Instrumentation/SanitizerCoverage/pc-table.ll

entry:
 
   if.end:                                           ; preds = %entry, %if.then
   ret void
 }
 
 ; CHECK: private constant [6 x ptr] [ptr @foo, ptr inttoptr (i64 1 to ptr), ptr blockaddress(@foo, %entry.if.end_crit_edge), ptr null, ptr blockaddress(@foo, %if.then), ptr null], section "__sancov_pcs", comdat($foo), align 8
 ; CHECK:      @__start___sancov_pcs = extern_weak hidden global i64
 ; CHECK-NEXT: @__stop___sancov_pcs = extern_weak hidden global i64
-; CHECK: define internal void @sancov.module_ctor
+; CHECK: define hidden void @sancov.module_ctor
 ; CHECK: call void @__sanitizer_cov
 ; CHECK: call void @__sanitizer_cov_pcs_init

llvm/test/Instrumentation/SanitizerCoverage/trace-pc-guard-inline-8bit-counters.ll

 ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=1 -sanitizer-coverage-trace-pc-guard -sanitizer-coverage-inline-8bit-counters -S | FileCheck %s
 
 ; Module ctors should have stable names across modules, not something like
 ; @sancov.module_ctor.3 that may cause duplicate ctors after linked together.
 
-; CHECK: define internal void @sancov.module_ctor_trace_pc_guard() #[[#]] comdat {
-; CHECK: define internal void @sancov.module_ctor_8bit_counters() #[[#]] comdat {
+; CHECK: define hidden void @sancov.module_ctor_trace_pc_guard() #[[#]] comdat {
+; CHECK: define hidden void @sancov.module_ctor_8bit_counters() #[[#]] comdat {
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 define void @foo() {
   ret void
 }

llvm/test/Instrumentation/SanitizerCoverage/trace-pc-guard-inline-bool-flag.ll

 ; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=1 -sanitizer-coverage-trace-pc-guard -sanitizer-coverage-inline-bool-flag -S | FileCheck %s
 
 ; Module ctors should have stable names across modules, not something like
 ; @sancov.module_ctor.3 that may cause duplicate ctors after linked together.
+; They should also have external linkage, so that LTO doesn't end up producing
+; duplicate ctors either.
 
-; CHECK: define internal void @sancov.module_ctor_trace_pc_guard() #[[#]] comdat {
-; CHECK: define internal void @sancov.module_ctor_bool_flag() #[[#]] comdat {
+; CHECK: define hidden void @sancov.module_ctor_trace_pc_guard() #[[#]] comdat {
+; CHECK: define hidden void @sancov.module_ctor_bool_flag() #[[#]] comdat {
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 define void @foo() {
   ret void
 }

llvm/test/Instrumentation/SanitizerCoverage/trace-pc-guard.ll

 
 declare i32 @direct_callee()
 
 define void @DirectBitcastCall() sanitize_address {
   call void @direct_callee()
   ret void
 }
 
-; ELF-LABEL: define internal void @sancov.module_ctor_trace_pc_guard() #2 comdat {
+; ELF-LABEL: define hidden void @sancov.module_ctor_trace_pc_guard() #2 comdat {
 ; MACHO-LABEL: define internal void @sancov.module_ctor_trace_pc_guard() #2 {
 
 ; CHECK: attributes #2 = { nounwind }