Home | History | Annotate | Download | only in MC 
      1 //===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements ELF object file writer information.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "llvm/MC/MCELFObjectWriter.h"
     15 #include "llvm/ADT/STLExtras.h"
     16 #include "llvm/ADT/SmallPtrSet.h"
     17 #include "llvm/ADT/SmallString.h"
     18 #include "llvm/ADT/StringMap.h"
     19 #include "llvm/MC/MCAsmBackend.h"
     20 #include "llvm/MC/MCAsmInfo.h"
     21 #include "llvm/MC/MCAsmLayout.h"
     22 #include "llvm/MC/MCAssembler.h"
     23 #include "llvm/MC/MCContext.h"
     24 #include "llvm/MC/MCExpr.h"
     25 #include "llvm/MC/MCFixupKindInfo.h"
     26 #include "llvm/MC/MCObjectWriter.h"
     27 #include "llvm/MC/MCSectionELF.h"
     28 #include "llvm/MC/MCSymbolELF.h"
     29 #include "llvm/MC/MCValue.h"
     30 #include "llvm/MC/StringTableBuilder.h"
     31 #include "llvm/Support/Compression.h"
     32 #include "llvm/Support/Debug.h"
     33 #include "llvm/Support/ELF.h"
     34 #include "llvm/Support/Endian.h"
     35 #include "llvm/Support/ErrorHandling.h"
     36 #include "llvm/Support/StringSaver.h"
     37 #include <vector>
     38 using namespace llvm;
     39 
     40 #undef  DEBUG_TYPE
     41 #define DEBUG_TYPE "reloc-info"
     42 
     43 namespace {
     44 
     45 typedef DenseMap<const MCSectionELF *, uint32_t> SectionIndexMapTy;
     46 
     47 class ELFObjectWriter;
     48 
     49 class SymbolTableWriter {
     50   ELFObjectWriter &EWriter;
     51   bool Is64Bit;
     52 
     53   // indexes we are going to write to .symtab_shndx.
     54   std::vector<uint32_t> ShndxIndexes;
     55 
     56   // The numbel of symbols written so far.
     57   unsigned NumWritten;
     58 
     59   void createSymtabShndx();
     60 
     61   template <typename T> void write(T Value);
     62 
     63 public:
     64   SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit);
     65 
     66   void writeSymbol(uint32_t name, uint8_t info, uint64_t value, uint64_t size,
     67                    uint8_t other, uint32_t shndx, bool Reserved);
     68 
     69   ArrayRef<uint32_t> getShndxIndexes() const { return ShndxIndexes; }
     70 };
     71 
     72 class ELFObjectWriter : public MCObjectWriter {
     73     static bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind);
     74     static uint64_t SymbolValue(const MCSymbol &Sym, const MCAsmLayout &Layout);
     75     static bool isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
     76                            bool Used, bool Renamed);
     77 
     78     /// Helper struct for containing some precomputed information on symbols.
     79     struct ELFSymbolData {
     80       const MCSymbolELF *Symbol;
     81       uint32_t SectionIndex;
     82       StringRef Name;
     83 
     84       // Support lexicographic sorting.
     85       bool operator<(const ELFSymbolData &RHS) const {
     86         unsigned LHSType = Symbol->getType();
     87         unsigned RHSType = RHS.Symbol->getType();
     88         if (LHSType == ELF::STT_SECTION && RHSType != ELF::STT_SECTION)
     89           return false;
     90         if (LHSType != ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
     91           return true;
     92         if (LHSType == ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
     93           return SectionIndex < RHS.SectionIndex;
     94         return Name < RHS.Name;
     95       }
     96     };
     97 
     98     /// The target specific ELF writer instance.
     99     std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
    100 
    101     DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
    102 
    103     llvm::DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>>
    104         Relocations;
    105 
    106     /// @}
    107     /// @name Symbol Table Data
    108     /// @{
    109 
    110     BumpPtrAllocator Alloc;
    111     StringSaver VersionSymSaver{Alloc};
    112     StringTableBuilder StrTabBuilder{StringTableBuilder::ELF};
    113 
    114     /// @}
    115 
    116     // This holds the symbol table index of the last local symbol.
    117     unsigned LastLocalSymbolIndex;
    118     // This holds the .strtab section index.
    119     unsigned StringTableIndex;
    120     // This holds the .symtab section index.
    121     unsigned SymbolTableIndex;
    122 
    123     // Sections in the order they are to be output in the section table.
    124     std::vector<const MCSectionELF *> SectionTable;
    125     unsigned addToSectionTable(const MCSectionELF *Sec);
    126 
    127     // TargetObjectWriter wrappers.
    128     bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
    129     bool hasRelocationAddend() const {
    130       return TargetObjectWriter->hasRelocationAddend();
    131     }
    132     unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
    133                           bool IsPCRel) const {
    134       return TargetObjectWriter->GetRelocType(Target, Fixup, IsPCRel);
    135     }
    136 
    137     void align(unsigned Alignment);
    138 
    139   public:
    140     ELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_pwrite_stream &OS,
    141                     bool IsLittleEndian)
    142         : MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(MOTW) {}
    143 
    144     void reset() override {
    145       Renames.clear();
    146       Relocations.clear();
    147       StrTabBuilder.clear();
    148       SectionTable.clear();
    149       MCObjectWriter::reset();
    150     }
    151 
    152     ~ELFObjectWriter() override;
    153 
    154     void WriteWord(uint64_t W) {
    155       if (is64Bit())
    156         write64(W);
    157       else
    158         write32(W);
    159     }
    160 
    161     template <typename T> void write(T Val) {
    162       if (IsLittleEndian)
    163         support::endian::Writer<support::little>(getStream()).write(Val);
    164       else
    165         support::endian::Writer<support::big>(getStream()).write(Val);
    166     }
    167 
    168     void writeHeader(const MCAssembler &Asm);
    169 
    170     void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
    171                      ELFSymbolData &MSD, const MCAsmLayout &Layout);
    172 
    173     // Start and end offset of each section
    174     typedef std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>
    175         SectionOffsetsTy;
    176 
    177     bool shouldRelocateWithSymbol(const MCAssembler &Asm,
    178                                   const MCSymbolRefExpr *RefA,
    179                                   const MCSymbol *Sym, uint64_t C,
    180                                   unsigned Type) const;
    181 
    182     void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
    183                           const MCFragment *Fragment, const MCFixup &Fixup,
    184                           MCValue Target, bool &IsPCRel,
    185                           uint64_t &FixedValue) override;
    186 
    187     // Map from a signature symbol to the group section index
    188     typedef DenseMap<const MCSymbol *, unsigned> RevGroupMapTy;
    189 
    190     /// Compute the symbol table data
    191     ///
    192     /// \param Asm - The assembler.
    193     /// \param SectionIndexMap - Maps a section to its index.
    194     /// \param RevGroupMap - Maps a signature symbol to the group section.
    195     void computeSymbolTable(MCAssembler &Asm, const MCAsmLayout &Layout,
    196                             const SectionIndexMapTy &SectionIndexMap,
    197                             const RevGroupMapTy &RevGroupMap,
    198                             SectionOffsetsTy &SectionOffsets);
    199 
    200     MCSectionELF *createRelocationSection(MCContext &Ctx,
    201                                           const MCSectionELF &Sec);
    202 
    203     const MCSectionELF *createStringTable(MCContext &Ctx);
    204 
    205     void executePostLayoutBinding(MCAssembler &Asm,
    206                                   const MCAsmLayout &Layout) override;
    207 
    208     void writeSectionHeader(const MCAsmLayout &Layout,
    209                             const SectionIndexMapTy &SectionIndexMap,
    210                             const SectionOffsetsTy &SectionOffsets);
    211 
    212     void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
    213                           const MCAsmLayout &Layout);
    214 
    215     void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
    216                           uint64_t Address, uint64_t Offset, uint64_t Size,
    217                           uint32_t Link, uint32_t Info, uint64_t Alignment,
    218                           uint64_t EntrySize);
    219 
    220     void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
    221 
    222     bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
    223                                                 const MCSymbol &SymA,
    224                                                 const MCFragment &FB,
    225                                                 bool InSet,
    226                                                 bool IsPCRel) const override;
    227 
    228     bool isWeak(const MCSymbol &Sym) const override;
    229 
    230     void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
    231     void writeSection(const SectionIndexMapTy &SectionIndexMap,
    232                       uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
    233                       const MCSectionELF &Section);
    234   };
    235 }
    236 
    237 void ELFObjectWriter::align(unsigned Alignment) {
    238   uint64_t Padding = OffsetToAlignment(getStream().tell(), Alignment);
    239   WriteZeros(Padding);
    240 }
    241 
    242 unsigned ELFObjectWriter::addToSectionTable(const MCSectionELF *Sec) {
    243   SectionTable.push_back(Sec);
    244   StrTabBuilder.add(Sec->getSectionName());
    245   return SectionTable.size();
    246 }
    247 
    248 void SymbolTableWriter::createSymtabShndx() {
    249   if (!ShndxIndexes.empty())
    250     return;
    251 
    252   ShndxIndexes.resize(NumWritten);
    253 }
    254 
    255 template <typename T> void SymbolTableWriter::write(T Value) {
    256   EWriter.write(Value);
    257 }
    258 
    259 SymbolTableWriter::SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit)
    260     : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
    261 
    262 void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
    263                                     uint64_t size, uint8_t other,
    264                                     uint32_t shndx, bool Reserved) {
    265   bool LargeIndex = shndx >= ELF::SHN_LORESERVE && !Reserved;
    266 
    267   if (LargeIndex)
    268     createSymtabShndx();
    269 
    270   if (!ShndxIndexes.empty()) {
    271     if (LargeIndex)
    272       ShndxIndexes.push_back(shndx);
    273     else
    274       ShndxIndexes.push_back(0);
    275   }
    276 
    277   uint16_t Index = LargeIndex ? uint16_t(ELF::SHN_XINDEX) : shndx;
    278 
    279   if (Is64Bit) {
    280     write(name);  // st_name
    281     write(info);  // st_info
    282     write(other); // st_other
    283     write(Index); // st_shndx
    284     write(value); // st_value
    285     write(size);  // st_size
    286   } else {
    287     write(name);            // st_name
    288     write(uint32_t(value)); // st_value
    289     write(uint32_t(size));  // st_size
    290     write(info);            // st_info
    291     write(other);           // st_other
    292     write(Index);           // st_shndx
    293   }
    294 
    295   ++NumWritten;
    296 }
    297 
    298 bool ELFObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
    299   const MCFixupKindInfo &FKI =
    300     Asm.getBackend().getFixupKindInfo((MCFixupKind) Kind);
    301 
    302   return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
    303 }
    304 
    305 ELFObjectWriter::~ELFObjectWriter()
    306 {}
    307 
    308 // Emit the ELF header.
    309 void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
    310   // ELF Header
    311   // ----------
    312   //
    313   // Note
    314   // ----
    315   // emitWord method behaves differently for ELF32 and ELF64, writing
    316   // 4 bytes in the former and 8 in the latter.
    317 
    318   writeBytes(ELF::ElfMagic); // e_ident[EI_MAG0] to e_ident[EI_MAG3]
    319 
    320   write8(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
    321 
    322   // e_ident[EI_DATA]
    323   write8(isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
    324 
    325   write8(ELF::EV_CURRENT);        // e_ident[EI_VERSION]
    326   // e_ident[EI_OSABI]
    327   write8(TargetObjectWriter->getOSABI());
    328   write8(0);                  // e_ident[EI_ABIVERSION]
    329 
    330   WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
    331 
    332   write16(ELF::ET_REL);             // e_type
    333 
    334   write16(TargetObjectWriter->getEMachine()); // e_machine = target
    335 
    336   write32(ELF::EV_CURRENT);         // e_version
    337   WriteWord(0);                    // e_entry, no entry point in .o file
    338   WriteWord(0);                    // e_phoff, no program header for .o
    339   WriteWord(0);                     // e_shoff = sec hdr table off in bytes
    340 
    341   // e_flags = whatever the target wants
    342   write32(Asm.getELFHeaderEFlags());
    343 
    344   // e_ehsize = ELF header size
    345   write16(is64Bit() ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
    346 
    347   write16(0);                  // e_phentsize = prog header entry size
    348   write16(0);                  // e_phnum = # prog header entries = 0
    349 
    350   // e_shentsize = Section header entry size
    351   write16(is64Bit() ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
    352 
    353   // e_shnum     = # of section header ents
    354   write16(0);
    355 
    356   // e_shstrndx  = Section # of '.shstrtab'
    357   assert(StringTableIndex < ELF::SHN_LORESERVE);
    358   write16(StringTableIndex);
    359 }
    360 
    361 uint64_t ELFObjectWriter::SymbolValue(const MCSymbol &Sym,
    362                                       const MCAsmLayout &Layout) {
    363   if (Sym.isCommon() && Sym.isExternal())
    364     return Sym.getCommonAlignment();
    365 
    366   uint64_t Res;
    367   if (!Layout.getSymbolOffset(Sym, Res))
    368     return 0;
    369 
    370   if (Layout.getAssembler().isThumbFunc(&Sym))
    371     Res |= 1;
    372 
    373   return Res;
    374 }
    375 
    376 void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
    377                                                const MCAsmLayout &Layout) {
    378   // The presence of symbol versions causes undefined symbols and
    379   // versions declared with @@@ to be renamed.
    380 
    381   for (const MCSymbol &A : Asm.symbols()) {
    382     const auto &Alias = cast<MCSymbolELF>(A);
    383     // Not an alias.
    384     if (!Alias.isVariable())
    385       continue;
    386     auto *Ref = dyn_cast<MCSymbolRefExpr>(Alias.getVariableValue());
    387     if (!Ref)
    388       continue;
    389     const auto &Symbol = cast<MCSymbolELF>(Ref->getSymbol());
    390 
    391     StringRef AliasName = Alias.getName();
    392     size_t Pos = AliasName.find('@');
    393     if (Pos == StringRef::npos)
    394       continue;
    395 
    396     // Aliases defined with .symvar copy the binding from the symbol they alias.
    397     // This is the first place we are able to copy this information.
    398     Alias.setExternal(Symbol.isExternal());
    399     Alias.setBinding(Symbol.getBinding());
    400 
    401     StringRef Rest = AliasName.substr(Pos);
    402     if (!Symbol.isUndefined() && !Rest.startswith("@@@"))
    403       continue;
    404 
    405     // FIXME: produce a better error message.
    406     if (Symbol.isUndefined() && Rest.startswith("@@") &&
    407         !Rest.startswith("@@@"))
    408       report_fatal_error("A @@ version cannot be undefined");
    409 
    410     Renames.insert(std::make_pair(&Symbol, &Alias));
    411   }
    412 }
    413 
    414 static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType) {
    415   uint8_t Type = newType;
    416 
    417   // Propagation rules:
    418   // IFUNC > FUNC > OBJECT > NOTYPE
    419   // TLS_OBJECT > OBJECT > NOTYPE
    420   //
    421   // dont let the new type degrade the old type
    422   switch (origType) {
    423   default:
    424     break;
    425   case ELF::STT_GNU_IFUNC:
    426     if (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT ||
    427         Type == ELF::STT_NOTYPE || Type == ELF::STT_TLS)
    428       Type = ELF::STT_GNU_IFUNC;
    429     break;
    430   case ELF::STT_FUNC:
    431     if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
    432         Type == ELF::STT_TLS)
    433       Type = ELF::STT_FUNC;
    434     break;
    435   case ELF::STT_OBJECT:
    436     if (Type == ELF::STT_NOTYPE)
    437       Type = ELF::STT_OBJECT;
    438     break;
    439   case ELF::STT_TLS:
    440     if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
    441         Type == ELF::STT_GNU_IFUNC || Type == ELF::STT_FUNC)
    442       Type = ELF::STT_TLS;
    443     break;
    444   }
    445 
    446   return Type;
    447 }
    448 
    449 void ELFObjectWriter::writeSymbol(SymbolTableWriter &Writer,
    450                                   uint32_t StringIndex, ELFSymbolData &MSD,
    451                                   const MCAsmLayout &Layout) {
    452   const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
    453   const MCSymbolELF *Base =
    454       cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
    455 
    456   // This has to be in sync with when computeSymbolTable uses SHN_ABS or
    457   // SHN_COMMON.
    458   bool IsReserved = !Base || Symbol.isCommon();
    459 
    460   // Binding and Type share the same byte as upper and lower nibbles
    461   uint8_t Binding = Symbol.getBinding();
    462   uint8_t Type = Symbol.getType();
    463   if (Base) {
    464     Type = mergeTypeForSet(Type, Base->getType());
    465   }
    466   uint8_t Info = (Binding << 4) | Type;
    467 
    468   // Other and Visibility share the same byte with Visibility using the lower
    469   // 2 bits
    470   uint8_t Visibility = Symbol.getVisibility();
    471   uint8_t Other = Symbol.getOther() | Visibility;
    472 
    473   uint64_t Value = SymbolValue(*MSD.Symbol, Layout);
    474   uint64_t Size = 0;
    475 
    476   const MCExpr *ESize = MSD.Symbol->getSize();
    477   if (!ESize && Base)
    478     ESize = Base->getSize();
    479 
    480   if (ESize) {
    481     int64_t Res;
    482     if (!ESize->evaluateKnownAbsolute(Res, Layout))
    483       report_fatal_error("Size expression must be absolute.");
    484     Size = Res;
    485   }
    486 
    487   // Write out the symbol table entry
    488   Writer.writeSymbol(StringIndex, Info, Value, Size, Other, MSD.SectionIndex,
    489                      IsReserved);
    490 }
    491 
    492 // It is always valid to create a relocation with a symbol. It is preferable
    493 // to use a relocation with a section if that is possible. Using the section
    494 // allows us to omit some local symbols from the symbol table.
    495 bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
    496                                                const MCSymbolRefExpr *RefA,
    497                                                const MCSymbol *S, uint64_t C,
    498                                                unsigned Type) const {
    499   const auto *Sym = cast_or_null<MCSymbolELF>(S);
    500   // A PCRel relocation to an absolute value has no symbol (or section). We
    501   // represent that with a relocation to a null section.
    502   if (!RefA)
    503     return false;
    504 
    505   MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
    506   switch (Kind) {
    507   default:
    508     break;
    509   // The .odp creation emits a relocation against the symbol ".TOC." which
    510   // create a R_PPC64_TOC relocation. However the relocation symbol name
    511   // in final object creation should be NULL, since the symbol does not
    512   // really exist, it is just the reference to TOC base for the current
    513   // object file. Since the symbol is undefined, returning false results
    514   // in a relocation with a null section which is the desired result.
    515   case MCSymbolRefExpr::VK_PPC_TOCBASE:
    516     return false;
    517 
    518   // These VariantKind cause the relocation to refer to something other than
    519   // the symbol itself, like a linker generated table. Since the address of
    520   // symbol is not relevant, we cannot replace the symbol with the
    521   // section and patch the difference in the addend.
    522   case MCSymbolRefExpr::VK_GOT:
    523   case MCSymbolRefExpr::VK_PLT:
    524   case MCSymbolRefExpr::VK_GOTPCREL:
    525   case MCSymbolRefExpr::VK_Mips_GOT:
    526   case MCSymbolRefExpr::VK_PPC_GOT_LO:
    527   case MCSymbolRefExpr::VK_PPC_GOT_HI:
    528   case MCSymbolRefExpr::VK_PPC_GOT_HA:
    529     return true;
    530   }
    531 
    532   // An undefined symbol is not in any section, so the relocation has to point
    533   // to the symbol itself.
    534   assert(Sym && "Expected a symbol");
    535   if (Sym->isUndefined())
    536     return true;
    537 
    538   unsigned Binding = Sym->getBinding();
    539   switch(Binding) {
    540   default:
    541     llvm_unreachable("Invalid Binding");
    542   case ELF::STB_LOCAL:
    543     break;
    544   case ELF::STB_WEAK:
    545     // If the symbol is weak, it might be overridden by a symbol in another
    546     // file. The relocation has to point to the symbol so that the linker
    547     // can update it.
    548     return true;
    549   case ELF::STB_GLOBAL:
    550     // Global ELF symbols can be preempted by the dynamic linker. The relocation
    551     // has to point to the symbol for a reason analogous to the STB_WEAK case.
    552     return true;
    553   }
    554 
    555   // If a relocation points to a mergeable section, we have to be careful.
    556   // If the offset is zero, a relocation with the section will encode the
    557   // same information. With a non-zero offset, the situation is different.
    558   // For example, a relocation can point 42 bytes past the end of a string.
    559   // If we change such a relocation to use the section, the linker would think
    560   // that it pointed to another string and subtracting 42 at runtime will
    561   // produce the wrong value.
    562   auto &Sec = cast<MCSectionELF>(Sym->getSection());
    563   unsigned Flags = Sec.getFlags();
    564   if (Flags & ELF::SHF_MERGE) {
    565     if (C != 0)
    566       return true;
    567 
    568     // It looks like gold has a bug (http://sourceware.org/PR16794) and can
    569     // only handle section relocations to mergeable sections if using RELA.
    570     if (!hasRelocationAddend())
    571       return true;
    572   }
    573 
    574   // Most TLS relocations use a got, so they need the symbol. Even those that
    575   // are just an offset (@tpoff), require a symbol in gold versions before
    576   // 5efeedf61e4fe720fd3e9a08e6c91c10abb66d42 (2014-09-26) which fixed
    577   // http://sourceware.org/PR16773.
    578   if (Flags & ELF::SHF_TLS)
    579     return true;
    580 
    581   // If the symbol is a thumb function the final relocation must set the lowest
    582   // bit. With a symbol that is done by just having the symbol have that bit
    583   // set, so we would lose the bit if we relocated with the section.
    584   // FIXME: We could use the section but add the bit to the relocation value.
    585   if (Asm.isThumbFunc(Sym))
    586     return true;
    587 
    588   if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
    589     return true;
    590   return false;
    591 }
    592 
    593 // True if the assembler knows nothing about the final value of the symbol.
    594 // This doesn't cover the comdat issues, since in those cases the assembler
    595 // can at least know that all symbols in the section will move together.
    596 static bool isWeak(const MCSymbolELF &Sym) {
    597   if (Sym.getType() == ELF::STT_GNU_IFUNC)
    598     return true;
    599 
    600   switch (Sym.getBinding()) {
    601   default:
    602     llvm_unreachable("Unknown binding");
    603   case ELF::STB_LOCAL:
    604     return false;
    605   case ELF::STB_GLOBAL:
    606     return false;
    607   case ELF::STB_WEAK:
    608   case ELF::STB_GNU_UNIQUE:
    609     return true;
    610   }
    611 }
    612 
    613 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
    614                                        const MCAsmLayout &Layout,
    615                                        const MCFragment *Fragment,
    616                                        const MCFixup &Fixup, MCValue Target,
    617                                        bool &IsPCRel, uint64_t &FixedValue) {
    618   const MCSectionELF &FixupSection = cast<MCSectionELF>(*Fragment->getParent());
    619   uint64_t C = Target.getConstant();
    620   uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
    621 
    622   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
    623     assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
    624            "Should not have constructed this");
    625 
    626     // Let A, B and C being the components of Target and R be the location of
    627     // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
    628     // If it is pcrel, we want to compute (A - B + C - R).
    629 
    630     // In general, ELF has no relocations for -B. It can only represent (A + C)
    631     // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
    632     // replace B to implement it: (A - R - K + C)
    633     if (IsPCRel) {
    634       Asm.getContext().reportError(
    635           Fixup.getLoc(),
    636           "No relocation available to represent this relative expression");
    637       return;
    638     }
    639 
    640     const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
    641 
    642     if (SymB.isUndefined()) {
    643       Asm.getContext().reportError(
    644           Fixup.getLoc(),
    645           Twine("symbol '") + SymB.getName() +
    646               "' can not be undefined in a subtraction expression");
    647       return;
    648     }
    649 
    650     assert(!SymB.isAbsolute() && "Should have been folded");
    651     const MCSection &SecB = SymB.getSection();
    652     if (&SecB != &FixupSection) {
    653       Asm.getContext().reportError(
    654           Fixup.getLoc(), "Cannot represent a difference across sections");
    655       return;
    656     }
    657 
    658     if (::isWeak(SymB)) {
    659       Asm.getContext().reportError(
    660           Fixup.getLoc(), "Cannot represent a subtraction with a weak symbol");
    661       return;
    662     }
    663 
    664     uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
    665     uint64_t K = SymBOffset - FixupOffset;
    666     IsPCRel = true;
    667     C -= K;
    668   }
    669 
    670   // We either rejected the fixup or folded B into C at this point.
    671   const MCSymbolRefExpr *RefA = Target.getSymA();
    672   const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->getSymbol()) : nullptr;
    673 
    674   bool ViaWeakRef = false;
    675   if (SymA && SymA->isVariable()) {
    676     const MCExpr *Expr = SymA->getVariableValue();
    677     if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
    678       if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF) {
    679         SymA = cast<MCSymbolELF>(&Inner->getSymbol());
    680         ViaWeakRef = true;
    681       }
    682     }
    683   }
    684 
    685   unsigned Type = GetRelocType(Target, Fixup, IsPCRel);
    686   bool RelocateWithSymbol = shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type);
    687   if (!RelocateWithSymbol && SymA && !SymA->isUndefined())
    688     C += Layout.getSymbolOffset(*SymA);
    689 
    690   uint64_t Addend = 0;
    691   if (hasRelocationAddend()) {
    692     Addend = C;
    693     C = 0;
    694   }
    695 
    696   FixedValue = C;
    697 
    698   if (!RelocateWithSymbol) {
    699     const MCSection *SecA =
    700         (SymA && !SymA->isUndefined()) ? &SymA->getSection() : nullptr;
    701     auto *ELFSec = cast_or_null<MCSectionELF>(SecA);
    702     const auto *SectionSymbol =
    703         ELFSec ? cast<MCSymbolELF>(ELFSec->getBeginSymbol()) : nullptr;
    704     if (SectionSymbol)
    705       SectionSymbol->setUsedInReloc();
    706     ELFRelocationEntry Rec(FixupOffset, SectionSymbol, Type, Addend);
    707     Relocations[&FixupSection].push_back(Rec);
    708     return;
    709   }
    710 
    711   if (SymA) {
    712     if (const MCSymbolELF *R = Renames.lookup(SymA))
    713       SymA = R;
    714 
    715     if (ViaWeakRef)
    716       SymA->setIsWeakrefUsedInReloc();
    717     else
    718       SymA->setUsedInReloc();
    719   }
    720   ELFRelocationEntry Rec(FixupOffset, SymA, Type, Addend);
    721   Relocations[&FixupSection].push_back(Rec);
    722   return;
    723 }
    724 
    725 bool ELFObjectWriter::isInSymtab(const MCAsmLayout &Layout,
    726                                  const MCSymbolELF &Symbol, bool Used,
    727                                  bool Renamed) {
    728   if (Symbol.isVariable()) {
    729     const MCExpr *Expr = Symbol.getVariableValue();
    730     if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr)) {
    731       if (Ref->getKind() == MCSymbolRefExpr::VK_WEAKREF)
    732         return false;
    733     }
    734   }
    735 
    736   if (Used)
    737     return true;
    738 
    739   if (Renamed)
    740     return false;
    741 
    742   if (Symbol.isVariable() && Symbol.isUndefined()) {
    743     // FIXME: this is here just to diagnose the case of a var = commmon_sym.
    744     Layout.getBaseSymbol(Symbol);
    745     return false;
    746   }
    747 
    748   if (Symbol.isUndefined() && !Symbol.isBindingSet())
    749     return false;
    750 
    751   if (Symbol.isTemporary())
    752     return false;
    753 
    754   if (Symbol.getType() == ELF::STT_SECTION)
    755     return false;
    756 
    757   return true;
    758 }
    759 
    760 void ELFObjectWriter::computeSymbolTable(
    761     MCAssembler &Asm, const MCAsmLayout &Layout,
    762     const SectionIndexMapTy &SectionIndexMap, const RevGroupMapTy &RevGroupMap,
    763     SectionOffsetsTy &SectionOffsets) {
    764   MCContext &Ctx = Asm.getContext();
    765   SymbolTableWriter Writer(*this, is64Bit());
    766 
    767   // Symbol table
    768   unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
    769   MCSectionELF *SymtabSection =
    770       Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize, "");
    771   SymtabSection->setAlignment(is64Bit() ? 8 : 4);
    772   SymbolTableIndex = addToSectionTable(SymtabSection);
    773 
    774   align(SymtabSection->getAlignment());
    775   uint64_t SecStart = getStream().tell();
    776 
    777   // The first entry is the undefined symbol entry.
    778   Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
    779 
    780   std::vector<ELFSymbolData> LocalSymbolData;
    781   std::vector<ELFSymbolData> ExternalSymbolData;
    782 
    783   // Add the data for the symbols.
    784   bool HasLargeSectionIndex = false;
    785   for (const MCSymbol &S : Asm.symbols()) {
    786     const auto &Symbol = cast<MCSymbolELF>(S);
    787     bool Used = Symbol.isUsedInReloc();
    788     bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
    789     bool isSignature = Symbol.isSignature();
    790 
    791     if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
    792                     Renames.count(&Symbol)))
    793       continue;
    794 
    795     if (Symbol.isTemporary() && Symbol.isUndefined()) {
    796       Ctx.reportError(SMLoc(), "Undefined temporary symbol");
    797       continue;
    798     }
    799 
    800     ELFSymbolData MSD;
    801     MSD.Symbol = cast<MCSymbolELF>(&Symbol);
    802 
    803     bool Local = Symbol.getBinding() == ELF::STB_LOCAL;
    804     assert(Local || !Symbol.isTemporary());
    805 
    806     if (Symbol.isAbsolute()) {
    807       MSD.SectionIndex = ELF::SHN_ABS;
    808     } else if (Symbol.isCommon()) {
    809       assert(!Local);
    810       MSD.SectionIndex = ELF::SHN_COMMON;
    811     } else if (Symbol.isUndefined()) {
    812       if (isSignature && !Used) {
    813         MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
    814         if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
    815           HasLargeSectionIndex = true;
    816       } else {
    817         MSD.SectionIndex = ELF::SHN_UNDEF;
    818       }
    819     } else {
    820       const MCSectionELF &Section =
    821           static_cast<const MCSectionELF &>(Symbol.getSection());
    822       MSD.SectionIndex = SectionIndexMap.lookup(&Section);
    823       assert(MSD.SectionIndex && "Invalid section index!");
    824       if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
    825         HasLargeSectionIndex = true;
    826     }
    827 
    828     // The @@@ in symbol version is replaced with @ in undefined symbols and @@
    829     // in defined ones.
    830     //
    831     // FIXME: All name handling should be done before we get to the writer,
    832     // including dealing with GNU-style version suffixes.  Fixing this isn't
    833     // trivial.
    834     //
    835     // We thus have to be careful to not perform the symbol version replacement
    836     // blindly:
    837     //
    838     // The ELF format is used on Windows by the MCJIT engine.  Thus, on
    839     // Windows, the ELFObjectWriter can encounter symbols mangled using the MS
    840     // Visual Studio C++ name mangling scheme. Symbols mangled using the MSVC
    841     // C++ name mangling can legally have "@@@" as a sub-string. In that case,
    842     // the EFLObjectWriter should not interpret the "@@@" sub-string as
    843     // specifying GNU-style symbol versioning. The ELFObjectWriter therefore
    844     // checks for the MSVC C++ name mangling prefix which is either "?", "@?",
    845     // "__imp_?" or "__imp_@?".
    846     //
    847     // It would have been interesting to perform the MS mangling prefix check
    848     // only when the target triple is of the form *-pc-windows-elf. But, it
    849     // seems that this information is not easily accessible from the
    850     // ELFObjectWriter.
    851     StringRef Name = Symbol.getName();
    852     SmallString<32> Buf;
    853     if (!Name.startswith("?") && !Name.startswith("@?") &&
    854         !Name.startswith("__imp_?") && !Name.startswith("__imp_@?")) {
    855       // This symbol isn't following the MSVC C++ name mangling convention. We
    856       // can thus safely interpret the @@@ in symbol names as specifying symbol
    857       // versioning.
    858       size_t Pos = Name.find("@@@");
    859       if (Pos != StringRef::npos) {
    860         Buf += Name.substr(0, Pos);
    861         unsigned Skip = MSD.SectionIndex == ELF::SHN_UNDEF ? 2 : 1;
    862         Buf += Name.substr(Pos + Skip);
    863         Name = VersionSymSaver.save(Buf.c_str());
    864       }
    865     }
    866 
    867     // Sections have their own string table
    868     if (Symbol.getType() != ELF::STT_SECTION) {
    869       MSD.Name = Name;
    870       StrTabBuilder.add(Name);
    871     }
    872 
    873     if (Local)
    874       LocalSymbolData.push_back(MSD);
    875     else
    876       ExternalSymbolData.push_back(MSD);
    877   }
    878 
    879   // This holds the .symtab_shndx section index.
    880   unsigned SymtabShndxSectionIndex = 0;
    881 
    882   if (HasLargeSectionIndex) {
    883     MCSectionELF *SymtabShndxSection =
    884         Ctx.getELFSection(".symtab_shndxr", ELF::SHT_SYMTAB_SHNDX, 0, 4, "");
    885     SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
    886     SymtabShndxSection->setAlignment(4);
    887   }
    888 
    889   ArrayRef<std::string> FileNames = Asm.getFileNames();
    890   for (const std::string &Name : FileNames)
    891     StrTabBuilder.add(Name);
    892 
    893   StrTabBuilder.finalize();
    894 
    895   for (const std::string &Name : FileNames)
    896     Writer.writeSymbol(StrTabBuilder.getOffset(Name),
    897                        ELF::STT_FILE | ELF::STB_LOCAL, 0, 0, ELF::STV_DEFAULT,
    898                        ELF::SHN_ABS, true);
    899 
    900   // Symbols are required to be in lexicographic order.
    901   array_pod_sort(LocalSymbolData.begin(), LocalSymbolData.end());
    902   array_pod_sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
    903 
    904   // Set the symbol indices. Local symbols must come before all other
    905   // symbols with non-local bindings.
    906   unsigned Index = FileNames.size() + 1;
    907 
    908   for (ELFSymbolData &MSD : LocalSymbolData) {
    909     unsigned StringIndex = MSD.Symbol->getType() == ELF::STT_SECTION
    910                                ? 0
    911                                : StrTabBuilder.getOffset(MSD.Name);
    912     MSD.Symbol->setIndex(Index++);
    913     writeSymbol(Writer, StringIndex, MSD, Layout);
    914   }
    915 
    916   // Write the symbol table entries.
    917   LastLocalSymbolIndex = Index;
    918 
    919   for (ELFSymbolData &MSD : ExternalSymbolData) {
    920     unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
    921     MSD.Symbol->setIndex(Index++);
    922     writeSymbol(Writer, StringIndex, MSD, Layout);
    923     assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
    924   }
    925 
    926   uint64_t SecEnd = getStream().tell();
    927   SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
    928 
    929   ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
    930   if (ShndxIndexes.empty()) {
    931     assert(SymtabShndxSectionIndex == 0);
    932     return;
    933   }
    934   assert(SymtabShndxSectionIndex != 0);
    935 
    936   SecStart = getStream().tell();
    937   const MCSectionELF *SymtabShndxSection =
    938       SectionTable[SymtabShndxSectionIndex - 1];
    939   for (uint32_t Index : ShndxIndexes)
    940     write(Index);
    941   SecEnd = getStream().tell();
    942   SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
    943 }
    944 
    945 MCSectionELF *
    946 ELFObjectWriter::createRelocationSection(MCContext &Ctx,
    947                                          const MCSectionELF &Sec) {
    948   if (Relocations[&Sec].empty())
    949     return nullptr;
    950 
    951   const StringRef SectionName = Sec.getSectionName();
    952   std::string RelaSectionName = hasRelocationAddend() ? ".rela" : ".rel";
    953   RelaSectionName += SectionName;
    954 
    955   unsigned EntrySize;
    956   if (hasRelocationAddend())
    957     EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rela) : sizeof(ELF::Elf32_Rela);
    958   else
    959     EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rel) : sizeof(ELF::Elf32_Rel);
    960 
    961   unsigned Flags = 0;
    962   if (Sec.getFlags() & ELF::SHF_GROUP)
    963     Flags = ELF::SHF_GROUP;
    964 
    965   MCSectionELF *RelaSection = Ctx.createELFRelSection(
    966       RelaSectionName, hasRelocationAddend() ? ELF::SHT_RELA : ELF::SHT_REL,
    967       Flags, EntrySize, Sec.getGroup(), &Sec);
    968   RelaSection->setAlignment(is64Bit() ? 8 : 4);
    969   return RelaSection;
    970 }
    971 
    972 // Include the debug info compression header:
    973 // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
    974 // useful for consumers to preallocate a buffer to decompress into.
    975 static bool
    976 prependCompressionHeader(uint64_t Size,
    977                          SmallVectorImpl<char> &CompressedContents) {
    978   const StringRef Magic = "ZLIB";
    979   if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
    980     return false;
    981   if (sys::IsLittleEndianHost)
    982     sys::swapByteOrder(Size);
    983   CompressedContents.insert(CompressedContents.begin(),
    984                             Magic.size() + sizeof(Size), 0);
    985   std::copy(Magic.begin(), Magic.end(), CompressedContents.begin());
    986   std::copy(reinterpret_cast<char *>(&Size),
    987             reinterpret_cast<char *>(&Size + 1),
    988             CompressedContents.begin() + Magic.size());
    989   return true;
    990 }
    991 
    992 void ELFObjectWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
    993                                        const MCAsmLayout &Layout) {
    994   MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
    995   StringRef SectionName = Section.getSectionName();
    996 
    997   // Compressing debug_frame requires handling alignment fragments which is
    998   // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow
    999   // for writing to arbitrary buffers) for little benefit.
   1000   if (!Asm.getContext().getAsmInfo()->compressDebugSections() ||
   1001       !SectionName.startswith(".debug_") || SectionName == ".debug_frame") {
   1002     Asm.writeSectionData(&Section, Layout);
   1003     return;
   1004   }
   1005 
   1006   SmallVector<char, 128> UncompressedData;
   1007   raw_svector_ostream VecOS(UncompressedData);
   1008   raw_pwrite_stream &OldStream = getStream();
   1009   setStream(VecOS);
   1010   Asm.writeSectionData(&Section, Layout);
   1011   setStream(OldStream);
   1012 
   1013   SmallVector<char, 128> CompressedContents;
   1014   zlib::Status Success = zlib::compress(
   1015       StringRef(UncompressedData.data(), UncompressedData.size()),
   1016       CompressedContents);
   1017   if (Success != zlib::StatusOK) {
   1018     getStream() << UncompressedData;
   1019     return;
   1020   }
   1021 
   1022   if (!prependCompressionHeader(UncompressedData.size(), CompressedContents)) {
   1023     getStream() << UncompressedData;
   1024     return;
   1025   }
   1026   Asm.getContext().renameELFSection(&Section,
   1027                                     (".z" + SectionName.drop_front(1)).str());
   1028   getStream() << CompressedContents;
   1029 }
   1030 
   1031 void ELFObjectWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
   1032                                        uint64_t Flags, uint64_t Address,
   1033                                        uint64_t Offset, uint64_t Size,
   1034                                        uint32_t Link, uint32_t Info,
   1035                                        uint64_t Alignment,
   1036                                        uint64_t EntrySize) {
   1037   write32(Name);        // sh_name: index into string table
   1038   write32(Type);        // sh_type
   1039   WriteWord(Flags);     // sh_flags
   1040   WriteWord(Address);   // sh_addr
   1041   WriteWord(Offset);    // sh_offset
   1042   WriteWord(Size);      // sh_size
   1043   write32(Link);        // sh_link
   1044   write32(Info);        // sh_info
   1045   WriteWord(Alignment); // sh_addralign
   1046   WriteWord(EntrySize); // sh_entsize
   1047 }
   1048 
   1049 void ELFObjectWriter::writeRelocations(const MCAssembler &Asm,
   1050                                        const MCSectionELF &Sec) {
   1051   std::vector<ELFRelocationEntry> &Relocs = Relocations[&Sec];
   1052 
   1053   // We record relocations by pushing to the end of a vector. Reverse the vector
   1054   // to get the relocations in the order they were created.
   1055   // In most cases that is not important, but it can be for special sections
   1056   // (.eh_frame) or specific relocations (TLS optimizations on SystemZ).
   1057   std::reverse(Relocs.begin(), Relocs.end());
   1058 
   1059   // Sort the relocation entries. MIPS needs this.
   1060   TargetObjectWriter->sortRelocs(Asm, Relocs);
   1061 
   1062   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
   1063     const ELFRelocationEntry &Entry = Relocs[e - i - 1];
   1064     unsigned Index = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
   1065 
   1066     if (is64Bit()) {
   1067       write(Entry.Offset);
   1068       if (TargetObjectWriter->isN64()) {
   1069         write(uint32_t(Index));
   1070 
   1071         write(TargetObjectWriter->getRSsym(Entry.Type));
   1072         write(TargetObjectWriter->getRType3(Entry.Type));
   1073         write(TargetObjectWriter->getRType2(Entry.Type));
   1074         write(TargetObjectWriter->getRType(Entry.Type));
   1075       } else {
   1076         struct ELF::Elf64_Rela ERE64;
   1077         ERE64.setSymbolAndType(Index, Entry.Type);
   1078         write(ERE64.r_info);
   1079       }
   1080       if (hasRelocationAddend())
   1081         write(Entry.Addend);
   1082     } else {
   1083       write(uint32_t(Entry.Offset));
   1084 
   1085       struct ELF::Elf32_Rela ERE32;
   1086       ERE32.setSymbolAndType(Index, Entry.Type);
   1087       write(ERE32.r_info);
   1088 
   1089       if (hasRelocationAddend())
   1090         write(uint32_t(Entry.Addend));
   1091     }
   1092   }
   1093 }
   1094 
   1095 const MCSectionELF *ELFObjectWriter::createStringTable(MCContext &Ctx) {
   1096   const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
   1097   getStream() << StrTabBuilder.data();
   1098   return StrtabSection;
   1099 }
   1100 
   1101 void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
   1102                                    uint32_t GroupSymbolIndex, uint64_t Offset,
   1103                                    uint64_t Size, const MCSectionELF &Section) {
   1104   uint64_t sh_link = 0;
   1105   uint64_t sh_info = 0;
   1106 
   1107   switch(Section.getType()) {
   1108   default:
   1109     // Nothing to do.
   1110     break;
   1111 
   1112   case ELF::SHT_DYNAMIC:
   1113     llvm_unreachable("SHT_DYNAMIC in a relocatable object");
   1114 
   1115   case ELF::SHT_REL:
   1116   case ELF::SHT_RELA: {
   1117     sh_link = SymbolTableIndex;
   1118     assert(sh_link && ".symtab not found");
   1119     const MCSectionELF *InfoSection = Section.getAssociatedSection();
   1120     sh_info = SectionIndexMap.lookup(InfoSection);
   1121     break;
   1122   }
   1123 
   1124   case ELF::SHT_SYMTAB:
   1125   case ELF::SHT_DYNSYM:
   1126     sh_link = StringTableIndex;
   1127     sh_info = LastLocalSymbolIndex;
   1128     break;
   1129 
   1130   case ELF::SHT_SYMTAB_SHNDX:
   1131     sh_link = SymbolTableIndex;
   1132     break;
   1133 
   1134   case ELF::SHT_GROUP:
   1135     sh_link = SymbolTableIndex;
   1136     sh_info = GroupSymbolIndex;
   1137     break;
   1138   }
   1139 
   1140   if (TargetObjectWriter->getEMachine() == ELF::EM_ARM &&
   1141       Section.getType() == ELF::SHT_ARM_EXIDX)
   1142     sh_link = SectionIndexMap.lookup(Section.getAssociatedSection());
   1143 
   1144   WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getSectionName()),
   1145                    Section.getType(), Section.getFlags(), 0, Offset, Size,
   1146                    sh_link, sh_info, Section.getAlignment(),
   1147                    Section.getEntrySize());
   1148 }
   1149 
   1150 void ELFObjectWriter::writeSectionHeader(
   1151     const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
   1152     const SectionOffsetsTy &SectionOffsets) {
   1153   const unsigned NumSections = SectionTable.size();
   1154 
   1155   // Null section first.
   1156   uint64_t FirstSectionSize =
   1157       (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
   1158   WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
   1159 
   1160   for (const MCSectionELF *Section : SectionTable) {
   1161     uint32_t GroupSymbolIndex;
   1162     unsigned Type = Section->getType();
   1163     if (Type != ELF::SHT_GROUP)
   1164       GroupSymbolIndex = 0;
   1165     else
   1166       GroupSymbolIndex = Section->getGroup()->getIndex();
   1167 
   1168     const std::pair<uint64_t, uint64_t> &Offsets =
   1169         SectionOffsets.find(Section)->second;
   1170     uint64_t Size;
   1171     if (Type == ELF::SHT_NOBITS)
   1172       Size = Layout.getSectionAddressSize(Section);
   1173     else
   1174       Size = Offsets.second - Offsets.first;
   1175 
   1176     writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
   1177                  *Section);
   1178   }
   1179 }
   1180 
   1181 void ELFObjectWriter::writeObject(MCAssembler &Asm,
   1182                                   const MCAsmLayout &Layout) {
   1183   MCContext &Ctx = Asm.getContext();
   1184   MCSectionELF *StrtabSection =
   1185       Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
   1186   StringTableIndex = addToSectionTable(StrtabSection);
   1187 
   1188   RevGroupMapTy RevGroupMap;
   1189   SectionIndexMapTy SectionIndexMap;
   1190 
   1191   std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
   1192 
   1193   // Write out the ELF header ...
   1194   writeHeader(Asm);
   1195 
   1196   // ... then the sections ...
   1197   SectionOffsetsTy SectionOffsets;
   1198   std::vector<MCSectionELF *> Groups;
   1199   std::vector<MCSectionELF *> Relocations;
   1200   for (MCSection &Sec : Asm) {
   1201     MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
   1202 
   1203     align(Section.getAlignment());
   1204 
   1205     // Remember the offset into the file for this section.
   1206     uint64_t SecStart = getStream().tell();
   1207 
   1208     const MCSymbolELF *SignatureSymbol = Section.getGroup();
   1209     writeSectionData(Asm, Section, Layout);
   1210 
   1211     uint64_t SecEnd = getStream().tell();
   1212     SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
   1213 
   1214     MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
   1215 
   1216     if (SignatureSymbol) {
   1217       Asm.registerSymbol(*SignatureSymbol);
   1218       unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
   1219       if (!GroupIdx) {
   1220         MCSectionELF *Group = Ctx.createELFGroupSection(SignatureSymbol);
   1221         GroupIdx = addToSectionTable(Group);
   1222         Group->setAlignment(4);
   1223         Groups.push_back(Group);
   1224       }
   1225       std::vector<const MCSectionELF *> &Members =
   1226           GroupMembers[SignatureSymbol];
   1227       Members.push_back(&Section);
   1228       if (RelSection)
   1229         Members.push_back(RelSection);
   1230     }
   1231 
   1232     SectionIndexMap[&Section] = addToSectionTable(&Section);
   1233     if (RelSection) {
   1234       SectionIndexMap[RelSection] = addToSectionTable(RelSection);
   1235       Relocations.push_back(RelSection);
   1236     }
   1237   }
   1238 
   1239   for (MCSectionELF *Group : Groups) {
   1240     align(Group->getAlignment());
   1241 
   1242     // Remember the offset into the file for this section.
   1243     uint64_t SecStart = getStream().tell();
   1244 
   1245     const MCSymbol *SignatureSymbol = Group->getGroup();
   1246     assert(SignatureSymbol);
   1247     write(uint32_t(ELF::GRP_COMDAT));
   1248     for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
   1249       uint32_t SecIndex = SectionIndexMap.lookup(Member);
   1250       write(SecIndex);
   1251     }
   1252 
   1253     uint64_t SecEnd = getStream().tell();
   1254     SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
   1255   }
   1256 
   1257   // Compute symbol table information.
   1258   computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap, SectionOffsets);
   1259 
   1260   for (MCSectionELF *RelSection : Relocations) {
   1261     align(RelSection->getAlignment());
   1262 
   1263     // Remember the offset into the file for this section.
   1264     uint64_t SecStart = getStream().tell();
   1265 
   1266     writeRelocations(Asm, *RelSection->getAssociatedSection());
   1267 
   1268     uint64_t SecEnd = getStream().tell();
   1269     SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
   1270   }
   1271 
   1272   {
   1273     uint64_t SecStart = getStream().tell();
   1274     const MCSectionELF *Sec = createStringTable(Ctx);
   1275     uint64_t SecEnd = getStream().tell();
   1276     SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
   1277   }
   1278 
   1279   uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
   1280   align(NaturalAlignment);
   1281 
   1282   const unsigned SectionHeaderOffset = getStream().tell();
   1283 
   1284   // ... then the section header table ...
   1285   writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
   1286 
   1287   uint16_t NumSections = (SectionTable.size() + 1 >= ELF::SHN_LORESERVE)
   1288                              ? (uint16_t)ELF::SHN_UNDEF
   1289                              : SectionTable.size() + 1;
   1290   if (sys::IsLittleEndianHost != IsLittleEndian)
   1291     sys::swapByteOrder(NumSections);
   1292   unsigned NumSectionsOffset;
   1293 
   1294   if (is64Bit()) {
   1295     uint64_t Val = SectionHeaderOffset;
   1296     if (sys::IsLittleEndianHost != IsLittleEndian)
   1297       sys::swapByteOrder(Val);
   1298     getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
   1299                        offsetof(ELF::Elf64_Ehdr, e_shoff));
   1300     NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
   1301   } else {
   1302     uint32_t Val = SectionHeaderOffset;
   1303     if (sys::IsLittleEndianHost != IsLittleEndian)
   1304       sys::swapByteOrder(Val);
   1305     getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
   1306                        offsetof(ELF::Elf32_Ehdr, e_shoff));
   1307     NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
   1308   }
   1309   getStream().pwrite(reinterpret_cast<char *>(&NumSections),
   1310                      sizeof(NumSections), NumSectionsOffset);
   1311 }
   1312 
   1313 bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
   1314     const MCAssembler &Asm, const MCSymbol &SA, const MCFragment &FB,
   1315     bool InSet, bool IsPCRel) const {
   1316   const auto &SymA = cast<MCSymbolELF>(SA);
   1317   if (IsPCRel) {
   1318     assert(!InSet);
   1319     if (::isWeak(SymA))
   1320       return false;
   1321   }
   1322   return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
   1323                                                                 InSet, IsPCRel);
   1324 }
   1325 
   1326 bool ELFObjectWriter::isWeak(const MCSymbol &S) const {
   1327   const auto &Sym = cast<MCSymbolELF>(S);
   1328   if (::isWeak(Sym))
   1329     return true;
   1330 
   1331   // It is invalid to replace a reference to a global in a comdat
   1332   // with a reference to a local since out of comdat references
   1333   // to a local are forbidden.
   1334   // We could try to return false for more cases, like the reference
   1335   // being in the same comdat or Sym being an alias to another global,
   1336   // but it is not clear if it is worth the effort.
   1337   if (Sym.getBinding() != ELF::STB_GLOBAL)
   1338     return false;
   1339 
   1340   if (!Sym.isInSection())
   1341     return false;
   1342 
   1343   const auto &Sec = cast<MCSectionELF>(Sym.getSection());
   1344   return Sec.getGroup();
   1345 }
   1346 
   1347 MCObjectWriter *llvm::createELFObjectWriter(MCELFObjectTargetWriter *MOTW,
   1348                                             raw_pwrite_stream &OS,
   1349                                             bool IsLittleEndian) {
   1350   return new ELFObjectWriter(MOTW, OS, IsLittleEndian);
   1351 }
   1352