lld/COFF/Symbols.h

   1 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLD_COFF_SYMBOLS_H
  10 #define LLD_COFF_SYMBOLS_H
  11
  12 #include "Chunks.h"
  13 #include "Config.h"
  14 #include "lld/Common/LLVM.h"
  15 #include "lld/Common/Memory.h"
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/Object/Archive.h"
  18 #include "llvm/Object/COFF.h"
  19 #include <atomic>
  20 #include <memory>
  21 #include <vector>
  22
  23 namespace lld {
  24
  25 namespace coff {
  26
  27 using llvm::object::Archive;
  28 using llvm::object::COFFSymbolRef;
  29 using llvm::object::coff_import_header;
  30 using llvm::object::coff_symbol_generic;
  31
  32 class ArchiveFile;
  33 class COFFLinkerContext;
  34 class InputFile;
  35 class ObjFile;
  36 class SymbolTable;
  37
  38 // The base class for real symbol classes.
  39 class Symbol {
  40 public:
  41   enum Kind {
  42     // The order of these is significant. We start with the regular defined
  43     // symbols as those are the most prevalent and the zero tag is the cheapest
  44     // to set. Among the defined kinds, the lower the kind is preferred over
  45     // the higher kind when testing whether one symbol should take precedence
  46     // over another.
  47     DefinedRegularKind = 0,
  48     DefinedCommonKind,
  49     DefinedLocalImportKind,
  50     DefinedImportThunkKind,
  51     DefinedImportDataKind,
  52     DefinedAbsoluteKind,
  53     DefinedSyntheticKind,
  54
  55     UndefinedKind,
  56     LazyArchiveKind,
  57     LazyObjectKind,
  58     LazyDLLSymbolKind,
  59
  60     LastDefinedCOFFKind = DefinedCommonKind,
  61     LastDefinedKind = DefinedSyntheticKind,
  62   };
  63
  64   Kind kind() const { return static_cast<Kind>(symbolKind); }
  65
  66   // Returns the symbol name.
  67   StringRef getName() {
  68     // COFF symbol names are read lazily for a performance reason.
  69     // Non-external symbol names are never used by the linker except for logging
  70     // or debugging. Their internal references are resolved not by name but by
  71     // symbol index. And because they are not external, no one can refer them by
  72     // name. Object files contain lots of non-external symbols, and creating
  73     // StringRefs for them (which involves lots of strlen() on the string table)
  74     // is a waste of time.
  75     if (nameData == nullptr)
  76       computeName();
  77     return StringRef(nameData, nameSize);
  78   }
  79
  80   void replaceKeepingName(Symbol *other, size_t size);
  81
  82   // Returns the file from which this symbol was created.
  83   InputFile *getFile();
  84
  85   // Indicates that this symbol will be included in the final image. Only valid
  86   // after calling markLive.
  87   bool isLive() const;
  88
  89   bool isLazy() const {
  90     return symbolKind == LazyArchiveKind || symbolKind == LazyObjectKind ||
  91            symbolKind == LazyDLLSymbolKind;
  92   }
  93
  94 private:
  95   void computeName();
  96
  97 protected:
  98   friend SymbolTable;
  99   explicit Symbol(Kind k, StringRef n = "")
 100       : symbolKind(k), isExternal(true), isCOMDAT(false),
 101         writtenToSymtab(false), pendingArchiveLoad(false), isGCRoot(false),
 102         isRuntimePseudoReloc(false), deferUndefined(false), canInline(true),
 103         isWeak(false), nameSize(n.size()),
 104         nameData(n.empty() ? nullptr : n.data()) {
 105     assert((!n.empty() || k <= LastDefinedCOFFKind) &&
 106            "If the name is empty, the Symbol must be a DefinedCOFF.");
 107   }
 108
 109   const unsigned symbolKind : 8;
 110   unsigned isExternal : 1;
 111
 112 public:
 113   // This bit is used by the \c DefinedRegular subclass.
 114   unsigned isCOMDAT : 1;
 115
 116   // This bit is used by Writer::createSymbolAndStringTable() to prevent
 117   // symbols from being written to the symbol table more than once.
 118   unsigned writtenToSymtab : 1;
 119
 120   // True if this symbol was referenced by a regular (non-bitcode) object.
 121   unsigned isUsedInRegularObj : 1;
 122
 123   // True if we've seen both a lazy and an undefined symbol with this symbol
 124   // name, which means that we have enqueued an archive member load and should
 125   // not load any more archive members to resolve the same symbol.
 126   unsigned pendingArchiveLoad : 1;
 127
 128   /// True if we've already added this symbol to the list of GC roots.
 129   unsigned isGCRoot : 1;
 130
 131   unsigned isRuntimePseudoReloc : 1;
 132
 133   // True if we want to allow this symbol to be undefined in the early
 134   // undefined check pass in SymbolTable::reportUnresolvable(), as it
 135   // might be fixed up later.
 136   unsigned deferUndefined : 1;
 137
 138   // False if LTO shouldn't inline whatever this symbol points to. If a symbol
 139   // is overwritten after LTO, LTO shouldn't inline the symbol because it
 140   // doesn't know the final contents of the symbol.
 141   unsigned canInline : 1;
 142
 143   // True if the symbol is weak. This is only tracked for bitcode/LTO symbols.
 144   // This information isn't written to the output; rather, it's used for
 145   // managing weak symbol overrides.
 146   unsigned isWeak : 1;
 147
 148 protected:
 149   // Symbol name length. Assume symbol lengths fit in a 32-bit integer.
 150   uint32_t nameSize;
 151
 152   const char *nameData;
 153 };
 154
 155 // The base class for any defined symbols, including absolute symbols,
 156 // etc.
 157 class Defined : public Symbol {
 158 public:
 159   Defined(Kind k, StringRef n) : Symbol(k, n) {}
 160
 161   static bool classof(const Symbol *s) { return s->kind() <= LastDefinedKind; }
 162
 163   // Returns the RVA (relative virtual address) of this symbol. The
 164   // writer sets and uses RVAs.
 165   uint64_t getRVA();
 166
 167   // Returns the chunk containing this symbol. Absolute symbols and __ImageBase
 168   // do not have chunks, so this may return null.
 169   Chunk *getChunk();
 170 };
 171
 172 // Symbols defined via a COFF object file or bitcode file.  For COFF files, this
 173 // stores a coff_symbol_generic*, and names of internal symbols are lazily
 174 // loaded through that. For bitcode files, Sym is nullptr and the name is stored
 175 // as a decomposed StringRef.
 176 class DefinedCOFF : public Defined {
 177   friend Symbol;
 178
 179 public:
 180   DefinedCOFF(Kind k, InputFile *f, StringRef n, const coff_symbol_generic *s)
 181       : Defined(k, n), file(f), sym(s) {}
 182
 183   static bool classof(const Symbol *s) {
 184     return s->kind() <= LastDefinedCOFFKind;
 185   }
 186
 187   InputFile *getFile() { return file; }
 188
 189   COFFSymbolRef getCOFFSymbol();
 190
 191   InputFile *file;
 192
 193 protected:
 194   const coff_symbol_generic *sym;
 195 };
 196
 197 // Regular defined symbols read from object file symbol tables.
 198 class DefinedRegular : public DefinedCOFF {
 199 public:
 200   DefinedRegular(InputFile *f, StringRef n, bool isCOMDAT,
 201                  bool isExternal = false,
 202                  const coff_symbol_generic *s = nullptr,
 203                  SectionChunk *c = nullptr, bool isWeak = false)
 204       : DefinedCOFF(DefinedRegularKind, f, n, s), data(c ? &c->repl : nullptr) {
 205     this->isExternal = isExternal;
 206     this->isCOMDAT = isCOMDAT;
 207     this->isWeak = isWeak;
 208   }
 209
 210   static bool classof(const Symbol *s) {
 211     return s->kind() == DefinedRegularKind;
 212   }
 213
 214   uint64_t getRVA() const { return (*data)->getRVA() + sym->Value; }
 215   SectionChunk *getChunk() const { return *data; }
 216   uint32_t getValue() const { return sym->Value; }
 217
 218   SectionChunk **data;
 219 };
 220
 221 class DefinedCommon : public DefinedCOFF {
 222 public:
 223   DefinedCommon(InputFile *f, StringRef n, uint64_t size,
 224                 const coff_symbol_generic *s = nullptr,
 225                 CommonChunk *c = nullptr)
 226       : DefinedCOFF(DefinedCommonKind, f, n, s), data(c), size(size) {
 227     this->isExternal = true;
 228   }
 229
 230   static bool classof(const Symbol *s) {
 231     return s->kind() == DefinedCommonKind;
 232   }
 233
 234   uint64_t getRVA() { return data->getRVA(); }
 235   CommonChunk *getChunk() { return data; }
 236
 237 private:
 238   friend SymbolTable;
 239   uint64_t getSize() const { return size; }
 240   CommonChunk *data;
 241   uint64_t size;
 242 };
 243
 244 // Absolute symbols.
 245 class DefinedAbsolute : public Defined {
 246 public:
 247   DefinedAbsolute(const COFFLinkerContext &c, StringRef n, COFFSymbolRef s)
 248       : Defined(DefinedAbsoluteKind, n), va(s.getValue()), ctx(c) {
 249     isExternal = s.isExternal();
 250   }
 251
 252   DefinedAbsolute(const COFFLinkerContext &c, StringRef n, uint64_t v)
 253       : Defined(DefinedAbsoluteKind, n), va(v), ctx(c) {}
 254
 255   static bool classof(const Symbol *s) {
 256     return s->kind() == DefinedAbsoluteKind;
 257   }
 258
 259   uint64_t getRVA();
 260   void setVA(uint64_t v) { va = v; }
 261   uint64_t getVA() const { return va; }
 262
 263 private:
 264   uint64_t va;
 265   const COFFLinkerContext &ctx;
 266 };
 267
 268 // This symbol is used for linker-synthesized symbols like __ImageBase and
 269 // __safe_se_handler_table.
 270 class DefinedSynthetic : public Defined {
 271 public:
 272   explicit DefinedSynthetic(StringRef name, Chunk *c)
 273       : Defined(DefinedSyntheticKind, name), c(c) {}
 274
 275   static bool classof(const Symbol *s) {
 276     return s->kind() == DefinedSyntheticKind;
 277   }
 278
 279   // A null chunk indicates that this is __ImageBase. Otherwise, this is some
 280   // other synthesized chunk, like SEHTableChunk.
 281   uint32_t getRVA() { return c ? c->getRVA() : 0; }
 282   Chunk *getChunk() { return c; }
 283
 284 private:
 285   Chunk *c;
 286 };
 287
 288 // This class represents a symbol defined in an archive file. It is
 289 // created from an archive file header, and it knows how to load an
 290 // object file from an archive to replace itself with a defined
 291 // symbol. If the resolver finds both Undefined and LazyArchive for
 292 // the same name, it will ask the LazyArchive to load a file.
 293 class LazyArchive : public Symbol {
 294 public:
 295   LazyArchive(ArchiveFile *f, const Archive::Symbol s)
 296       : Symbol(LazyArchiveKind, s.getName()), file(f), sym(s) {}
 297
 298   static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
 299
 300   MemoryBufferRef getMemberBuffer();
 301
 302   ArchiveFile *file;
 303   const Archive::Symbol sym;
 304 };
 305
 306 class LazyObject : public Symbol {
 307 public:
 308   LazyObject(InputFile *f, StringRef n) : Symbol(LazyObjectKind, n), file(f) {}
 309   static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
 310   InputFile *file;
 311 };
 312
 313 // MinGW only.
 314 class LazyDLLSymbol : public Symbol {
 315 public:
 316   LazyDLLSymbol(DLLFile *f, DLLFile::Symbol *s, StringRef n)
 317       : Symbol(LazyDLLSymbolKind, n), file(f), sym(s) {}
 318   static bool classof(const Symbol *s) {
 319     return s->kind() == LazyDLLSymbolKind;
 320   }
 321
 322   DLLFile *file;
 323   DLLFile::Symbol *sym;
 324 };
 325
 326 // Undefined symbols.
 327 class Undefined : public Symbol {
 328 public:
 329   explicit Undefined(StringRef n) : Symbol(UndefinedKind, n) {}
 330
 331   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 332
 333   // An undefined symbol can have a fallback symbol which gives an
 334   // undefined symbol a second chance if it would remain undefined.
 335   // If it remains undefined, it'll be replaced with whatever the
 336   // Alias pointer points to.
 337   Symbol *weakAlias = nullptr;
 338
 339   // If this symbol is external weak, try to resolve it to a defined
 340   // symbol by searching the chain of fallback symbols. Returns the symbol if
 341   // successful, otherwise returns null.
 342   Defined *getWeakAlias();
 343 };
 344
 345 // Windows-specific classes.
 346
 347 // This class represents a symbol imported from a DLL. This has two
 348 // names for internal use and external use. The former is used for
 349 // name resolution, and the latter is used for the import descriptor
 350 // table in an output. The former has "__imp_" prefix.
 351 class DefinedImportData : public Defined {
 352 public:
 353   DefinedImportData(StringRef n, ImportFile *f)
 354       : Defined(DefinedImportDataKind, n), file(f) {
 355   }
 356
 357   static bool classof(const Symbol *s) {
 358     return s->kind() == DefinedImportDataKind;
 359   }
 360
 361   uint64_t getRVA() { return file->location->getRVA(); }
 362   Chunk *getChunk() { return file->location; }
 363   void setLocation(Chunk *addressTable) { file->location = addressTable; }
 364
 365   StringRef getDLLName() { return file->dllName; }
 366   StringRef getExternalName() { return file->externalName; }
 367   uint16_t getOrdinal() { return file->hdr->OrdinalHint; }
 368
 369   ImportFile *file;
 370
 371   // This is a pointer to the synthetic symbol associated with the load thunk
 372   // for this symbol that will be called if the DLL is delay-loaded. This is
 373   // needed for Control Flow Guard because if this DefinedImportData symbol is a
 374   // valid call target, the corresponding load thunk must also be marked as a
 375   // valid call target.
 376   DefinedSynthetic *loadThunkSym = nullptr;
 377 };
 378
 379 // This class represents a symbol for a jump table entry which jumps
 380 // to a function in a DLL. Linker are supposed to create such symbols
 381 // without "__imp_" prefix for all function symbols exported from
 382 // DLLs, so that you can call DLL functions as regular functions with
 383 // a regular name. A function pointer is given as a DefinedImportData.
 384 class DefinedImportThunk : public Defined {
 385 public:
 386   DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
 387                      DefinedImportData *s, uint16_t machine);
 388
 389   static bool classof(const Symbol *s) {
 390     return s->kind() == DefinedImportThunkKind;
 391   }
 392
 393   uint64_t getRVA() { return data->getRVA(); }
 394   Chunk *getChunk() { return data; }
 395
 396   DefinedImportData *wrappedSym;
 397
 398 private:
 399   Chunk *data;
 400 };
 401
 402 // If you have a symbol "foo" in your object file, a symbol name
 403 // "__imp_foo" becomes automatically available as a pointer to "foo".
 404 // This class is for such automatically-created symbols.
 405 // Yes, this is an odd feature. We didn't intend to implement that.
 406 // This is here just for compatibility with MSVC.
 407 class DefinedLocalImport : public Defined {
 408 public:
 409   DefinedLocalImport(COFFLinkerContext &ctx, StringRef n, Defined *s)
 410       : Defined(DefinedLocalImportKind, n),
 411         data(make<LocalImportChunk>(ctx, s)) {}
 412
 413   static bool classof(const Symbol *s) {
 414     return s->kind() == DefinedLocalImportKind;
 415   }
 416
 417   uint64_t getRVA() { return data->getRVA(); }
 418   Chunk *getChunk() { return data; }
 419
 420 private:
 421   LocalImportChunk *data;
 422 };
 423
 424 inline uint64_t Defined::getRVA() {
 425   switch (kind()) {
 426   case DefinedAbsoluteKind:
 427     return cast<DefinedAbsolute>(this)->getRVA();
 428   case DefinedSyntheticKind:
 429     return cast<DefinedSynthetic>(this)->getRVA();
 430   case DefinedImportDataKind:
 431     return cast<DefinedImportData>(this)->getRVA();
 432   case DefinedImportThunkKind:
 433     return cast<DefinedImportThunk>(this)->getRVA();
 434   case DefinedLocalImportKind:
 435     return cast<DefinedLocalImport>(this)->getRVA();
 436   case DefinedCommonKind:
 437     return cast<DefinedCommon>(this)->getRVA();
 438   case DefinedRegularKind:
 439     return cast<DefinedRegular>(this)->getRVA();
 440   case LazyArchiveKind:
 441   case LazyObjectKind:
 442   case LazyDLLSymbolKind:
 443   case UndefinedKind:
 444     llvm_unreachable("Cannot get the address for an undefined symbol.");
 445   }
 446   llvm_unreachable("unknown symbol kind");
 447 }
 448
 449 inline Chunk *Defined::getChunk() {
 450   switch (kind()) {
 451   case DefinedRegularKind:
 452     return cast<DefinedRegular>(this)->getChunk();
 453   case DefinedAbsoluteKind:
 454     return nullptr;
 455   case DefinedSyntheticKind:
 456     return cast<DefinedSynthetic>(this)->getChunk();
 457   case DefinedImportDataKind:
 458     return cast<DefinedImportData>(this)->getChunk();
 459   case DefinedImportThunkKind:
 460     return cast<DefinedImportThunk>(this)->getChunk();
 461   case DefinedLocalImportKind:
 462     return cast<DefinedLocalImport>(this)->getChunk();
 463   case DefinedCommonKind:
 464     return cast<DefinedCommon>(this)->getChunk();
 465   case LazyArchiveKind:
 466   case LazyObjectKind:
 467   case LazyDLLSymbolKind:
 468   case UndefinedKind:
 469     llvm_unreachable("Cannot get the chunk of an undefined symbol.");
 470   }
 471   llvm_unreachable("unknown symbol kind");
 472 }
 473
 474 // A buffer class that is large enough to hold any Symbol-derived
 475 // object. We allocate memory using this class and instantiate a symbol
 476 // using the placement new.
 477 union SymbolUnion {
 478   alignas(DefinedRegular) char a[sizeof(DefinedRegular)];
 479   alignas(DefinedCommon) char b[sizeof(DefinedCommon)];
 480   alignas(DefinedAbsolute) char c[sizeof(DefinedAbsolute)];
 481   alignas(DefinedSynthetic) char d[sizeof(DefinedSynthetic)];
 482   alignas(LazyArchive) char e[sizeof(LazyArchive)];
 483   alignas(Undefined) char f[sizeof(Undefined)];
 484   alignas(DefinedImportData) char g[sizeof(DefinedImportData)];
 485   alignas(DefinedImportThunk) char h[sizeof(DefinedImportThunk)];
 486   alignas(DefinedLocalImport) char i[sizeof(DefinedLocalImport)];
 487   alignas(LazyObject) char j[sizeof(LazyObject)];
 488   alignas(LazyDLLSymbol) char k[sizeof(LazyDLLSymbol)];
 489 };
 490
 491 template <typename T, typename... ArgT>
 492 void replaceSymbol(Symbol *s, ArgT &&... arg) {
 493   static_assert(std::is_trivially_destructible<T>(),
 494                 "Symbol types must be trivially destructible");
 495   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
 496   static_assert(alignof(T) <= alignof(SymbolUnion),
 497                 "SymbolUnion not aligned enough");
 498   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
 499          "Not a Symbol");
 500   bool canInline = s->canInline;
 501   new (s) T(std::forward<ArgT>(arg)...);
 502   s->canInline = canInline;
 503 }
 504 } // namespace coff
 505
 506 std::string toString(const coff::COFFLinkerContext &ctx, coff::Symbol &b);
 507 std::string toCOFFString(const coff::COFFLinkerContext &ctx,
 508                          const llvm::object::Archive::Symbol &b);
 509
 510 } // namespace lld
 511
 512 #endif