lib/MC/ELFObjectWriter.h

   1 //===- lib/MC/ELFObjectWriter.h - 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 #ifndef LLVM_MC_ELFOBJECTWRITER_H
  15 #define LLVM_MC_ELFOBJECTWRITER_H
  16
  17 #include "MCELF.h"
  18 #include "llvm/ADT/OwningPtr.h"
  19 #include "llvm/ADT/SmallPtrSet.h"
  20 #include "llvm/ADT/SmallString.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/MC/MCAssembler.h"
  23 #include "llvm/MC/MCELFObjectWriter.h"
  24 #include "llvm/MC/MCELFSymbolFlags.h"
  25 #include "llvm/MC/MCObjectWriter.h"
  26 #include "llvm/MC/MCExpr.h"
  27 #include "llvm/MC/MCSymbol.h"
  28
  29 #include <vector>
  30
  31 namespace llvm {
  32
  33 class MCSection;
  34 class MCDataFragment;
  35 class MCSectionELF;
  36
  37 class ELFObjectWriter : public MCObjectWriter {
  38   protected:
  39
  40     static bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind);
  41     static bool RelocNeedsGOT(MCSymbolRefExpr::VariantKind Variant);
  42     static uint64_t SymbolValue(MCSymbolData &Data, const MCAsmLayout &Layout);
  43     static bool isInSymtab(const MCAssembler &Asm, const MCSymbolData &Data,
  44                            bool Used, bool Renamed);
  45     static bool isLocal(const MCSymbolData &Data, bool isSignature,
  46                         bool isUsedInReloc);
  47     static bool IsELFMetaDataSection(const MCSectionData &SD);
  48     static uint64_t DataSectionSize(const MCSectionData &SD);
  49     static uint64_t GetSectionFileSize(const MCAsmLayout &Layout,
  50                                        const MCSectionData &SD);
  51     static uint64_t GetSectionAddressSize(const MCAsmLayout &Layout,
  52                                           const MCSectionData &SD);
  53
  54     void WriteDataSectionData(MCAssembler &Asm,
  55                               const MCAsmLayout &Layout,
  56                               const MCSectionELF &Section);
  57
  58     /*static bool isFixupKindX86RIPRel(unsigned Kind) {
  59       return Kind == X86::reloc_riprel_4byte ||
  60         Kind == X86::reloc_riprel_4byte_movq_load;
  61     }*/
  62
  63     /// ELFSymbolData - Helper struct for containing some precomputed
  64     /// information on symbols.
  65     struct ELFSymbolData {
  66       MCSymbolData *SymbolData;
  67       uint64_t StringIndex;
  68       uint32_t SectionIndex;
  69
  70       // Support lexicographic sorting.
  71       bool operator<(const ELFSymbolData &RHS) const {
  72         if (MCELF::GetType(*SymbolData) == ELF::STT_FILE)
  73           return true;
  74         if (MCELF::GetType(*RHS.SymbolData) == ELF::STT_FILE)
  75           return false;
  76         return SymbolData->getSymbol().getName() <
  77                RHS.SymbolData->getSymbol().getName();
  78       }
  79     };
  80
  81     /// @name Relocation Data
  82     /// @{
  83
  84     struct ELFRelocationEntry {
  85       // Make these big enough for both 32-bit and 64-bit
  86       uint64_t r_offset;
  87       int Index;
  88       unsigned Type;
  89       const MCSymbol *Symbol;
  90       uint64_t r_addend;
  91
  92       ELFRelocationEntry()
  93         : r_offset(0), Index(0), Type(0), Symbol(0), r_addend(0) {}
  94
  95       ELFRelocationEntry(uint64_t RelocOffset, int Idx,
  96                          unsigned RelType, const MCSymbol *Sym,
  97                          uint64_t Addend)
  98         : r_offset(RelocOffset), Index(Idx), Type(RelType),
  99           Symbol(Sym), r_addend(Addend) {}
 100
 101       // Support lexicographic sorting.
 102       bool operator<(const ELFRelocationEntry &RE) const {
 103         return RE.r_offset < r_offset;
 104       }
 105     };
 106
 107     /// The target specific ELF writer instance.
 108     llvm::OwningPtr<MCELFObjectTargetWriter> TargetObjectWriter;
 109
 110     SmallPtrSet<const MCSymbol *, 16> UsedInReloc;
 111     SmallPtrSet<const MCSymbol *, 16> WeakrefUsedInReloc;
 112     DenseMap<const MCSymbol *, const MCSymbol *> Renames;
 113
 114     llvm::DenseMap<const MCSectionData*,
 115                    std::vector<ELFRelocationEntry> > Relocations;
 116     DenseMap<const MCSection*, uint64_t> SectionStringTableIndex;
 117
 118     /// @}
 119     /// @name Symbol Table Data
 120     /// @{
 121
 122     SmallString<256> StringTable;
 123     std::vector<ELFSymbolData> LocalSymbolData;
 124     std::vector<ELFSymbolData> ExternalSymbolData;
 125     std::vector<ELFSymbolData> UndefinedSymbolData;
 126
 127     /// @}
 128
 129     bool NeedsGOT;
 130
 131     bool NeedsSymtabShndx;
 132
 133     // This holds the symbol table index of the last local symbol.
 134     unsigned LastLocalSymbolIndex;
 135     // This holds the .strtab section index.
 136     unsigned StringTableIndex;
 137     // This holds the .symtab section index.
 138     unsigned SymbolTableIndex;
 139
 140     unsigned ShstrtabIndex;
 141
 142
 143     virtual const MCSymbol *SymbolToReloc(const MCAssembler &Asm,
 144                                           const MCValue &Target,
 145                                           const MCFragment &F,
 146                                           const MCFixup &Fixup,
 147                                           bool IsPCRel) const;
 148
 149     // For arch-specific emission of explicit reloc symbol
 150     virtual const MCSymbol *ExplicitRelSym(const MCAssembler &Asm,
 151                                            const MCValue &Target,
 152                                            const MCFragment &F,
 153                                            const MCFixup &Fixup,
 154                                            bool IsPCRel) const {
 155       return NULL;
 156     }
 157
 158     bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
 159     bool hasRelocationAddend() const {
 160       return TargetObjectWriter->hasRelocationAddend();
 161     }
 162
 163   public:
 164     ELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 165                     raw_ostream &_OS, bool IsLittleEndian)
 166       : MCObjectWriter(_OS, IsLittleEndian),
 167         TargetObjectWriter(MOTW),
 168         NeedsGOT(false), NeedsSymtabShndx(false){
 169     }
 170
 171     virtual ~ELFObjectWriter();
 172
 173     void WriteWord(uint64_t W) {
 174       if (is64Bit())
 175         Write64(W);
 176       else
 177         Write32(W);
 178     }
 179
 180     void StringLE16(char *buf, uint16_t Value) {
 181       buf[0] = char(Value >> 0);
 182       buf[1] = char(Value >> 8);
 183     }
 184
 185     void StringLE32(char *buf, uint32_t Value) {
 186       StringLE16(buf, uint16_t(Value >> 0));
 187       StringLE16(buf + 2, uint16_t(Value >> 16));
 188     }
 189
 190     void StringLE64(char *buf, uint64_t Value) {
 191       StringLE32(buf, uint32_t(Value >> 0));
 192       StringLE32(buf + 4, uint32_t(Value >> 32));
 193     }
 194
 195     void StringBE16(char *buf ,uint16_t Value) {
 196       buf[0] = char(Value >> 8);
 197       buf[1] = char(Value >> 0);
 198     }
 199
 200     void StringBE32(char *buf, uint32_t Value) {
 201       StringBE16(buf, uint16_t(Value >> 16));
 202       StringBE16(buf + 2, uint16_t(Value >> 0));
 203     }
 204
 205     void StringBE64(char *buf, uint64_t Value) {
 206       StringBE32(buf, uint32_t(Value >> 32));
 207       StringBE32(buf + 4, uint32_t(Value >> 0));
 208     }
 209
 210     void String8(MCDataFragment &F, uint8_t Value) {
 211       char buf[1];
 212       buf[0] = Value;
 213       F.getContents() += StringRef(buf, 1);
 214     }
 215
 216     void String16(MCDataFragment &F, uint16_t Value) {
 217       char buf[2];
 218       if (isLittleEndian())
 219         StringLE16(buf, Value);
 220       else
 221         StringBE16(buf, Value);
 222       F.getContents() += StringRef(buf, 2);
 223     }
 224
 225     void String32(MCDataFragment &F, uint32_t Value) {
 226       char buf[4];
 227       if (isLittleEndian())
 228         StringLE32(buf, Value);
 229       else
 230         StringBE32(buf, Value);
 231       F.getContents() += StringRef(buf, 4);
 232     }
 233
 234     void String64(MCDataFragment &F, uint64_t Value) {
 235       char buf[8];
 236       if (isLittleEndian())
 237         StringLE64(buf, Value);
 238       else
 239         StringBE64(buf, Value);
 240       F.getContents() += StringRef(buf, 8);
 241     }
 242
 243     virtual void WriteHeader(uint64_t SectionDataSize,
 244                              unsigned NumberOfSections);
 245
 246     /// Default e_flags = 0
 247     virtual void WriteEFlags() { Write32(0); }
 248
 249     virtual void WriteSymbolEntry(MCDataFragment *SymtabF,
 250                                   MCDataFragment *ShndxF,
 251                                   uint64_t name, uint8_t info,
 252                                   uint64_t value, uint64_t size,
 253                                   uint8_t other, uint32_t shndx,
 254                                   bool Reserved);
 255
 256     virtual void WriteSymbol(MCDataFragment *SymtabF,  MCDataFragment *ShndxF,
 257                      ELFSymbolData &MSD,
 258                      const MCAsmLayout &Layout);
 259
 260     typedef DenseMap<const MCSectionELF*, uint32_t> SectionIndexMapTy;
 261     virtual void WriteSymbolTable(MCDataFragment *SymtabF,
 262                                   MCDataFragment *ShndxF,
 263                                   const MCAssembler &Asm,
 264                                   const MCAsmLayout &Layout,
 265                                   const SectionIndexMapTy &SectionIndexMap);
 266
 267     virtual void RecordRelocation(const MCAssembler &Asm,
 268                                   const MCAsmLayout &Layout,
 269                                   const MCFragment *Fragment,
 270                                   const MCFixup &Fixup,
 271                                   MCValue Target, uint64_t &FixedValue);
 272
 273     virtual uint64_t getSymbolIndexInSymbolTable(const MCAssembler &Asm,
 274                                                  const MCSymbol *S);
 275
 276     // Map from a group section to the signature symbol
 277     typedef DenseMap<const MCSectionELF*, const MCSymbol*> GroupMapTy;
 278     // Map from a signature symbol to the group section
 279     typedef DenseMap<const MCSymbol*, const MCSectionELF*> RevGroupMapTy;
 280     // Map from a section to the section with the relocations
 281     typedef DenseMap<const MCSectionELF*, const MCSectionELF*> RelMapTy;
 282     // Map from a section to its offset
 283     typedef DenseMap<const MCSectionELF*, uint64_t> SectionOffsetMapTy;
 284
 285     /// ComputeSymbolTable - Compute the symbol table data
 286     ///
 287     /// \param StringTable [out] - The string table data.
 288     /// \param StringIndexMap [out] - Map from symbol names to offsets in the
 289     /// string table.
 290     virtual void ComputeSymbolTable(MCAssembler &Asm,
 291                             const SectionIndexMapTy &SectionIndexMap,
 292                                     RevGroupMapTy RevGroupMap,
 293                                     unsigned NumRegularSections);
 294
 295     virtual void ComputeIndexMap(MCAssembler &Asm,
 296                                  SectionIndexMapTy &SectionIndexMap,
 297                                  const RelMapTy &RelMap);
 298
 299     void CreateRelocationSections(MCAssembler &Asm, MCAsmLayout &Layout,
 300                                   RelMapTy &RelMap);
 301
 302     void WriteRelocations(MCAssembler &Asm, MCAsmLayout &Layout,
 303                           const RelMapTy &RelMap);
 304
 305     virtual void CreateMetadataSections(MCAssembler &Asm, MCAsmLayout &Layout,
 306                                         SectionIndexMapTy &SectionIndexMap,
 307                                         const RelMapTy &RelMap);
 308
 309     // Create the sections that show up in the symbol table. Currently
 310     // those are the .note.GNU-stack section and the group sections.
 311     virtual void CreateIndexedSections(MCAssembler &Asm, MCAsmLayout &Layout,
 312                                        GroupMapTy &GroupMap,
 313                                        RevGroupMapTy &RevGroupMap,
 314                                        SectionIndexMapTy &SectionIndexMap,
 315                                        const RelMapTy &RelMap);
 316
 317     virtual void ExecutePostLayoutBinding(MCAssembler &Asm,
 318                                           const MCAsmLayout &Layout);
 319
 320     void WriteSectionHeader(MCAssembler &Asm, const GroupMapTy &GroupMap,
 321                             const MCAsmLayout &Layout,
 322                             const SectionIndexMapTy &SectionIndexMap,
 323                             const SectionOffsetMapTy &SectionOffsetMap);
 324
 325     void ComputeSectionOrder(MCAssembler &Asm,
 326                              std::vector<const MCSectionELF*> &Sections);
 327
 328     virtual void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
 329                           uint64_t Address, uint64_t Offset,
 330                           uint64_t Size, uint32_t Link, uint32_t Info,
 331                           uint64_t Alignment, uint64_t EntrySize);
 332
 333     virtual void WriteRelocationsFragment(const MCAssembler &Asm,
 334                                           MCDataFragment *F,
 335                                           const MCSectionData *SD);
 336
 337     virtual bool
 338     IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
 339                                            const MCSymbolData &DataA,
 340                                            const MCFragment &FB,
 341                                            bool InSet,
 342                                            bool IsPCRel) const;
 343
 344     virtual void WriteObject(MCAssembler &Asm, const MCAsmLayout &Layout);
 345     virtual void WriteSection(MCAssembler &Asm,
 346                       const SectionIndexMapTy &SectionIndexMap,
 347                       uint32_t GroupSymbolIndex,
 348                       uint64_t Offset, uint64_t Size, uint64_t Alignment,
 349                       const MCSectionELF &Section);
 350
 351   protected:
 352     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 353                                   bool IsPCRel, bool IsRelocWithSymbol,
 354                                   int64_t Addend) = 0;
 355     virtual void adjustFixupOffset(const MCFixup &Fixup,
 356                                    uint64_t &RelocOffset) {}
 357   };
 358
 359   //===- X86ELFObjectWriter -------------------------------------------===//
 360
 361   class X86ELFObjectWriter : public ELFObjectWriter {
 362   public:
 363     X86ELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 364                        raw_ostream &_OS,
 365                        bool IsLittleEndian);
 366
 367     virtual ~X86ELFObjectWriter();
 368   protected:
 369     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 370                                   bool IsPCRel, bool IsRelocWithSymbol,
 371                                   int64_t Addend);
 372   };
 373
 374
 375   //===- ARMELFObjectWriter -------------------------------------------===//
 376
 377   class ARMELFObjectWriter : public ELFObjectWriter {
 378   public:
 379     // FIXME: MCAssembler can't yet return the Subtarget,
 380     enum { DefaultEABIVersion = 0x05000000U };
 381
 382     ARMELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 383                        raw_ostream &_OS,
 384                        bool IsLittleEndian);
 385
 386     virtual ~ARMELFObjectWriter();
 387
 388     virtual void WriteEFlags();
 389   protected:
 390     virtual const MCSymbol *ExplicitRelSym(const MCAssembler &Asm,
 391                                            const MCValue &Target,
 392                                            const MCFragment &F,
 393                                            const MCFixup &Fixup,
 394                                            bool IsPCRel) const;
 395
 396     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 397                                   bool IsPCRel, bool IsRelocWithSymbol,
 398                                   int64_t Addend);
 399   private:
 400     unsigned GetRelocTypeInner(const MCValue &Target,
 401                                const MCFixup &Fixup, bool IsPCRel) const;
 402
 403   };
 404
 405   //===- PPCELFObjectWriter -------------------------------------------===//
 406
 407   class PPCELFObjectWriter : public ELFObjectWriter {
 408   public:
 409     PPCELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 410                           raw_ostream &_OS,
 411                           bool IsLittleEndian);
 412
 413     virtual ~PPCELFObjectWriter();
 414   protected:
 415     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 416                                   bool IsPCRel, bool IsRelocWithSymbol,
 417                                   int64_t Addend);
 418     virtual void adjustFixupOffset(const MCFixup &Fixup, uint64_t &RelocOffset);
 419   };
 420
 421   //===- MBlazeELFObjectWriter -------------------------------------------===//
 422
 423   class MBlazeELFObjectWriter : public ELFObjectWriter {
 424   public:
 425     MBlazeELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 426                           raw_ostream &_OS,
 427                           bool IsLittleEndian);
 428
 429     virtual ~MBlazeELFObjectWriter();
 430   protected:
 431     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 432                                   bool IsPCRel, bool IsRelocWithSymbol,
 433                                   int64_t Addend);
 434   };
 435
 436   //===- MipsELFObjectWriter -------------------------------------------===//
 437
 438   class MipsELFObjectWriter : public ELFObjectWriter {
 439   public:
 440     MipsELFObjectWriter(MCELFObjectTargetWriter *MOTW,
 441                         raw_ostream &_OS,
 442                         bool IsLittleEndian);
 443
 444     virtual ~MipsELFObjectWriter();
 445     virtual void WriteEFlags();
 446
 447   protected:
 448     virtual unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
 449                                   bool IsPCRel, bool IsRelocWithSymbol,
 450                                   int64_t Addend);
 451   };
 452 }
 453
 454 #endif