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

src/IceELFSection.cpp

 //===- subzero/src/IceELFSection.cpp - Representation of ELF sections -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines how ELF sections are represented.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/MathExtras.h"
+
 #include "IceDefs.h"
 #include "IceELFSection.h"
 #include "IceELFStreamer.h"
 
 using namespace llvm::ELF;
 
 namespace Ice {
 
 // Text sections.
 
 void ELFTextSection::appendData(ELFStreamer &Str,
                                 const llvm::StringRef MoreData) {
   Str.writeBytes(MoreData);
   Header.sh_size += MoreData.size();
 }
 
 // Data sections.
 
 void ELFDataSection::appendData(ELFStreamer &Str,
                                 const llvm::StringRef MoreData) {
   Str.writeBytes(MoreData);
   Header.sh_size += MoreData.size();
 }
 
+void ELFDataSection::appendZeros(ELFStreamer &Str, SizeT NumBytes) {
+  Str.writeZeroPadding(NumBytes);
+  Header.sh_size += NumBytes;
+}
+
+void ELFDataSection::appendRelocationOffset(ELFStreamer &Str, bool IsRela,
+                                            RelocOffsetT RelocOffset) {
+  if (IsRela) {
+    appendZeros(Str, RelocAddrSize);
+    return;
+  }
+  static_assert(RelocAddrSize == 4, " writeLE32 assumes RelocAddrSize is 4");
+  Str.writeLE32(RelocOffset);
+  Header.sh_size += RelocAddrSize;
+}
+
+void ELFDataSection::padToAlignment(ELFStreamer &Str, Elf64_Xword Align) {
+  assert(llvm::isPowerOf2_32(Align));
+  Elf64_Xword AlignDiff = Utils::OffsetToAlignment(Header.sh_size, Align);
+  if (AlignDiff == 0)
+    return;
+  if (Header.sh_type != llvm::ELF::SHT_NOBITS)
+    Str.writeZeroPadding(AlignDiff);
+  Header.sh_size += AlignDiff;
+}
+
 // Relocation sections.
 
 void ELFRelocationSection::addRelocations(RelocOffsetT BaseOff,
                                           const FixupRefList &FixupRefs) {
   for (const AssemblerFixup *FR : FixupRefs) {
     Fixups.push_back(*FR);
     AssemblerFixup &F = Fixups.back();
     F.set_position(BaseOff + F.position());
   }
 }
@@ skipping 18 matching lines @@
                                              uint8_t Type, uint8_t Binding,
                                              ELFSection *Section,
                                              RelocOffsetT Offset, SizeT Size) {
   ELFSym NewSymbol = ELFSym();
   NewSymbol.Sym.setBindingAndType(Binding, Type);
   NewSymbol.Sym.st_value = Offset;
   NewSymbol.Sym.st_size = Size;
   NewSymbol.Section = Section;
   NewSymbol.Number = ELFSym::UnknownNumber;
   bool Unique;
-  if (Type == STB_LOCAL)
+  if (Binding == STB_LOCAL)
     Unique = LocalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
   else
     Unique = GlobalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
   assert(Unique);
   (void)Unique;
 }
 
 void ELFSymbolTableSection::noteUndefinedSym(const IceString &Name,
                                              ELFSection *NullSection) {
   ELFSym NewSymbol = ELFSym();
@@ skipping 97 matching lines @@
       continue;
     }
     StringIndex.second = StringData.size();
     std::copy(Cur.begin(), Cur.end(), back_inserter(StringData));
     StringData.push_back(0);
     Prev = Cur;
   }
 }
 
 } // end of namespace Ice