Write out global initializers and data rel directly to ELF file.

src/IceELFSection.h

 //===- subzero/src/IceELFSection.h - Model of ELF sections ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Representation of ELF sections.
@@ skipping 99 matching lines @@
 // size of the section is then updated incrementally.
 // Some rodata sections may have fixed entsize and duplicates may be mergeable.
 class ELFDataSection : public ELFSection {
   ELFDataSection(const ELFDataSection &) = delete;
   ELFDataSection &operator=(const ELFDataSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
   void appendData(ELFStreamer &Str, const llvm::StringRef MoreData);
+
+  void appendZeros(ELFStreamer &Str, SizeT NumBytes);
+
+  void appendRelocationOffset(ELFStreamer &Str, bool IsRela,
+                              RelocOffsetT RelocOffset);
+
+  // Pad the next section offset for writing data elements to the requested
+  // alignment. If the section is NOBITS then do not actually write out
+  // the padding and only update the section size.
+  void padToAlignment(ELFStreamer &Str, Elf64_Xword Align);
 };
 
 // Model of ELF symbol table entries. Besides keeping track of the fields
 // required for an elf symbol table entry it also tracks the number that
 // represents the symbol's final index in the symbol table.
 struct ELFSym {
   Elf64_Sym Sym;
   ELFSection *Section;
   SizeT Number;
 
@@ skipping 58 matching lines @@
 };
 
 // Models a relocation section.
 class ELFRelocationSection : public ELFSection {
   ELFRelocationSection(const ELFRelocationSection &) = delete;
   ELFRelocationSection &operator=(const ELFRelocationSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
-  ELFSection *getRelatedSection() const { return RelatedSection; }
-  void setRelatedSection(ELFSection *Section) { RelatedSection = Section; }
+  const ELFSection *getRelatedSection() const { return RelatedSection; }
+  void setRelatedSection(const ELFSection *Section) {
+    RelatedSection = Section;
+  }
 
   // Track additional relocations which start out relative to offset 0,
   // but should be adjusted to be relative to BaseOff.
   void addRelocations(RelocOffsetT BaseOff, const FixupRefList &FixupRefs);
 
+  // Track a single additional relocation.
+  void addRelocation(const AssemblerFixup &Fixup) { Fixups.push_back(Fixup); }
+
   size_t getSectionDataSize(const GlobalContext &Ctx,
                             const ELFSymbolTableSection *SymTab) const;
 
   template <bool IsELF64>
   void writeData(const GlobalContext &Ctx, ELFStreamer &Str,
                  const ELFSymbolTableSection *SymTab);
 
+  bool isRela() const { return Header.sh_type == SHT_RELA; }
+
 private:
-  ELFSection *RelatedSection;
+  const ELFSection *RelatedSection;
   FixupList Fixups;
 };
 
 // Models a string table.  The user will build the string table by
 // adding strings incrementally.  At some point, all strings should be
 // known and doLayout() should be called. After that, no other
 // strings may be added.  However, the final offsets of the strings
 // can be discovered and used to fill out section headers and symbol
 // table entries.
 class ELFStringTableSection : public ELFSection {
@@ skipping 111 matching lines @@
         Str.writeAddrOrOffset<IsELF64>(Rel.r_offset);
         Str.writeELFWord<IsELF64>(Rel.r_info);
       }
     }
   }
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFSECTION_H