Subzero: Assemble calls to constant addresses.

src/IceELFSection.h

 //===- subzero/src/IceELFSection.h - Model of ELF sections ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Representation of ELF sections.
@@ skipping 145 matching lines @@
 };
 
 // Models a symbol table. Symbols may be added up until updateIndices is
 // called. At that point the indices of each symbol will be finalized.
 class ELFSymbolTableSection : public ELFSection {
   ELFSymbolTableSection() = delete;
   ELFSymbolTableSection(const ELFSymbolTableSection &) = delete;
   ELFSymbolTableSection &operator=(const ELFSymbolTableSection &) = delete;
 
 public:
-  using ELFSection::ELFSection;
+  ELFSymbolTableSection(const IceString &Name, Elf64_Word ShType,
+                        Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
+                        Elf64_Xword ShEntsize)
+      : ELFSection(Name, ShType, ShFlags, ShAddralign, ShEntsize),
+        NullSymbol(nullptr) {}
 
   // Create initial entry for a symbol when it is defined.
   // Each entry should only be defined once.
   // We might want to allow Name to be a dummy name initially, then
   // get updated to the real thing, since Data initializers are read
   // before the bitcode's symbol table is read.
   void createDefinedSym(const IceString &Name, uint8_t Type, uint8_t Binding,
                         ELFSection *Section, RelocOffsetT Offset, SizeT Size);
 
   // Note that a symbol table entry needs to be created for the given
   // symbol because it is undefined.
   void noteUndefinedSym(const IceString &Name, ELFSection *NullSection);
 
   const ELFSym *findSymbol(const IceString &Name) const;
 
+  void createNullSymbol(ELFSection *NullSection);
+  const ELFSym *getNullSymbol() const { return NullSymbol; }
+
   size_t getSectionDataSize() const {
     return (LocalSymbols.size() + GlobalSymbols.size()) * Header.sh_entsize;
   }
 
   size_t getNumLocals() const { return LocalSymbols.size(); }
 
   void updateIndices(const ELFStringTableSection *StrTab);
 
   void writeData(ELFStreamer &Str, bool IsELF64);
 
 private:
   // Map from symbol name to its symbol information.
   // This assumes symbols are unique across all sections.
   typedef IceString SymtabKey;
   typedef std::map<SymtabKey, ELFSym> SymMap;
 
   template <bool IsELF64>
   void writeSymbolMap(ELFStreamer &Str, const SymMap &Map);
 
+  const ELFSym *NullSymbol;
   // Keep Local and Global symbols separate, since the sh_info needs to
   // know the index of the last LOCAL.
   SymMap LocalSymbols;
   SymMap GlobalSymbols;
 };
 
 // Models a relocation section.
 class ELFRelocationSection : public ELFSection {
   ELFRelocationSection() = delete;
   ELFRelocationSection(const ELFRelocationSection &) = delete;
   ELFRelocationSection &operator=(const ELFRelocationSection &) = delete;
 
 public:
-  using ELFSection::ELFSection;
+  ELFRelocationSection(const IceString &Name, Elf64_Word ShType,
+                       Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
+                       Elf64_Xword ShEntsize)
+      : ELFSection(Name, ShType, ShFlags, ShAddralign, ShEntsize),
+        RelatedSection(nullptr) {}
 
   const ELFSection *getRelatedSection() const { return RelatedSection; }
   void setRelatedSection(const ELFSection *Section) {
     RelatedSection = Section;
   }
 
   // Track additional relocations which start out relative to offset 0,
   // but should be adjusted to be relative to BaseOff.
   void addRelocations(RelocOffsetT BaseOff, const FixupRefList &FixupRefs);
 
@@ skipping 108 matching lines @@
       Str.write8(SymInfo.st_other);
       Str.writeLE16(SymInfo.st_shndx);
     }
   }
 }
 
 template <bool IsELF64>
 void ELFRelocationSection::writeData(const GlobalContext &Ctx, ELFStreamer &Str,
                                      const ELFSymbolTableSection *SymTab) {
   for (const AssemblerFixup &Fixup : Fixups) {
-    const ELFSym *Symbol = SymTab->findSymbol(Fixup.symbol(&Ctx));
+    const ELFSym *Symbol;
+    if (Fixup.isNullSymbol())
+      Symbol = SymTab->getNullSymbol();
+    else
+      Symbol = SymTab->findSymbol(Fixup.symbol(&Ctx));
     if (!Symbol)
       llvm::report_fatal_error("Missing symbol mentioned in reloc");
 
     if (IsELF64) {
       Elf64_Rela Rela;
       Rela.r_offset = Fixup.position();
       Rela.setSymbolAndType(Symbol->getNumber(), Fixup.kind());
       Rela.r_addend = Fixup.offset();
       Str.writeAddrOrOffset<IsELF64>(Rela.r_offset);
       Str.writeELFXword<IsELF64>(Rela.r_info);
       Str.writeELFXword<IsELF64>(Rela.r_addend);
     } else {
       Elf32_Rel Rel;
       Rel.r_offset = Fixup.position();
       Rel.setSymbolAndType(Symbol->getNumber(), Fixup.kind());
       Str.writeAddrOrOffset<IsELF64>(Rel.r_offset);
       Str.writeELFWord<IsELF64>(Rel.r_info);
     }
   }
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFSECTION_H