Subzero: Start writing out some relocation sections (text)

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 "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 83 matching lines @@
                                                  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()));
     AllSections.push_back(UserSection);
     if (RelIt != RelE) {
-      ELFRelocationSectionBase *RelSection = *RelIt;
+      ELFRelocationSection *RelSection = *RelIt;
       if (RelSection->getRelatedSection() == UserSection) {
         RelSection->setInfoNum(UserSection->getNumber());
         RelSection->setNumber(CurSectionNumber++);
         RelSection->setNameStrIndex(ShStrTab->getIndex(RelSection->getName()));
         AllSections.push_back(RelSection);
         ++RelIt;
       }
     }
   }
   // Should finish with UserIt at the same time as RelIt.
   assert(RelIt == RelE);
   return;
 }
 
 void ELFObjectWriter::assignRelLinkNum(SizeT SymTabNumber,
                                        RelSectionList &RelSections) {
-  for (ELFRelocationSectionBase *S : RelSections) {
+  for (ELFRelocationSection *S : RelSections) {
     S->setLinkNum(SymTabNumber);
   }
 }
 
 void ELFObjectWriter::assignSectionNumbersInfo(SectionList &AllSections) {
   // Go through each section, assigning them section numbers and
   // and fill in the size for sections that aren't incrementally updated.
   assert(!SectionNumbersAssigned);
   SizeT CurSectionNumber = 0;
   NullSection->setNumber(CurSectionNumber++);
@@ skipping 35 matching lines @@
   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 llvm::StringRef Data) {
+                                        bool IsInternal, const Assembler *Asm) {
   assert(!SectionNumbersAssigned);
+  ELFTextSection *Section = nullptr;
   // TODO(jvoung): handle ffunction-sections.
   IceString SectionName = ".text";
-  ELFTextSection *Section = nullptr;
   if (TextSections.size() == 0) {
     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);
   } else {
     Section = TextSections[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, Data);
+  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) {
   assert(!SectionNumbersAssigned);
   (void)Data;
   llvm_unreachable("TODO");
   StrTab->add(VarName);
 }
 
@@ skipping 105 matching lines @@
 
 // Instantiate known needed versions of the template, since we are
 // defining the function in the .cpp file instead of the .h file.
 // 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);
+}
+
+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);
+    } else {
+      RelSec->writeData<false>(Ctx, Str, SymTab);
+    }
+  }
+}
+
 void ELFObjectWriter::writeNonUserSections() {
   bool IsELF64 = isELF64(Ctx.getTargetArch());
 
   // Write out the shstrtab now that all sections are known.
   ShStrTab->doLayout();
   ShStrTab->setSize(ShStrTab->getSectionDataSize());
   Elf64_Off ShStrTabOffset = alignFileOffset(ShStrTab->getSectionAlign());
   ShStrTab->setFileOffset(ShStrTabOffset);
   Str.writeBytes(ShStrTab->getSectionData());
 
   SectionList AllSections;
   assignSectionNumbersInfo(AllSections);
 
   // Finalize the regular StrTab and fix up references in the SymTab.
   StrTab->doLayout();
   StrTab->setSize(StrTab->getSectionDataSize());
 
   SymTab->updateIndices(StrTab);
 
   Elf64_Off SymTabOffset = alignFileOffset(SymTab->getSectionAlign());
   SymTab->setFileOffset(SymTabOffset);
   SymTab->setSize(SymTab->getSectionDataSize());
   SymTab->writeData(Str, IsELF64);
 
   Elf64_Off StrTabOffset = alignFileOffset(StrTab->getSectionAlign());
   StrTab->setFileOffset(StrTabOffset);
   Str.writeBytes(StrTab->getSectionData());
 
-  // TODO: Write out the relocation sections.
-  // May also be able to seek around the file and resolve function calls
-  // that are for functions within the same section.
+  writeAllRelocationSections(IsELF64);
 
   // Write out the section headers.
   const size_t ShdrAlign = IsELF64 ? 8 : 4;
   Elf64_Off ShOffset = alignFileOffset(ShdrAlign);
   for (const auto S : AllSections) {
     if (IsELF64)
       S->writeHeader<true>(Str);
     else
       S->writeHeader<false>(Str);
   }
 
   // Finally write the updated ELF header w/ the correct number of sections.
   Str.seek(0);
   if (IsELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice