Subzero: Start writing out some relocation sections (text)

src/IceELFObjectWriter.h

 //===- subzero/src/IceELFObjectWriter.h - ELF object writer -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Abstraction for a writer that is responsible for writing an ELF file.
@@ skipping 29 matching lines @@
 public:
   ELFObjectWriter(GlobalContext &Ctx, ELFStreamer &Out);
 
   // Write the initial ELF header. This is just to reserve space in the ELF
   // file. Reserving space allows the other functions to write text
   // and data directly to the file and get the right file offsets.
   void writeInitialELFHeader();
 
   // Copy data of a function's text section to file and note the offset of the
   // symbol's definition in the symbol table.
-  // TODO(jvoung): This also needs the relocations to adjust the
-  // section-relative offsets and hook them up to the symbol table references.
+  // Copy the text fixups for use after all functions are written.
   void writeFunctionCode(const IceString &FuncName, bool IsInternal,
-                         const llvm::StringRef Data);
+                         const Assembler *Asm);
 
   // Copy initializer data for a global to file and note the offset and
   // size of the global's definition in the symbol table.
   // TODO(jvoung): This needs to know which section. This also needs the
   // relocations to hook them up to the symbol table references. Also
   // TODO is handling BSS (which just needs to note the size).
   void writeDataInitializer(const IceString &VarName,
                             const llvm::StringRef Data);
 
   template <typename ConstType> void writeConstantPool(Type Ty);
 
   // Do final layout and write out the rest of the object file, then
   // patch up the initial ELF header with the final info.
   void writeNonUserSections();
 
 private:
   GlobalContext &Ctx;
   ELFStreamer &Str;
   bool SectionNumbersAssigned;
 
   // All created sections, separated into different pools.
   typedef std::vector<ELFSection *> SectionList;
   typedef std::vector<ELFTextSection *> TextSectionList;
   typedef std::vector<ELFDataSection *> DataSectionList;
-  typedef std::vector<ELFRelocationSectionBase *> RelSectionList;
+  typedef std::vector<ELFRelocationSection *> RelSectionList;
   TextSectionList TextSections;
   RelSectionList RelTextSections;
   DataSectionList DataSections;
   RelSectionList RelDataSections;
   DataSectionList RoDataSections;
   RelSectionList RelRoDataSections;
 
   // Handles to special sections that need incremental bookkeeping.
   ELFSection *NullSection;
   ELFStringTableSection *ShStrTab;
@@ skipping 21 matching lines @@
   // section's number.
   template <typename UserSectionList>
   void assignRelSectionNumInPairs(SizeT &CurSectionNumber,
                                   UserSectionList &UserSections,
                                   RelSectionList &RelSections,
                                   SectionList &AllSections);
 
   // Link the relocation sections to the symbol table.
   void assignRelLinkNum(SizeT SymTabNumber, RelSectionList &RelSections);
 
+  // Write the final relocation sections given the final symbol table.
+  // May also be able to seek around the file and resolve function calls
+  // that are for functions within the same section.
+  void writeAllRelocationSections(bool IsELF64);
+  void writeRelocationSections(bool IsELF64, RelSectionList &RelSections);
+
   // Write the ELF file header with the given information about sections.
   template <bool IsELF64>
   void writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                               SizeT SectHeaderStrIndex, SizeT NumSections);
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFOBJECTWRITER_H