Subzero. Uses fixups to calculate addend to relocations.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 199 matching lines @@
   Elf64_Off OffsetInFile = Str.tell();
   Elf64_Xword AlignDiff = Utils::OffsetToAlignment(OffsetInFile, Align);
   if (AlignDiff == 0)
     return OffsetInFile;
   Str.writeZeroPadding(AlignDiff);
   OffsetInFile += AlignDiff;
   return OffsetInFile;
 }
 
 void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
-                                        bool IsInternal, const Assembler *Asm) {
+                                        bool IsInternal, Assembler *Asm) {
   assert(!SectionNumbersAssigned);
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
   const bool FunctionSections = Ctx.getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
     IceString SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
     constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     const Elf64_Xword ShAlign = 1 << Asm->getBundleAlignLog2Bytes();
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
     RelSection = RelTextSections[0];
   }
   const 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.
   constexpr SizeT SymbolSize = 0;
-  Section->appendData(Str, Asm->getBufferView());
   uint8_t SymbolType;
   uint8_t SymbolBinding;
   if (IsInternal && !Ctx.getFlags().getDisableInternal()) {
     SymbolType = STT_NOTYPE;
     SymbolBinding = STB_LOCAL;
   } else {
     SymbolType = STT_FUNC;
     SymbolBinding = STB_GLOBAL;
   }
   SymTab->createDefinedSym(FuncName, SymbolType, SymbolBinding, Section,
                            OffsetInSection, SymbolSize);
   StrTab->add(FuncName);
 
   // Copy the fixup information from per-function Assembler memory to the
   // object writer's memory, for writing later.
-  if (!Asm->fixups().empty()) {
+  const auto &Fixups = Asm->fixups();
+  if (!Fixups.empty()) {
+    if (!RelSection->isRela()) {
+      // This is a non-rela section, so we need to update the instruction stream
+      // with the relocation addends.
+      for (const auto *Fixup : Fixups) {

[Jim Stichnoth, 2016/02/03 23:18:27]

const AssemblerFixup *Fixup

[John, 2016/02/04 18:28:50]

Discussed offline. Leaving as is.

+        Fixup->emitOffset(Asm);
+      }
+    }
     RelSection->addRelocations(OffsetInSection, Asm->fixups());
   }
+  Section->appendData(Str, Asm->getBufferView());
 }
 
 namespace {
 
 ELFObjectWriter::SectionType
 classifyGlobalSection(const VariableDeclaration *Var) {
   if (Var->getIsConstant())
     return ELFObjectWriter::ROData;
   if (Var->hasNonzeroInitializer())
     return ELFObjectWriter::Data;
@@ skipping 405 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice