contrib/llvm/tools/lld/ELF/InputFiles.h

   1 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLD_ELF_INPUT_FILES_H
  11 #define LLD_ELF_INPUT_FILES_H
  12
  13 #include "Config.h"
  14 #include "lld/Common/ErrorHandler.h"
  15 #include "lld/Common/LLVM.h"
  16 #include "lld/Common/Reproduce.h"
  17 #include "llvm/ADT/CachedHashString.h"
  18 #include "llvm/ADT/DenseSet.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
  21 #include "llvm/IR/Comdat.h"
  22 #include "llvm/Object/Archive.h"
  23 #include "llvm/Object/ELF.h"
  24 #include "llvm/Object/IRObjectFile.h"
  25 #include "llvm/Support/Threading.h"
  26 #include <map>
  27
  28 namespace llvm {
  29 class TarWriter;
  30 struct DILineInfo;
  31 namespace lto {
  32 class InputFile;
  33 }
  34 } // namespace llvm
  35
  36 namespace lld {
  37 namespace elf {
  38 class InputFile;
  39 class InputSectionBase;
  40 }
  41
  42 // Returns "<internal>", "foo.a(bar.o)" or "baz.o".
  43 std::string toString(const elf::InputFile *F);
  44
  45 namespace elf {
  46
  47 using llvm::object::Archive;
  48
  49 class Symbol;
  50
  51 // If -reproduce option is given, all input files are written
  52 // to this tar archive.
  53 extern std::unique_ptr<llvm::TarWriter> Tar;
  54
  55 // Opens a given file.
  56 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
  57
  58 // The root class of input files.
  59 class InputFile {
  60 public:
  61   enum Kind {
  62     ObjKind,
  63     SharedKind,
  64     LazyObjKind,
  65     ArchiveKind,
  66     BitcodeKind,
  67     BinaryKind,
  68   };
  69
  70   Kind kind() const { return FileKind; }
  71
  72   bool isElf() const {
  73     Kind K = kind();
  74     return K == ObjKind || K == SharedKind;
  75   }
  76
  77   StringRef getName() const { return MB.getBufferIdentifier(); }
  78   MemoryBufferRef MB;
  79
  80   // Returns sections. It is a runtime error to call this function
  81   // on files that don't have the notion of sections.
  82   ArrayRef<InputSectionBase *> getSections() const {
  83     assert(FileKind == ObjKind || FileKind == BinaryKind);
  84     return Sections;
  85   }
  86
  87   // Returns object file symbols. It is a runtime error to call this
  88   // function on files of other types.
  89   ArrayRef<Symbol *> getSymbols() { return getMutableSymbols(); }
  90
  91   std::vector<Symbol *> &getMutableSymbols() {
  92     assert(FileKind == BinaryKind || FileKind == ObjKind ||
  93            FileKind == BitcodeKind);
  94     return Symbols;
  95   }
  96
  97   // Filename of .a which contained this file. If this file was
  98   // not in an archive file, it is the empty string. We use this
  99   // string for creating error messages.
 100   std::string ArchiveName;
 101
 102   // If this is an architecture-specific file, the following members
 103   // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
 104   ELFKind EKind = ELFNoneKind;
 105   uint16_t EMachine = llvm::ELF::EM_NONE;
 106   uint8_t OSABI = 0;
 107
 108   // Cache for toString(). Only toString() should use this member.
 109   mutable std::string ToStringCache;
 110
 111   std::string getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
 112                         uint64_t Offset);
 113
 114   // True if this is an argument for --just-symbols. Usually false.
 115   bool JustSymbols = false;
 116
 117   // GroupId is used for --warn-backrefs which is an optional error
 118   // checking feature. All files within the same --{start,end}-group or
 119   // --{start,end}-lib get the same group ID. Otherwise, each file gets a new
 120   // group ID. For more info, see checkDependency() in SymbolTable.cpp.
 121   uint32_t GroupId;
 122   static bool IsInGroup;
 123   static uint32_t NextGroupId;
 124
 125   // Index of MIPS GOT built for this file.
 126   llvm::Optional<size_t> MipsGotIndex;
 127
 128 protected:
 129   InputFile(Kind K, MemoryBufferRef M);
 130   std::vector<InputSectionBase *> Sections;
 131   std::vector<Symbol *> Symbols;
 132
 133 private:
 134   const Kind FileKind;
 135 };
 136
 137 template <typename ELFT> class ELFFileBase : public InputFile {
 138 public:
 139   typedef typename ELFT::Shdr Elf_Shdr;
 140   typedef typename ELFT::Sym Elf_Sym;
 141   typedef typename ELFT::Word Elf_Word;
 142   typedef typename ELFT::SymRange Elf_Sym_Range;
 143
 144   ELFFileBase(Kind K, MemoryBufferRef M);
 145   static bool classof(const InputFile *F) { return F->isElf(); }
 146
 147   llvm::object::ELFFile<ELFT> getObj() const {
 148     return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
 149   }
 150
 151   StringRef getStringTable() const { return StringTable; }
 152
 153   uint32_t getSectionIndex(const Elf_Sym &Sym) const;
 154
 155   Elf_Sym_Range getGlobalELFSyms();
 156   Elf_Sym_Range getELFSyms() const { return ELFSyms; }
 157
 158 protected:
 159   ArrayRef<Elf_Sym> ELFSyms;
 160   uint32_t FirstGlobal = 0;
 161   ArrayRef<Elf_Word> SymtabSHNDX;
 162   StringRef StringTable;
 163   void initSymtab(ArrayRef<Elf_Shdr> Sections, const Elf_Shdr *Symtab);
 164 };
 165
 166 // .o file.
 167 template <class ELFT> class ObjFile : public ELFFileBase<ELFT> {
 168   typedef ELFFileBase<ELFT> Base;
 169   typedef typename ELFT::Rel Elf_Rel;
 170   typedef typename ELFT::Rela Elf_Rela;
 171   typedef typename ELFT::Sym Elf_Sym;
 172   typedef typename ELFT::Shdr Elf_Shdr;
 173   typedef typename ELFT::Word Elf_Word;
 174   typedef typename ELFT::CGProfile Elf_CGProfile;
 175
 176   StringRef getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
 177                                  const Elf_Shdr &Sec);
 178
 179 public:
 180   static bool classof(const InputFile *F) { return F->kind() == Base::ObjKind; }
 181
 182   ArrayRef<Symbol *> getLocalSymbols();
 183   ArrayRef<Symbol *> getGlobalSymbols();
 184
 185   ObjFile(MemoryBufferRef M, StringRef ArchiveName);
 186   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 187
 188   Symbol &getSymbol(uint32_t SymbolIndex) const {
 189     if (SymbolIndex >= this->Symbols.size())
 190       fatal(toString(this) + ": invalid symbol index");
 191     return *this->Symbols[SymbolIndex];
 192   }
 193
 194   template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
 195     uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
 196     return getSymbol(SymIndex);
 197   }
 198
 199   llvm::Optional<llvm::DILineInfo> getDILineInfo(InputSectionBase *, uint64_t);
 200   llvm::Optional<std::pair<std::string, unsigned>> getVariableLoc(StringRef Name);
 201
 202   // MIPS GP0 value defined by this file. This value represents the gp value
 203   // used to create the relocatable object and required to support
 204   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
 205   uint32_t MipsGp0 = 0;
 206
 207   // Name of source file obtained from STT_FILE symbol value,
 208   // or empty string if there is no such symbol in object file
 209   // symbol table.
 210   StringRef SourceFile;
 211
 212   // True if the file defines functions compiled with
 213   // -fsplit-stack. Usually false.
 214   bool SplitStack = false;
 215
 216   // True if the file defines functions compiled with -fsplit-stack,
 217   // but had one or more functions with the no_split_stack attribute.
 218   bool SomeNoSplitStack = false;
 219
 220   // Pointer to this input file's .llvm_addrsig section, if it has one.
 221   const Elf_Shdr *AddrsigSec = nullptr;
 222
 223   // SHT_LLVM_CALL_GRAPH_PROFILE table
 224   ArrayRef<Elf_CGProfile> CGProfile;
 225
 226 private:
 227   void
 228   initializeSections(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 229   void initializeSymbols();
 230   void initializeJustSymbols();
 231   void initializeDwarf();
 232   InputSectionBase *getRelocTarget(const Elf_Shdr &Sec);
 233   InputSectionBase *createInputSection(const Elf_Shdr &Sec);
 234   StringRef getSectionName(const Elf_Shdr &Sec);
 235
 236   bool shouldMerge(const Elf_Shdr &Sec);
 237   Symbol *createSymbol(const Elf_Sym *Sym);
 238
 239   // .shstrtab contents.
 240   StringRef SectionStringTable;
 241
 242   // Debugging information to retrieve source file and line for error
 243   // reporting. Linker may find reasonable number of errors in a
 244   // single object file, so we cache debugging information in order to
 245   // parse it only once for each object file we link.
 246   std::unique_ptr<llvm::DWARFContext> Dwarf;
 247   std::vector<const llvm::DWARFDebugLine::LineTable *> LineTables;
 248   struct VarLoc {
 249     const llvm::DWARFDebugLine::LineTable *LT;
 250     unsigned File;
 251     unsigned Line;
 252   };
 253   llvm::DenseMap<StringRef, VarLoc> VariableLoc;
 254   llvm::once_flag InitDwarfLine;
 255 };
 256
 257 // LazyObjFile is analogous to ArchiveFile in the sense that
 258 // the file contains lazy symbols. The difference is that
 259 // LazyObjFile wraps a single file instead of multiple files.
 260 //
 261 // This class is used for --start-lib and --end-lib options which
 262 // instruct the linker to link object files between them with the
 263 // archive file semantics.
 264 class LazyObjFile : public InputFile {
 265 public:
 266   LazyObjFile(MemoryBufferRef M, StringRef ArchiveName,
 267               uint64_t OffsetInArchive)
 268       : InputFile(LazyObjKind, M), OffsetInArchive(OffsetInArchive) {
 269     this->ArchiveName = ArchiveName;
 270   }
 271
 272   static bool classof(const InputFile *F) { return F->kind() == LazyObjKind; }
 273
 274   template <class ELFT> void parse();
 275   MemoryBufferRef getBuffer();
 276   InputFile *fetch();
 277   bool AddedToLink = false;
 278
 279 private:
 280   uint64_t OffsetInArchive;
 281 };
 282
 283 // An ArchiveFile object represents a .a file.
 284 class ArchiveFile : public InputFile {
 285 public:
 286   explicit ArchiveFile(std::unique_ptr<Archive> &&File);
 287   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
 288   template <class ELFT> void parse();
 289
 290   // Pulls out an object file that contains a definition for Sym and
 291   // returns it. If the same file was instantiated before, this
 292   // function returns a nullptr (so we don't instantiate the same file
 293   // more than once.)
 294   InputFile *fetch(const Archive::Symbol &Sym);
 295
 296 private:
 297   std::unique_ptr<Archive> File;
 298   llvm::DenseSet<uint64_t> Seen;
 299 };
 300
 301 class BitcodeFile : public InputFile {
 302 public:
 303   BitcodeFile(MemoryBufferRef M, StringRef ArchiveName,
 304               uint64_t OffsetInArchive);
 305   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
 306   template <class ELFT>
 307   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 308   std::unique_ptr<llvm::lto::InputFile> Obj;
 309 };
 310
 311 // .so file.
 312 template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
 313   typedef ELFFileBase<ELFT> Base;
 314   typedef typename ELFT::Dyn Elf_Dyn;
 315   typedef typename ELFT::Shdr Elf_Shdr;
 316   typedef typename ELFT::Sym Elf_Sym;
 317   typedef typename ELFT::SymRange Elf_Sym_Range;
 318   typedef typename ELFT::Verdef Elf_Verdef;
 319   typedef typename ELFT::Versym Elf_Versym;
 320
 321   const Elf_Shdr *VersymSec = nullptr;
 322   const Elf_Shdr *VerdefSec = nullptr;
 323
 324 public:
 325   std::vector<const Elf_Verdef *> Verdefs;
 326   std::vector<StringRef> DtNeeded;
 327   std::string SoName;
 328
 329   static bool classof(const InputFile *F) {
 330     return F->kind() == Base::SharedKind;
 331   }
 332
 333   SharedFile(MemoryBufferRef M, StringRef DefaultSoName);
 334
 335   void parseDynamic();
 336   void parseRest();
 337   uint32_t getAlignment(ArrayRef<Elf_Shdr> Sections, const Elf_Sym &Sym);
 338   std::vector<const Elf_Verdef *> parseVerdefs();
 339   std::vector<uint32_t> parseVersyms();
 340
 341   struct NeededVer {
 342     // The string table offset of the version name in the output file.
 343     size_t StrTab;
 344
 345     // The version identifier for this version name.
 346     uint16_t Index;
 347   };
 348
 349   // Mapping from Elf_Verdef data structures to information about Elf_Vernaux
 350   // data structures in the output file.
 351   std::map<const Elf_Verdef *, NeededVer> VerdefMap;
 352
 353   // Used for --no-allow-shlib-undefined.
 354   bool AllNeededIsKnown;
 355
 356   // Used for --as-needed
 357   bool IsNeeded;
 358 };
 359
 360 class BinaryFile : public InputFile {
 361 public:
 362   explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
 363   static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
 364   void parse();
 365 };
 366
 367 InputFile *createObjectFile(MemoryBufferRef MB, StringRef ArchiveName = "",
 368                             uint64_t OffsetInArchive = 0);
 369 InputFile *createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName);
 370
 371 inline bool isBitcode(MemoryBufferRef MB) {
 372   return identify_magic(MB.getBuffer()) == llvm::file_magic::bitcode;
 373 }
 374
 375 std::string replaceThinLTOSuffix(StringRef Path);
 376
 377 extern std::vector<BinaryFile *> BinaryFiles;
 378 extern std::vector<BitcodeFile *> BitcodeFiles;
 379 extern std::vector<LazyObjFile *> LazyObjFiles;
 380 extern std::vector<InputFile *> ObjectFiles;
 381 extern std::vector<InputFile *> SharedFiles;
 382
 383 } // namespace elf
 384 } // namespace lld
 385
 386 #endif