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

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the writer for ELF relocatable object files.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Support/MathExtras.h"
+
 #include "assembler.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceELFSection.h"
 #include "IceELFStreamer.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 
 using namespace llvm::ELF;
@@ skipping 72 matching lines @@
 T *ELFObjectWriter::createSection(const IceString &Name, Elf64_Word ShType,
                                   Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
                                   Elf64_Xword ShEntsize) {
   assert(!SectionNumbersAssigned);
   T *NewSection =
       new (Ctx.allocate<T>()) T(Name, ShType, ShFlags, ShAddralign, ShEntsize);
   ShStrTab->add(Name);
   return NewSection;
 }
 
+ELFRelocationSection *
+ELFObjectWriter::createRelocationSection(bool IsELF64,
+                                         const ELFSection *RelatedSection) {
+  // Choice of RELA vs REL is actually separate from elf64 vs elf32,
+  // but in practice we've only had .rela for elf64 (x86-64).
+  // In the future, the two properties may need to be decoupled
+  // and the ShEntSize can vary more.
+  const Elf64_Word ShType = IsELF64 ? SHT_RELA : SHT_REL;
+  IceString RelPrefix = IsELF64 ? ".rela" : ".rel";
+  IceString RelSectionName = RelPrefix + RelatedSection->getName();
+  const Elf64_Xword ShAlign = IsELF64 ? 8 : 4;
+  const Elf64_Xword ShEntSize =
+      IsELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
+  static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
+                "Elf_Rel/Rela sizes cannot be derived from sizeof");
+  const Elf64_Xword ShFlags = 0;
+  ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
+      RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
+  RelSection->setRelatedSection(RelatedSection);
+  return RelSection;
+}
+
 template <typename UserSectionList>
 void ELFObjectWriter::assignRelSectionNumInPairs(SizeT &CurSectionNumber,
                                                  UserSectionList &UserSections,
                                                  RelSectionList &RelSections,
                                                  SectionList &AllSections) {
   RelSectionList::iterator RelIt = RelSections.begin();
   RelSectionList::iterator RelE = RelSections.end();
   for (ELFSection *UserSection : UserSections) {
     UserSection->setNumber(CurSectionNumber++);
     UserSection->setNameStrIndex(ShStrTab->getIndex(UserSection->getName()));
@@ skipping 27 matching lines @@
   assert(!SectionNumbersAssigned);
   SizeT CurSectionNumber = 0;
   NullSection->setNumber(CurSectionNumber++);
   // The rest of the fields are initialized to 0, and stay that way.
   AllSections.push_back(NullSection);
 
   assignRelSectionNumInPairs<TextSectionList>(CurSectionNumber, TextSections,
                                               RelTextSections, AllSections);
   assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, DataSections,
                                               RelDataSections, AllSections);
-  assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, RoDataSections,
-                                              RelRoDataSections, AllSections);
+  for (ELFSection *BSSSection : BSSSections) {
+    BSSSection->setNumber(CurSectionNumber++);
+    BSSSection->setNameStrIndex(ShStrTab->getIndex(BSSSection->getName()));
+    AllSections.push_back(BSSSection);
+  }
+  assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, RODataSections,
+                                              RelRODataSections, AllSections);
 
   ShStrTab->setNumber(CurSectionNumber++);
   ShStrTab->setNameStrIndex(ShStrTab->getIndex(ShStrTab->getName()));
   AllSections.push_back(ShStrTab);
 
   SymTab->setNumber(CurSectionNumber++);
   SymTab->setNameStrIndex(ShStrTab->getIndex(SymTab->getName()));
   AllSections.push_back(SymTab);
 
   StrTab->setNumber(CurSectionNumber++);
   StrTab->setNameStrIndex(ShStrTab->getIndex(StrTab->getName()));
   AllSections.push_back(StrTab);
 
   SymTab->setLinkNum(StrTab->getNumber());
   SymTab->setInfoNum(SymTab->getNumLocals());
 
   assignRelLinkNum(SymTab->getNumber(), RelTextSections);
   assignRelLinkNum(SymTab->getNumber(), RelDataSections);
-  assignRelLinkNum(SymTab->getNumber(), RelRoDataSections);
+  assignRelLinkNum(SymTab->getNumber(), RelRODataSections);
   SectionNumbersAssigned = true;
 }
 
 Elf64_Off ELFObjectWriter::alignFileOffset(Elf64_Xword Align) {
-  assert(llvm::isPowerOf2_32(Align));
   Elf64_Off OffsetInFile = Str.tell();
-  Elf64_Xword Mod = OffsetInFile & (Align - 1);
-  if (Mod == 0)
+  Elf64_Xword AlignDiff = Utils::OffsetToAlignment(OffsetInFile, Align);
+  if (AlignDiff == 0)
     return OffsetInFile;
-  Elf64_Xword AlignDiff = Align - Mod;
   Str.writeZeroPadding(AlignDiff);
   OffsetInFile += AlignDiff;
-  assert((OffsetInFile & (Align - 1)) == 0);
   return OffsetInFile;
 }
 
 void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
                                         bool IsInternal, const Assembler *Asm) {
   assert(!SectionNumbersAssigned);
   ELFTextSection *Section = nullptr;
-  // TODO(jvoung): handle ffunction-sections.
-  IceString SectionName = ".text";
-  if (TextSections.size() == 0) {
+  ELFRelocationSection *RelSection = nullptr;
+  if (TextSections.empty()) {
+    // TODO(jvoung): handle ffunction-sections.
+    IceString SectionName = ".text";
+    bool IsELF64 = isELF64(Ctx.getTargetArch());
     const Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     // TODO(jvoung): Should be bundle size. Grab it from that target?
     const Elf64_Xword ShAlign = 32;
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
+    RelSection = createRelocationSection(IsELF64, Section);
+    RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
+    RelSection = RelTextSections[0];
   }
   RelocOffsetT OffsetInSection = Section->getCurrentSize();
   // Function symbols are set to 0 size in the symbol table,
   // in contrast to data symbols which have a proper size.
   SizeT SymbolSize = 0;
   Section->appendData(Str, Asm->getBufferView());
   uint8_t SymbolType;
   uint8_t SymbolBinding;
   if (IsInternal) {
     SymbolType = STT_NOTYPE;
     SymbolBinding = STB_LOCAL;
   } else {
     SymbolType = STT_FUNC;
     SymbolBinding = STB_GLOBAL;
   }
   SymTab->createDefinedSym(FuncName, SymbolType, SymbolBinding, Section,
                            OffsetInSection, SymbolSize);
   StrTab->add(FuncName);
 
   // Create a relocation section for the text section if needed, and copy the
   // fixup information from per-function Assembler memory to the object
   // writer's memory, for writing later.
   if (!Asm->fixups().empty()) {
-    bool IsELF64 = isELF64(Ctx.getTargetArch());
-    IceString RelSectionName = IsELF64 ? ".rela" : ".rel";
-    RelSectionName += SectionName;
-    ELFRelocationSection *RelSection = nullptr;
-    // TODO(jvoung): Make this more efficient if -ffunction-sections
-    // efficiency becomes a problem.
-    auto RSI =
-        std::find_if(RelTextSections.begin(), RelTextSections.end(),
-                     [&RelSectionName](const ELFRelocationSection *S)
-                         -> bool { return S->getName() == RelSectionName; });
-    if (RSI != RelTextSections.end()) {
-      RelSection = *RSI;
-    } else {
-      const Elf64_Word ShType = IsELF64 ? SHT_RELA : SHT_REL;
-      const Elf64_Xword ShAlign = IsELF64 ? 8 : 4;
-      const Elf64_Xword ShEntSize =
-          IsELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
-      static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
-                    "Elf_Rel/Rela sizes cannot be derived from sizeof");
-      const Elf64_Xword ShFlags = 0;
-      RelSection = createSection<ELFRelocationSection>(
-          RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
-      RelSection->setRelatedSection(Section);
-      RelTextSections.push_back(RelSection);
-    }
     RelSection->addRelocations(OffsetInSection, Asm->fixups());
   }
 }
 
-void ELFObjectWriter::writeDataInitializer(const IceString &VarName,
-                                           const llvm::StringRef Data) {
+namespace {
+
+ELFObjectWriter::SectionType
+classifyGlobalSection(const VariableDeclaration *Var) {
+  if (Var->getIsConstant())
+    return ELFObjectWriter::ROData;
+  if (Var->hasNonzeroInitializer())
+    return ELFObjectWriter::Data;
+  return ELFObjectWriter::BSS;
+}
+
+// Partition the Vars list by SectionType into VarsBySection.
+// If TranslateOnly is non-empty, then only the TranslateOnly variable
+// is kept for emission.
+void partitionGlobalsBySection(const VariableDeclarationList &Vars,
+                               VariableDeclarationList VarsBySection[],
+                               const IceString &TranslateOnly) {
+  for (VariableDeclaration *Var : Vars) {
+    if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+      size_t Section = classifyGlobalSection(Var);
+      assert(Section < ELFObjectWriter::SectionType::NumSectionTypes);
+      VarsBySection[Section].push_back(Var);
+    }
+  }
+}
+
+} // end of anonymous namespace
+
+void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
+                                       FixupKind RelocationKind) {
   assert(!SectionNumbersAssigned);
-  (void)Data;
-  llvm_unreachable("TODO");
-  StrTab->add(VarName);
+  VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
+  for (auto &SectionList : VarsBySection)
+    SectionList.reserve(Vars.size());
+  partitionGlobalsBySection(Vars, VarsBySection, Ctx.getFlags().TranslateOnly);
+  bool IsELF64 = isELF64(Ctx.getTargetArch());
+  for (size_t I = ELFObjectWriter::BaseSectionType;

[Jim Stichnoth, 2015/01/28 20:35:08]

Consider doing something like this to make the second pass through the array
look more similar to the first pass:

SectionType I = 0;
for (auto &SectionList : VarsBySection)
  writeDataOfType(I++, SectionList, RelocationKind, IsELF64);

[jvoung (off chromium), 2015/01/28 23:37:52]

Done sort of -- If I is type SectionType, then I++ gives:

cannot increment expression of enum type

[Jim Stichnoth, 2015/01/29 00:38:14]

BTW, JF pointed out this would be possible using an enum *class*, with the
drawback that you don't get the enum values directly injected into the parent
namespace.

+       I < ELFObjectWriter::NumSectionTypes; ++I) {
+    writeDataOfType(static_cast<SectionType>(I), VarsBySection[I],
+                    RelocationKind, IsELF64);
+  }
+}
+
+void ELFObjectWriter::writeDataOfType(SectionType SectionType,
+                                      const VariableDeclarationList &Vars,
+                                      FixupKind RelocationKind, bool IsELF64) {
+  ELFDataSection *Section;
+  ELFRelocationSection *RelSection;
+  // TODO(jvoung): Handle fdata-sections.
+  IceString SectionName;
+  Elf64_Xword ShAddralign = 0;
+  for (auto *Var : Vars) {

[Jim Stichnoth, 2015/01/28 20:35:08]

auto --> VariableDeclaration

[jvoung (off chromium), 2015/01/28 23:37:53]

Done.

+    Elf64_Xword Align = Var->getAlignment();
+    ShAddralign = std::max(ShAddralign, Align);
+  }
+  const Elf64_Xword ShEntsize = 0; // non-uniform data element size.
+  // Lift this out, so it can be re-used if we do fdata-sections?
+  switch (SectionType) {
+  case SectionType::ROData: {
+    SectionName = ".rodata";
+    // Only expecting to write the data sections all in one shot for now.
+    assert(RODataSections.empty());
+    const Elf64_Xword ShFlags = SHF_ALLOC;
+    Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
+                                            ShAddralign, ShEntsize);
+    Section->setFileOffset(alignFileOffset(ShAddralign));
+    RODataSections.push_back(Section);
+    RelSection = createRelocationSection(IsELF64, Section);
+    RelRODataSections.push_back(RelSection);
+    break;
+  }
+  case SectionType::Data: {
+    SectionName = ".data";
+    assert(DataSections.empty());
+    const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+    Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
+                                            ShAddralign, ShEntsize);
+    Section->setFileOffset(alignFileOffset(ShAddralign));
+    DataSections.push_back(Section);
+    RelSection = createRelocationSection(IsELF64, Section);
+    RelDataSections.push_back(RelSection);
+    break;
+  }
+  case SectionType::BSS: {
+    SectionName = ".bss";
+    assert(BSSSections.empty());
+    const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+    Section = createSection<ELFDataSection>(SectionName, SHT_NOBITS, ShFlags,
+                                            ShAddralign, ShEntsize);
+    Section->setFileOffset(alignFileOffset(ShAddralign));
+    BSSSections.push_back(Section);
+    break;
+  }
+  case SectionType::NumSectionTypes:
+    llvm::report_fatal_error("Unknown SectionType");
+    break;
+  }
+
+  const uint8_t SymbolType = STT_OBJECT;
+  for (auto *Var : Vars) {

[Jim Stichnoth, 2015/01/28 20:35:08]

auto --> VariableDeclaration

[jvoung (off chromium), 2015/01/28 23:37:53]

Done.

+    Elf64_Xword Align = Var->getAlignment();
+    Section->padToAlignment(Str, Align);
+    SizeT SymbolSize = Var->getNumBytes();
+    bool IsExternal = Var->isExternal() || Ctx.getFlags().DisableInternal;
+    const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
+    IceString MangledName = Var->mangleName(&Ctx);
+    SymTab->createDefinedSym(MangledName, SymbolType, SymbolBinding, Section,
+                             Section->getCurrentSize(), SymbolSize);
+    StrTab->add(MangledName);
+    if (!Var->hasNonzeroInitializer()) {
+      assert(SectionType == SectionType::BSS ||
+             SectionType == SectionType::ROData);
+      if (SectionType == SectionType::ROData)
+        Section->appendZeros(Str, SymbolSize);
+      else
+        Section->setSize(Section->getCurrentSize() + SymbolSize);
+    } else {
+      assert(SectionType != SectionType::BSS);
+      for (VariableDeclaration::Initializer *Init : Var->getInitializers()) {
+        switch (Init->getKind()) {
+        case VariableDeclaration::Initializer::DataInitializerKind: {
+          const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(
+                                Init)->getContents();
+          Section->appendData(Str, llvm::StringRef(Data.data(), Data.size()));
+          break;
+        }
+        case VariableDeclaration::Initializer::ZeroInitializerKind:
+          Section->appendZeros(Str, Init->getNumBytes());
+          break;
+        case VariableDeclaration::Initializer::RelocInitializerKind: {
+          const auto Reloc =
+              llvm::cast<VariableDeclaration::RelocInitializer>(Init);
+          AssemblerFixup NewFixup;
+          NewFixup.set_position(Section->getCurrentSize());
+          NewFixup.set_kind(RelocationKind);
+          const bool SuppressMangling = true;
+          NewFixup.set_value(Ctx.getConstantSym(
+              Reloc->getOffset(), Reloc->getDeclaration()->mangleName(&Ctx),
+              SuppressMangling));
+          RelSection->addRelocation(NewFixup);
+          Section->appendRelocationOffset(Str, RelSection->isRela(),
+                                          Reloc->getOffset());
+          break;
+        }
+        }
+      }
+    }
+  }
 }
 
 void ELFObjectWriter::writeInitialELFHeader() {
   assert(!SectionNumbersAssigned);
   const Elf64_Off DummySHOffset = 0;
   const SizeT DummySHStrIndex = 0;
   const SizeT DummyNumSections = 0;
   if (isELF64(Ctx.getTargetArch())) {
     writeELFHeaderInternal<true>(DummySHOffset, DummySHStrIndex,
                                  DummyNumSections);
@@ skipping 63 matching lines @@
   // between entries.
   assert(WriteAmt % Align == 0);
   // Check that we write the full PrimType.
   assert(WriteAmt == sizeof(typename ConstType::PrimType));
   const Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
   std::string SecBuffer;
   llvm::raw_string_ostream SecStrBuf(SecBuffer);
   SecStrBuf << ".rodata.cst" << WriteAmt;
   ELFDataSection *Section = createSection<ELFDataSection>(
       SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
-  RoDataSections.push_back(Section);
+  RODataSections.push_back(Section);
   SizeT OffsetInSection = 0;
   // The symbol table entry doesn't need to know the defined symbol's
   // size since this is in a section with a fixed Entry Size.
   const SizeT SymbolSize = 0;
   Section->setFileOffset(alignFileOffset(Align));
 
   // Write the data.
   for (Constant *C : Pool) {
     auto Const = llvm::cast<ConstType>(C);
     std::string SymBuffer;
@@ skipping 16 matching lines @@
 // We may need to instantiate constant pools for integers as well
 // if we do constant-pooling of large integers to remove them
 // from the instruction stream (fewer bytes controlled by an attacker).
 template void ELFObjectWriter::writeConstantPool<ConstantFloat>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantDouble>(Type Ty);
 
 void ELFObjectWriter::writeAllRelocationSections(bool IsELF64) {
   writeRelocationSections(IsELF64, RelTextSections);
   writeRelocationSections(IsELF64, RelDataSections);
-  writeRelocationSections(IsELF64, RelRoDataSections);
+  writeRelocationSections(IsELF64, RelRODataSections);
 }
 
 void ELFObjectWriter::writeRelocationSections(bool IsELF64,
                                               RelSectionList &RelSections) {
   for (ELFRelocationSection *RelSec : RelSections) {
     Elf64_Off Offset = alignFileOffset(RelSec->getSectionAlign());
     RelSec->setFileOffset(Offset);
     RelSec->setSize(RelSec->getSectionDataSize(Ctx, SymTab));
     if (IsELF64) {
       RelSec->writeData<true>(Ctx, Str, SymTab);
@@ skipping 48 matching lines @@
   if (IsELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice