MC/COFF: Do not emit forward associative section referenceds.

[ruiu]

Summary

MSVC link.exe cannot handle associative sections that refer later
sections in the section header. Technically, such COFF object doesn't
violate the Microsoft COFF spec, as the spec doesn't say anything
about that, but still we should avoid doing that to make it compatible
with MS tools.

This patch assigns smaller section numbers to non-associative sections
and larger numbers to associative sections. This should resolve the
compatibility issue.

llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp

public:
 
   bool IsPhysicalSection(COFFSection *S);
 
   // Entity writing methods.
 
   void WriteFileHeader(const COFF::header &Header);
   void WriteSymbol(const COFFSymbol &S);
   void WriteAuxiliarySymbols(const COFFSymbol::AuxiliarySymbols &S);
-  void writeSectionHeader(const COFF::section &S);
+  void writeSectionHeaders();
   void WriteRelocation(const COFF::relocation &R);
   uint32_t writeSectionContents(MCAssembler &Asm, const MCAsmLayout &Layout,
                                 const MCSection &MCSec);
   void writeSection(MCAssembler &Asm, const MCAsmLayout &Layout,
                     const COFFSection &Sec, const MCSection &MCSec);
 
   // MCObjectWriter interface implementation.
 
case ATSectionDefinition:
       writeLE16(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
       if (UseBigObj)
         WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     }
   }
 }
 
-void WinCOFFObjectWriter::writeSectionHeader(const COFF::section &S) {
-  writeBytes(StringRef(S.Name, COFF::NameSize));
+// Write the section header.
+void WinCOFFObjectWriter::writeSectionHeaders() {
+  // Section numbers must be monotonically increasing in the section
+  // header, but our Sections array is not sorted by section number,
+  // so make a copy of Sections and sort it.
+  std::vector<COFFSection *> Arr;
+  for (auto &Section : Sections)
+    Arr.push_back(Section.get());
+  std::sort(Arr.begin(), Arr.end(),
+            [](const COFFSection *A, const COFFSection *B) {
+              return A->Number < B->Number;
+            });
+
+  for (auto &Section : Arr) {
+    if (Section->Number == -1)
+      continue;
 
+    COFF::section &S = Section->Header;
+    if (Section->Relocations.size() >= 0xffff)
+      S.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
+    writeBytes(StringRef(S.Name, COFF::NameSize));
     writeLE32(S.VirtualSize);
     writeLE32(S.VirtualAddress);
     writeLE32(S.SizeOfRawData);
     writeLE32(S.PointerToRawData);
     writeLE32(S.PointerToRelocations);
     writeLE32(S.PointerToLineNumbers);
     writeLE16(S.NumberOfRelocations);
     writeLE16(S.NumberOfLineNumbers);
     writeLE32(S.Characteristics);
   }
+}
 
 void WinCOFFObjectWriter::WriteRelocation(const COFF::relocation &R) {
   writeLE32(R.VirtualAddress);
   writeLE32(R.SymbolTableIndex);
   writeLE16(R.Type);
 }
 
 // Write MCSec's contents. What this function does is essentially
for (auto &Aux : File->Aux) {
         break;
       }
 
       Offset += SymbolSize;
     }
   }
 }
 
+static bool isAssociative(const COFFSection &Section) {
+  return Section.Symbol->Aux[0].Aux.SectionDefinition.Selection ==
+         COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
+}
+
 void WinCOFFObjectWriter::assignSectionNumbers() {
   size_t I = 1;
-  for (const auto &Section : Sections) {
-    Section->Number = I;
-    Section->Symbol->Data.SectionNumber = I;
-    Section->Symbol->Aux[0].Aux.SectionDefinition.Number = I;
+  auto Assign = [&](COFFSection &Section) {
+    Section.Number = I;
+    Section.Symbol->Data.SectionNumber = I;
+    Section.Symbol->Aux[0].Aux.SectionDefinition.Number = I;
     ++I;
-  }
+  };
+
+  // Although it is not explicitly requested by the Microsoft COFF spec,
+  // we should avoid emitting forward associative section references,
+  // because MSVC link.exe as of 2017 cannot handle that.
+  for (const std::unique_ptr<COFFSection> &Section : Sections)
+    if (!isAssociative(*Section))
+      Assign(*Section);
+  for (const std::unique_ptr<COFFSection> &Section : Sections)
+    if (isAssociative(*Section))
+      Assign(*Section);
 }
 
 // Assign file offsets to COFF object file structures.
 void WinCOFFObjectWriter::assignFileOffsets(MCAssembler &Asm,
                                             const MCAsmLayout &Layout) {
   unsigned Offset = getInitialOffset();
 
   Offset += UseBigObj ? COFF::Header32Size : COFF::Header16Size;
if (Asm.isIncrementalLinkerCompatible()) {
     Header.TimeDateStamp = getTime();
   } else {
     // Have deterministic output if /INCREMENTAL isn't needed. Also matches GNU.
     Header.TimeDateStamp = 0;
   }
 
   // Write it all to disk...
   WriteFileHeader(Header);
-
-  for (auto &Section : Sections) {
-    if (Section->Number != -1) {
-      if (Section->Relocations.size() >= 0xffff)
-        Section->Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
-      writeSectionHeader(Section->Header);
-    }
-  }
+  writeSectionHeaders();
 
   // Write section contents.
   sections::iterator I = Sections.begin();
   sections::iterator IE = Sections.end();
   MCAssembler::iterator J = Asm.begin();
   MCAssembler::iterator JE = Asm.end();
   for (; I != IE && J != JE; ++I, ++J)
     writeSection(Asm, Layout, **I, *J);

llvm/trunk/test/DebugInfo/COFF/globals.ll

 ; OBJ:       DataOffset: ?last@@3HA+0x0
 ; OBJ:       Type: int (0x74)
 ; OBJ:       DisplayName: last
 ; OBJ:       LinkageName: ?last@@3HA
 ; OBJ:     }
 ; OBJ:   ]
 ; OBJ: ]
 ; OBJ: CodeViewDebugInfo [
-; OBJ:   Section: .debug$S (7)
+; OBJ:   Section: .debug$S (8)
 ; OBJ:   Magic: 0x4
 ; OBJ:   Subsection [
 ; OBJ:     SubSectionType: Symbols (0xF1)
 ; OBJ:     DataSym {
 ; OBJ:       DataOffset: ?comdat@?$A@X@@2HB+0x0
 ; OBJ:       Type: const int (0x1000)
 ; OBJ:       DisplayName: comdat
 ; OBJ:       LinkageName: ?comdat@?$A@X@@2HB

llvm/trunk/test/DebugInfo/COFF/types-data-members.ll

 ;   Union u;
 ;   Class c;
 ;   DerivedClass dc;
 ;   Class::Nested n;
 ; }
 ; $ clang t.cpp -S -emit-llvm -g -gcodeview -o t.ll
 
 ; CHECK: CodeViewTypes [
-; CHECK:   Section: .debug$T (10)
+; CHECK:   Section: .debug$T (8)
 ; CHECK:   Magic: 0x4
 ; CHECK:   ArgList (0x1000) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; CHECK:     NumArgs: 0
 ; CHECK:     Arguments [
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   Procedure (0x1001) {

llvm/trunk/test/MC/COFF/section-comdat.s

 // CHECK:     }
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: Symbol4
 // CHECK:     Section: SecName (8)
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: SecName
-// CHECK:     Section: SecName (9)
+// CHECK:     Section: SecName (11)
 // CHECK:     AuxSectionDef {
 // CHECK:       Selection: Associative
 // CHECK:       AssocSection: assocSec (4)
 // CHECK:     }
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: SecName
-// CHECK:     Section: SecName (10)
+// CHECK:     Section: SecName (9)
 // CHECK:     AuxSectionDef {
 // CHECK:       Selection: Largest
 // CHECK:     }
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: Symbol6
-// CHECK:     Section: SecName (10)
+// CHECK:     Section: SecName (9)
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: SecName
-// CHECK:     Section: SecName (11)
+// CHECK:     Section: SecName (10)
 // CHECK:     AuxSectionDef {
 // CHECK:       Selection: Newest (0x7)
 // CHECK:     }
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: Symbol7
-// CHECK:     Section: SecName (11)
+// CHECK:     Section: SecName (10)
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: assocSec
 // CHECK:     Section: assocSec (12)
 // CHECK:     AuxSectionDef {
 // CHECK:       Selection: Associative (0x5)
 // CHECK:       AssocSection: assocSec (4)
 // CHECK:     }
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: Symbol5
-// CHECK:     Section: SecName (9)
+// CHECK:     Section: SecName (11)
 // CHECK:   }
 // CHECK:   Symbol {
 // CHECK:     Name: Symbol8
 // CHECK:     Section: assocSec (12)
 // CHECK:   }
 // CHECK: ]