Fix a bug that would cause subzero to fail when --threads=0.

src/IceELFObjectWriter.h

 //===- subzero/src/IceELFObjectWriter.h - ELF object writer -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Abstraction for a writer that is responsible for writing an ELF file.
@@ skipping 12 matching lines @@
 
 namespace Ice {
 
 // Higher level ELF object writer.  Manages section information and writes
 // the final ELF object.  The object writer will write to file the code
 // and data as it is being defined (rather than keep a copy).
 // After all definitions are written out, it will finalize the bookkeeping
 // sections and write them out.  Expected usage:
 //
 // (1) writeInitialELFHeader (invoke once)
-// (2) writeDataSection  (invoke once)
+// (2) writeDataSection  (may be invoked multiple times, as long as
+// SectionSuffix is unique)

[Jim Stichnoth, 2015/06/16 17:03:24]

can you indent this by 4 characters?

[John, 2015/06/16 17:30:55]

Done.

 // (3) writeFunctionCode (must invoke once per function)
 // (4) writeConstantPool (must invoke once per pooled primitive type)
 // (5) setUndefinedSyms (invoke once)
 // (6) writeNonUserSections (invoke once)
 //
 // The requirement for writeDataSection to be invoked only once can
 // be relaxed if using -fdata-sections. The requirement to invoke only once
 // without -fdata-sections is so that variables that belong to each possible
 // SectionType are contiguous in the file. With -fdata-sections, each global
 // variable is in a separate section and therefore the sections will be
 // trivially contiguous.
 //
-// The motivation for requiring that writeFunctionCode happen after
-// writeDataSection: to keep the .text and .data sections contiguous in the
-// file. Having both -fdata-sections and -ffunction-sections does allow
-// relaxing this requirement.
+// TODO(jpp): explain what's going on here.
 class ELFObjectWriter {
   ELFObjectWriter() = delete;
   ELFObjectWriter(const ELFObjectWriter &) = delete;
   ELFObjectWriter &operator=(const ELFObjectWriter &) = delete;
 
 public:
   ELFObjectWriter(GlobalContext &Ctx, ELFStreamer &Out);
 
   // Write the initial ELF header. This is just to reserve space in the ELF
   // file. Reserving space allows the other functions to write text
   // and data directly to the file and get the right file offsets.
   void writeInitialELFHeader();
 
   // Copy initializer data for globals to file and note the offset and size
   // of each global's definition in the symbol table.
   // Use the given target's RelocationKind for any relocations.
   void writeDataSection(const VariableDeclarationList &Vars,
-                        FixupKind RelocationKind);
+                        FixupKind RelocationKind,
+                        const IceString &SectionSuffix);
 
   // Copy data of a function's text section to file and note the offset of the
   // symbol's definition in the symbol table.
   // Copy the text fixups for use after all functions are written.
   // The text buffer and fixups are extracted from the Assembler object.
   void writeFunctionCode(const IceString &FuncName, bool IsInternal,
                          const Assembler *Asm);
 
   // Queries the GlobalContext for constant pools of the given type
   // and writes out read-only data sections for those constants. This also
@@ skipping 66 matching lines @@
                                   RelSectionList &RelSections,
                                   SectionList &AllSections);
 
   // Link the relocation sections to the symbol table.
   void assignRelLinkNum(SizeT SymTabNumber, RelSectionList &RelSections);
 
   // Helper function for writeDataSection. Writes a data section of type
   // SectionType, given the global variables Vars belonging to that SectionType.
   void writeDataOfType(SectionType SectionType,
                        const VariableDeclarationList &Vars,
-                       FixupKind RelocationKind);
+                       FixupKind RelocationKind,
+                       const IceString &SectionSuffix);
 
   // Write the final relocation sections given the final symbol table.
   // May also be able to seek around the file and resolve function calls
   // that are for functions within the same section.
   void writeAllRelocationSections();
   void writeRelocationSections(RelSectionList &RelSections);
 
   // Write the ELF file header with the given information about sections.
   template <bool IsELF64>
   void writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                               SizeT SectHeaderStrIndex, SizeT NumSections);
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFOBJECTWRITER_H