[InstrProf] Use comdats on COFF for available_externally functions

[rnk]

Summary

r262157 added ELF-specific logic to put a comdat on the __profc_*
globals created for available_externally functions. We should be able to
generalize that logic to all object file formats that support comdats,
i.e. everything other than MachO. This fixes duplicate symbol errors,
since on COFF, linkonce_odr doesn't make the symbol weak.

Fixes PR38251.

[davidxl]

lgtm

llvm/lib/ProfileData/InstrProf.cpp

void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName) {
   MDNode *N = MDNode::get(C, MDString::get(C, PGOFuncName));
   F.setMetadata(getPGOFuncNameMetadataName(), N);
 }
 
 bool needsComdatForCounter(const Function &F, const Module &M) {
   if (F.hasComdat())
     return true;
 
-  Triple TT(M.getTargetTriple());
-  if (!TT.isOSBinFormatELF() && !TT.isOSBinFormatWasm())
+  if (!Triple(M.getTargetTriple()).supportsCOMDAT())
     return false;
 
   // See createPGOFuncNameVar for more details. To avoid link errors, profile
   // counters for function with available_externally linkage needs to be changed
   // to linkonce linkage. On ELF based systems, this leads to weak symbols to be
   // created. Without using comdat, duplicate entries won't be removed by the
   // linker leading to increased data segement size and raw profile size. Even
   // worse, since the referenced counter from profile per-function data object

llvm/test/Instrumentation/InstrProfiling/linkage.ll

 ; COMMON: @__profd_foo_weak = weak hidden global
 define weak void @foo_weak() {
   call void @llvm.instrprof.increment(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @__profn_foo_weak, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 ; COMMON: @"__profc_linkage.ll:foo_internal" = internal global
 ; COMMON: @"__profd_linkage.ll:foo_internal" = internal global
+; COFF: @"__profc_linkage.ll:foo_internal" = internal global
+; COFF: @"__profd_linkage.ll:foo_internal" = internal global
 define internal void @foo_internal() {
   call void @llvm.instrprof.increment(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @"__profn_linkage.ll:foo_internal", i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 ; COMMON: @__profc_foo_inline = linkonce_odr hidden global
 ; COMMON: @__profd_foo_inline = linkonce_odr hidden global
+; FIXME: Should we put a comdat here?
+; COFF: @__profc_foo_inline = linkonce_odr hidden global {{.*}}section ".lprfc", align 8
+; COFF: @__profd_foo_inline = linkonce_odr hidden global {{.*}}section ".lprfd", align 8
 define linkonce_odr void @foo_inline() {
   call void @llvm.instrprof.increment(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @__profn_foo_inline, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 ; LINUX: @__profc_foo_extern = linkonce_odr hidden global {{.*}}section "__llvm_prf_cnts", comdat($__profv_foo_extern), align 8
 ; LINUX: @__profd_foo_extern = linkonce_odr hidden global {{.*}}section "__llvm_prf_data", comdat($__profv_foo_extern), align 8
 ; OTHER: @__profc_foo_extern = linkonce_odr hidden global
 ; OTHER: @__profd_foo_extern = linkonce_odr hidden global
+; COFF: @__profc_foo_extern = linkonce_odr hidden global {{.*}}section ".lprfc", comdat, align 8
+; COFF: @__profd_foo_extern = linkonce_odr hidden global {{.*}}section ".lprfd", comdat($__profc_foo_extern), align 8
 define available_externally void @foo_extern() {
   call void @llvm.instrprof.increment(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @__profn_foo_extern, i32 0, i32 0), i64 0, i32 1, i32 0)
   ret void
 }
 
 declare void @llvm.instrprof.increment(i8*, i64, i32, i32)
 
 ; OTHER: define linkonce_odr hidden i32 @__llvm_profile_runtime_user() {{.*}} {
 ; OTHER:   %[[REG:.*]] = load i32, i32* @__llvm_profile_runtime
 ; OTHER:   ret i32 %[[REG]]
 ; OTHER: }
 ; COFF: define linkonce_odr hidden i32 @__llvm_profile_runtime_user() {{.*}} comdat {
 ; LINUX-NOT: define linkonce_odr hidden i32 @__llvm_profile_runtime_user() {{.*}} {
 ; LINUX-NOT:   %[[REG:.*]] = load i32, i32* @__llvm_profile_runtime

llvm/test/Transforms/PGOProfile/comdat_rename.ll

-; RUN: opt < %s -mtriple=x86_64-unknown-linux -pgo-instr-gen -do-comdat-renaming=true -S | FileCheck --check-prefixes COMMON,ELFONLY %s
-; RUN: opt < %s -mtriple=x86_64-unknown-linux -passes=pgo-instr-gen -do-comdat-renaming=true -S | FileCheck --check-prefixes COMMON,ELFONLY %s
-; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -pgo-instr-gen -do-comdat-renaming=true -S | FileCheck --check-prefixes COMMON,COFFONLY %s
-; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -passes=pgo-instr-gen -do-comdat-renaming=true -S | FileCheck --check-prefixes COMMON,COFFONLY %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux -pgo-instr-gen -do-comdat-renaming=true -S | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux -passes=pgo-instr-gen -do-comdat-renaming=true -S | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -pgo-instr-gen -do-comdat-renaming=true -S | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-pc-win32-coff -passes=pgo-instr-gen -do-comdat-renaming=true -S | FileCheck %s
 
 ; Rename Comdat group and its function.
 $f = comdat any
-; COMMON: $f.[[SINGLEBB_HASH:[0-9]+]] = comdat any
+; CHECK: $f.[[SINGLEBB_HASH:[0-9]+]] = comdat any
 define linkonce_odr void @f() comdat($f) {
   ret void
 }
 
 ; Not rename Comdat with right linkage.
 $nf = comdat any
-; COMMON: $nf = comdat any
+; CHECK: $nf = comdat any
 define void @nf() comdat($nf) {
   ret void
 }
 
 ; Not rename Comdat with variable members.
 $f_with_var = comdat any
-; COMMON: $f_with_var = comdat any
+; CHECK: $f_with_var = comdat any
 @var = global i32 0, comdat($f_with_var)
 define linkonce_odr void @f_with_var() comdat($f_with_var) {
   %tmp = load i32, i32* @var, align 4
   %inc = add nsw i32 %tmp, 1
   store i32 %inc, i32* @var, align 4
   ret void
 }
 
 ; Not rename Comdat with multiple functions.
 $tf = comdat any
-; COMMON: $tf = comdat any
+; CHECK: $tf = comdat any
 define linkonce void @tf() comdat($tf) {
   ret void
 }
 define linkonce void @tf2() comdat($tf) {
   ret void
 }
 
 ; Rename AvailableExternallyLinkage functions
-; ELFONLY-DAG: $aef.[[SINGLEBB_HASH]] = comdat any
+; CHECK-DAG: $aef.[[SINGLEBB_HASH]] = comdat any
 
-; ELFONLY: @f = weak alias void (), void ()* @f.[[SINGLEBB_HASH]]
-; ELFONLY: @aef = weak alias void (), void ()* @aef.[[SINGLEBB_HASH]]
+; CHECK: @f = weak alias void (), void ()* @f.[[SINGLEBB_HASH]]
+; CHECK: @aef = weak alias void (), void ()* @aef.[[SINGLEBB_HASH]]
 
 define available_externally void @aef() {
-; ELFONLY: define linkonce_odr void @aef.[[SINGLEBB_HASH]]() comdat {
-; COFFONLY: define available_externally void @aef() {
+; CHECK: define linkonce_odr void @aef.[[SINGLEBB_HASH]]() comdat {
   ret void
 }