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 46 matching lines @@
     Number = N;
   }
   SizeT getNumber() const {
     assert(Number != NoSectionNumber);
     return Number;
   }
 
   void setSize(Elf64_Xword sh_size) { Header.sh_size = sh_size; }
   SizeT getCurrentSize() const { return Header.sh_size; }
 
+  void setAlignment(Elf64_Xword sh_addralign) {
+    Header.sh_addralign = sh_addralign;
+  }
+
   void setNameStrIndex(Elf64_Word sh_name) { Header.sh_name = sh_name; }
 
   IceString getName() const { return Name; }
 
   void setLinkNum(Elf64_Word sh_link) { Header.sh_link = sh_link; }
 
   void setInfoNum(Elf64_Word sh_info) { Header.sh_info = sh_info; }
 
   void setFileOffset(Elf64_Off sh_offset) { Header.sh_offset = sh_offset; }
 
   Elf64_Xword getSectionAlign() const { return Header.sh_addralign; }
 
   // Write the section header out with the given streamer.
   template <bool IsELF64> void writeHeader(ELFStreamer &Str);
 
+  void padToAlignment(ELFStreamer &Str, bool WritePadding, Elf64_Xword Align);
+
 protected:
   ~ELFSection() {}
 
   // Name of the section in convenient string form (instead of a index
   // into the Section Header String Table, which is not known till later).
   IceString Name;
 
   // The fields of the header. May only be partially initialized, but should
   // be fully initialized before writing.
   Elf64_Shdr Header;
@@ skipping 18 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);
 };
 
 // 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