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)
     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;
+  ELFRelocationSection *RelSection = nullptr;
   // TODO(jvoung): handle ffunction-sections.
   IceString SectionName = ".text";
-  if (TextSections.size() == 0) {
+  bool IsELF64 = isELF64(Ctx.getTargetArch());

[Jim Stichnoth, 2015/01/27 16:44:55]

Move this into the if() block?  Maybe SectionName as well, thanks to the
refactoring?

[jvoung (off chromium), 2015/01/28 17:46:22]

Done.

+  if (TextSections.empty()) {
     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;
+}
+
+// TODO(jvoung): dedupe, use the GlobalContext version

[Jim Stichnoth, 2015/01/27 16:44:55]

Should be possible now. :)

[jvoung (off chromium), 2015/01/28 17:46:22]

Sweet -- Done.

+// https://codereview.chromium.org/870653002/diff/200001/src/IceGlobalContext.h
+bool matchSymbolName(const IceString &SymbolName, const IceString &Match) {
+  return Match.empty() || Match == SymbolName;
+}
+
+// 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 (auto Var : Vars) {

[Jim Stichnoth, 2015/01/27 16:44:55]

I think you should use VariableDeclaration *Var instead of auto Var since the
type isn't cumbersome (as opposed to something ugly like
std::unique_ptr<VariableDeclaration *>) and the type isn't immediately apparent
without digging up the definition of VariableDeclarationList.

E.g., I think the "auto &SectionList" below is reasonable.

[jvoung (off chromium), 2015/01/28 17:46:22]

Done -- still getting used to this fancy new "auto" thing =)

+    if (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");

[Jim Stichnoth, 2015/01/27 16:44:55]

Yay! :)

-  StrTab->add(VarName);
+  VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
+  for (auto &SectionList : VarsBySection)
+    SectionList.reserve(Vars.size());

[Jim Stichnoth, 2015/01/27 16:44:55]

Could you document relevant functions as to whether they are expected to be
called just once (or a small bounded number of times) during a pexe translation,
versus potentially many times due to e.g. -ffunction-sections or
-fdata-sections?

"Relevant" means functions that may result in a significant number of malloc()
calls due to containers using the default allocator.  This may lead to
scalability issues, and it's better to try fixing them at the source rather than
relying on special malloc implementations (though that may be useful as well).

[jvoung (off chromium), 2015/01/28 17:46:22]

Good point -- I've added some comments in the .h file.
Yes, I am a little worried about inefficiencies here. Need to check the timings
more...

By fixing at the source, do you mean for example, partition the
globals earlier (while parsing) rather than make a new set of vector
and then copying here?

Also, some of the maps (like the symtab and strtab) could probably be
unordered-map or vector, and then sorting happens later. Also wasn't sure about
the possiblity of copying strings around...

+  partitionGlobalsBySection(Vars, VarsBySection, Ctx.getFlags().TranslateOnly);
+  bool IsELF64 = isELF64(Ctx.getTargetArch());
+  for (size_t I = ELFObjectWriter::BaseSectionType;
+       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) {
+    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_unreachable("Unknown SectionType");

[Jim Stichnoth, 2015/01/27 16:44:55]

llvm::report_fatal_error()?

[jvoung (off chromium), 2015/01/28 17:46:22]

Done.

+    break;
+  }
+
+  const uint8_t SymbolType = STT_OBJECT;
+  for (auto *Var : Vars) {
+    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