[COFF] Use comdat shared constants for MinGW as well

[mstorsjo]

Summary

GNU binutils tools have no problems with this kind of shared constants, provided that we actually hook it up completely in AsmPrinter and
produce a global symbol.

This effectively reverts SVN r335918 by hooking the rest of it up properly.

This feature was implemented originally in SVN r213006, with no reason for why it can't be used for MinGW other than the fact that GCC doesn't
do it while MSVC does.

This goes on top of D49645 (which clarifies the current code). If both go in at once, they can be squashed, avoiding adding the flag that is removed directly afterwards again.

@majnemer Or was there any specific reason not to do this for all windows targets?

[rnk]

Great, that makes sense now. These constants are regular old comdat constants. This makes us use the MSVC constant name mangling for now, but that's fine. The linker won't deduplicate constants between Clang and GCC, but that's not an ABI compatibility problem.

llvm/trunk/include/llvm/MC/MCAsmInfo.h

protected:
   /// directive for emitting thread local BSS Symbols.  Default is false.
   bool HasMachoTBSSDirective = false;
 
   /// True if this is a non-GNU COFF target. The COFF port of the GNU linker
   /// doesn't handle associative comdats in the way that we would like to use
   /// them.
   bool HasCOFFAssociativeComdats = false;
 
-  /// True if this is a non-GNU COFF target. For GNU targets, we don't generate
-  /// constants into comdat sections.
-  bool HasCOFFComdatConstants = false;
-
   /// This is the maximum possible length of an instruction, which is needed to
   /// compute the size of an inline asm.  Defaults to 4.
   unsigned MaxInstLength = 4;
 
   /// Every possible instruction length is a multiple of this value.  Factored
   /// out in .debug_frame and .debug_line.  Defaults to 1.
   unsigned MinInstAlignment = 1;
 
bool needsDwarfSectionOffsetDirective() const {
     return NeedsDwarfSectionOffsetDirective;
   }
 
   // Accessors.
 
   bool hasMachoZeroFillDirective() const { return HasMachoZeroFillDirective; }
   bool hasMachoTBSSDirective() const { return HasMachoTBSSDirective; }
   bool hasCOFFAssociativeComdats() const { return HasCOFFAssociativeComdats; }
-  bool hasCOFFComdatConstants() const { return HasCOFFComdatConstants; }
   unsigned getMaxInstLength() const { return MaxInstLength; }
   unsigned getMinInstAlignment() const { return MinInstAlignment; }
   bool getDollarIsPC() const { return DollarIsPC; }
   const char *getSeparatorString() const { return SeparatorString; }
 
   /// This indicates the column (zero-based) at which asm comments should be
   /// printed.
   unsigned getCommentColumn() const { return 40; }

llvm/trunk/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 }
 
 MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const {
   return MMI->getAddrLabelSymbol(BB);
 }
 
 /// GetCPISymbol - Return the symbol for the specified constant pool entry.
 MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const {
-  if (getSubtargetInfo().getTargetTriple().isKnownWindowsMSVCEnvironment()) {
+  if (getSubtargetInfo().getTargetTriple().isOSWindows()) {
     const MachineConstantPoolEntry &CPE =
         MF->getConstantPool()->getConstants()[CPID];
     if (!CPE.isMachineConstantPoolEntry()) {
       const DataLayout &DL = MF->getDataLayout();
       SectionKind Kind = CPE.getSectionKind(&DL);
       const Constant *C = CPE.Val.ConstVal;
       unsigned Align = CPE.Alignment;
       if (const MCSectionCOFF *S = dyn_cast<MCSectionCOFF>(

llvm/trunk/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

for (int I = NumElements - 1, E = -1; I != E; --I)
       HexString += scalarConstantToHexString(C->getAggregateElement(I));
     return HexString;
   }
 }
 
 MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
     const DataLayout &DL, SectionKind Kind, const Constant *C,
     unsigned &Align) const {
-  if (Kind.isMergeableConst() && C &&
-      getContext().getAsmInfo()->hasCOFFComdatConstants()) {
-    // This creates comdat sections with the given symbol name, but unless
-    // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
-    // will be created with a null storage class, which makes GNU binutils
-    // error out.
+  if (Kind.isMergeableConst() && C) {
     const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                                      COFF::IMAGE_SCN_MEM_READ |
                                      COFF::IMAGE_SCN_LNK_COMDAT;
     std::string COMDATSymName;
     if (Kind.isMergeableConst4()) {
       if (Align <= 4) {
         COMDATSymName = "__real@" + scalarConstantToHexString(C);
         Align = 4;

llvm/trunk/lib/MC/MCAsmInfoCOFF.cpp

MCAsmInfoCOFF::MCAsmInfoCOFF() {
   UseIntegratedAssembler = true;
 
   // At least MSVC inline-asm does AShr.
   UseLogicalShr = false;
 
   // If this is a COFF target, assume that it supports associative comdats. It's
   // part of the spec.
   HasCOFFAssociativeComdats = true;
-
-  // We can generate constants in comdat sections that can be shared,
-  // but in order not to create null typed symbols, we actually need to
-  // make them global symbols as well.
-  HasCOFFComdatConstants = true;
 }
 
 void MCAsmInfoMicrosoft::anchor() {}
 
 MCAsmInfoMicrosoft::MCAsmInfoMicrosoft() = default;
 
 void MCAsmInfoGNUCOFF::anchor() {}
 
 MCAsmInfoGNUCOFF::MCAsmInfoGNUCOFF() {
   // If this is a GNU environment (mingw or cygwin), don't use associative
   // comdats for jump tables, unwind information, and other data associated with
   // a function.
   HasCOFFAssociativeComdats = false;
-
-  // We don't create constants in comdat sections for MinGW.
-  HasCOFFComdatConstants = false;
 }

llvm/trunk/test/CodeGen/AArch64/win_cst_pool.ll

 ; RUN: llc < %s -mtriple=aarch64-win32-msvc | FileCheck %s
-; RUN: llc < %s -mtriple=aarch64-win32-gnu | FileCheck -check-prefix=MINGW %s
+; RUN: llc < %s -mtriple=aarch64-win32-gnu | FileCheck %s
 
 define double @double() {
   ret double 0x0000000000800000
 }
 ; CHECK:              .globl  __real@0000000000800000
 ; CHECK-NEXT:         .section        .rdata,"dr",discard,__real@0000000000800000
 ; CHECK-NEXT:         .p2align  3
 ; CHECK-NEXT: __real@0000000000800000:
 ; CHECK-NEXT:         .xword   8388608
 ; CHECK:      double:
 ; CHECK:               adrp    x8, __real@0000000000800000
 ; CHECK-NEXT:          ldr     d0, [x8, __real@0000000000800000]
 ; CHECK-NEXT:          ret
-
-; MINGW:              .section        .rdata,"dr"
-; MINGW-NEXT:         .p2align  3
-; MINGW-NEXT: [[LABEL:\.LC.*]]:
-; MINGW-NEXT:         .xword   8388608
-; MINGW:      double:
-; MINGW:               adrp    x8, [[LABEL]]
-; MINGW-NEXT:          ldr     d0, [x8, [[LABEL]]]
-; MINGW-NEXT:          ret

llvm/trunk/test/CodeGen/X86/win_cst_pool.ll

 ; RUN: llc < %s -mtriple=x86_64-win32 -mattr=sse2 -mattr=avx | FileCheck %s
-; RUN: llc < %s -mtriple=x86_64-win32-gnu -mattr=sse2 -mattr=avx | FileCheck -check-prefix=MINGW %s
+; RUN: llc < %s -mtriple=x86_64-win32-gnu -mattr=sse2 -mattr=avx | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define double @double() {
   ret double 0x0000000000800000
 }
 ; CHECK:              .globl  __real@0000000000800000
 ; CHECK-NEXT:         .section        .rdata,"dr",discard,__real@0000000000800000
 ; CHECK-NEXT:         .p2align  3
 ; CHECK-NEXT: __real@0000000000800000:
 ; CHECK-NEXT:         .quad   8388608
 ; CHECK:      double:
 ; CHECK:               movsd   __real@0000000000800000(%rip), %xmm0
 ; CHECK-NEXT:          ret
 
-; MINGW:              .section        .rdata,"dr"
-; MINGW-NEXT:         .p2align  3
-; MINGW-NEXT: [[LABEL:\.LC.*]]:
-; MINGW-NEXT:         .quad   8388608
-; MINGW:      double:
-; MINGW:               movsd   [[LABEL]](%rip), %xmm0
-; MINGW-NEXT:          ret
-
 define <4 x i32> @vec1() {
   ret <4 x i32> <i32 3, i32 2, i32 1, i32 0>
 }
 ; CHECK:              .globl  __xmm@00000000000000010000000200000003
 ; CHECK-NEXT:         .section        .rdata,"dr",discard,__xmm@00000000000000010000000200000003
 ; CHECK-NEXT:         .p2align  4
 ; CHECK-NEXT: __xmm@00000000000000010000000200000003:
 ; CHECK-NEXT:         .long   3