[MC] Add a separate flag for skipping comdat constant sections for MinGW. NFC.

[mstorsjo]

Summary

This actually has nothing to do with the associative comdat sections that aren't supported by GNU binutils ld.

Clarify the comments from SVN r335918 and use a separate flag for it.

[rnk]

lgtm

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/TargetLoweringObjectFileImpl.cpp

if (isa<UndefValue>(C)) {
     return HexString;
   }
 }
 
 MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
     const DataLayout &DL, SectionKind Kind, const Constant *C,
     unsigned &Align) const {
   if (Kind.isMergeableConst() && C &&
-      getContext().getAsmInfo()->hasCOFFAssociativeComdats()) {
-    // GNU binutils doesn't support the kind of symbol with a null
-    // storage class that this generates.
+      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.
     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;
 }