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), isUsedInRegularObj(false),
 102         pendingArchiveLoad(false), isGCRoot(false), isRuntimePseudoReloc(false),
 103         deferUndefined(false), canInline(true), isWeak(false), isAntiDep(false),
 104         nameSize(n.size()), 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   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   // True if the symbol is an anti-dependency.
 149   unsigned isAntiDep : 1;
 150
 151 protected:
 152   // Symbol name length. Assume symbol lengths fit in a 32-bit integer.
 153   uint32_t nameSize;
 154
 155   const char *nameData;
 156 };
 157
 158 // The base class for any defined symbols, including absolute symbols,
 159 // etc.
 160 class Defined : public Symbol {
 161 public:
 162   Defined(Kind k, StringRef n) : Symbol(k, n) {}
 163
 164   static bool classof(const Symbol *s) { return s->kind() <= LastDefinedKind; }
 165
 166   // Returns the RVA (relative virtual address) of this symbol. The
 167   // writer sets and uses RVAs.
 168   uint64_t getRVA();
 169
 170   // Returns the chunk containing this symbol. Absolute symbols and __ImageBase
 171   // do not have chunks, so this may return null.
 172   Chunk *getChunk();
 173 };
 174
 175 // Symbols defined via a COFF object file or bitcode file.  For COFF files, this
 176 // stores a coff_symbol_generic*, and names of internal symbols are lazily
 177 // loaded through that. For bitcode files, Sym is nullptr and the name is stored
 178 // as a decomposed StringRef.
 179 class DefinedCOFF : public Defined {
 180   friend Symbol;
 181
 182 public:
 183   DefinedCOFF(Kind k, InputFile *f, StringRef n, const coff_symbol_generic *s)
 184       : Defined(k, n), file(f), sym(s) {}
 185
 186   static bool classof(const Symbol *s) {
 187     return s->kind() <= LastDefinedCOFFKind;
 188   }
 189
 190   InputFile *getFile() { return file; }
 191
 192   COFFSymbolRef getCOFFSymbol();
 193
 194   InputFile *file;
 195
 196 protected:
 197   const coff_symbol_generic *sym;
 198 };
 199
 200 // Regular defined symbols read from object file symbol tables.
 201 class DefinedRegular : public DefinedCOFF {
 202 public:
 203   DefinedRegular(InputFile *f, StringRef n, bool isCOMDAT,
 204                  bool isExternal = false,
 205                  const coff_symbol_generic *s = nullptr,
 206                  SectionChunk *c = nullptr, bool isWeak = false)
 207       : DefinedCOFF(DefinedRegularKind, f, n, s), data(c ? &c->repl : nullptr) {
 208     this->isExternal = isExternal;
 209     this->isCOMDAT = isCOMDAT;
 210     this->isWeak = isWeak;
 211   }
 212
 213   static bool classof(const Symbol *s) {
 214     return s->kind() == DefinedRegularKind;
 215   }
 216
 217   uint64_t getRVA() const { return (*data)->getRVA() + sym->Value; }
 218   SectionChunk *getChunk() const { return *data; }
 219   uint32_t getValue() const { return sym->Value; }
 220
 221   SectionChunk **data;
 222 };
 223
 224 class DefinedCommon : public DefinedCOFF {
 225 public:
 226   DefinedCommon(InputFile *f, StringRef n, uint64_t size,
 227                 const coff_symbol_generic *s = nullptr,
 228                 CommonChunk *c = nullptr)
 229       : DefinedCOFF(DefinedCommonKind, f, n, s), data(c), size(size) {
 230     this->isExternal = true;
 231   }
 232
 233   static bool classof(const Symbol *s) {
 234     return s->kind() == DefinedCommonKind;
 235   }
 236
 237   uint64_t getRVA() { return data->getRVA(); }
 238   CommonChunk *getChunk() { return data; }
 239
 240 private:
 241   friend SymbolTable;
 242   uint64_t getSize() const { return size; }
 243   CommonChunk *data;
 244   uint64_t size;
 245 };
 246
 247 // Absolute symbols.
 248 class DefinedAbsolute : public Defined {
 249 public:
 250   DefinedAbsolute(const COFFLinkerContext &c, StringRef n, COFFSymbolRef s)
 251       : Defined(DefinedAbsoluteKind, n), va(s.getValue()), ctx(c) {
 252     isExternal = s.isExternal();
 253   }
 254
 255   DefinedAbsolute(const COFFLinkerContext &c, StringRef n, uint64_t v)
 256       : Defined(DefinedAbsoluteKind, n), va(v), ctx(c) {}
 257
 258   static bool classof(const Symbol *s) {
 259     return s->kind() == DefinedAbsoluteKind;
 260   }
 261
 262   uint64_t getRVA();
 263   void setVA(uint64_t v) { va = v; }
 264   uint64_t getVA() const { return va; }
 265
 266 private:
 267   uint64_t va;
 268   const COFFLinkerContext &ctx;
 269 };
 270
 271 // This symbol is used for linker-synthesized symbols like __ImageBase and
 272 // __safe_se_handler_table.
 273 class DefinedSynthetic : public Defined {
 274 public:
 275   explicit DefinedSynthetic(StringRef name, Chunk *c, uint32_t offset = 0)
 276       : Defined(DefinedSyntheticKind, name), c(c), offset(offset) {}
 277
 278   static bool classof(const Symbol *s) {
 279     return s->kind() == DefinedSyntheticKind;
 280   }
 281
 282   // A null chunk indicates that this is __ImageBase. Otherwise, this is some
 283   // other synthesized chunk, like SEHTableChunk.
 284   uint32_t getRVA() { return c ? c->getRVA() + offset : 0; }
 285   Chunk *getChunk() { return c; }
 286
 287 private:
 288   Chunk *c;
 289   uint32_t offset;
 290 };
 291
 292 // This class represents a symbol defined in an archive file. It is
 293 // created from an archive file header, and it knows how to load an
 294 // object file from an archive to replace itself with a defined
 295 // symbol. If the resolver finds both Undefined and LazyArchive for
 296 // the same name, it will ask the LazyArchive to load a file.
 297 class LazyArchive : public Symbol {
 298 public:
 299   LazyArchive(ArchiveFile *f, const Archive::Symbol s)
 300       : Symbol(LazyArchiveKind, s.getName()), file(f), sym(s) {}
 301
 302   static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
 303
 304   MemoryBufferRef getMemberBuffer();
 305
 306   ArchiveFile *file;
 307   const Archive::Symbol sym;
 308 };
 309
 310 class LazyObject : public Symbol {
 311 public:
 312   LazyObject(InputFile *f, StringRef n) : Symbol(LazyObjectKind, n), file(f) {}
 313   static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
 314   InputFile *file;
 315 };
 316
 317 // MinGW only.
 318 class LazyDLLSymbol : public Symbol {
 319 public:
 320   LazyDLLSymbol(DLLFile *f, DLLFile::Symbol *s, StringRef n)
 321       : Symbol(LazyDLLSymbolKind, n), file(f), sym(s) {}
 322   static bool classof(const Symbol *s) {
 323     return s->kind() == LazyDLLSymbolKind;
 324   }
 325
 326   DLLFile *file;
 327   DLLFile::Symbol *sym;
 328 };
 329
 330 // Undefined symbols.
 331 class Undefined : public Symbol {
 332 public:
 333   explicit Undefined(StringRef n) : Symbol(UndefinedKind, n) {}
 334
 335   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 336
 337   // An undefined symbol can have a fallback symbol which gives an
 338   // undefined symbol a second chance if it would remain undefined.
 339   // If it remains undefined, it'll be replaced with whatever the
 340   // Alias pointer points to.
 341   Symbol *weakAlias = nullptr;
 342
 343   // If this symbol is external weak, try to resolve it to a defined
 344   // symbol by searching the chain of fallback symbols. Returns the symbol if
 345   // successful, otherwise returns null.
 346   Symbol *getWeakAlias();
 347   Defined *getDefinedWeakAlias() {
 348     return dyn_cast_or_null<Defined>(getWeakAlias());
 349   }
 350
 351   void setWeakAlias(Symbol *sym, bool antiDep = false) {
 352     weakAlias = sym;
 353     isAntiDep = antiDep;
 354   }
 355
 356   bool isECAlias(MachineTypes machine) const {
 357     return weakAlias && isAntiDep && isArm64EC(machine);
 358   }
 359
 360   // If this symbol is external weak, replace this object with aliased symbol.
 361   bool resolveWeakAlias();
 362 };
 363
 364 // Windows-specific classes.
 365
 366 // This class represents a symbol imported from a DLL. This has two
 367 // names for internal use and external use. The former is used for
 368 // name resolution, and the latter is used for the import descriptor
 369 // table in an output. The former has "__imp_" prefix.
 370 class DefinedImportData : public Defined {
 371 public:
 372   DefinedImportData(StringRef n, ImportFile *file, Chunk *&location)
 373       : Defined(DefinedImportDataKind, n), file(file), location(location) {}
 374
 375   static bool classof(const Symbol *s) {
 376     return s->kind() == DefinedImportDataKind;
 377   }
 378
 379   uint64_t getRVA() { return getChunk()->getRVA(); }
 380   Chunk *getChunk() { return location; }
 381   void setLocation(Chunk *addressTable) { location = addressTable; }
 382
 383   StringRef getDLLName() { return file->dllName; }
 384   StringRef getExternalName() { return file->externalName; }
 385   uint16_t getOrdinal() { return file->hdr->OrdinalHint; }
 386
 387   ImportFile *file;
 388   Chunk *&location;
 389
 390   // This is a pointer to the synthetic symbol associated with the load thunk
 391   // for this symbol that will be called if the DLL is delay-loaded. This is
 392   // needed for Control Flow Guard because if this DefinedImportData symbol is a
 393   // valid call target, the corresponding load thunk must also be marked as a
 394   // valid call target.
 395   DefinedSynthetic *loadThunkSym = nullptr;
 396 };
 397
 398 // This class represents a symbol for a jump table entry which jumps
 399 // to a function in a DLL. Linker are supposed to create such symbols
 400 // without "__imp_" prefix for all function symbols exported from
 401 // DLLs, so that you can call DLL functions as regular functions with
 402 // a regular name. A function pointer is given as a DefinedImportData.
 403 class DefinedImportThunk : public Defined {
 404 public:
 405   DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
 406                      DefinedImportData *s, ImportThunkChunk *chunk);
 407
 408   static bool classof(const Symbol *s) {
 409     return s->kind() == DefinedImportThunkKind;
 410   }
 411
 412   uint64_t getRVA() { return data->getRVA(); }
 413   ImportThunkChunk *getChunk() const { return data; }
 414
 415   DefinedImportData *wrappedSym;
 416
 417 private:
 418   ImportThunkChunk *data;
 419 };
 420
 421 // If you have a symbol "foo" in your object file, a symbol name
 422 // "__imp_foo" becomes automatically available as a pointer to "foo".
 423 // This class is for such automatically-created symbols.
 424 // Yes, this is an odd feature. We didn't intend to implement that.
 425 // This is here just for compatibility with MSVC.
 426 class DefinedLocalImport : public Defined {
 427 public:
 428   DefinedLocalImport(COFFLinkerContext &ctx, StringRef n, Defined *s)
 429       : Defined(DefinedLocalImportKind, n),
 430         data(make<LocalImportChunk>(ctx, s)) {}
 431
 432   static bool classof(const Symbol *s) {
 433     return s->kind() == DefinedLocalImportKind;
 434   }
 435
 436   uint64_t getRVA() { return data->getRVA(); }
 437   Chunk *getChunk() { return data; }
 438
 439 private:
 440   LocalImportChunk *data;
 441 };
 442
 443 inline uint64_t Defined::getRVA() {
 444   switch (kind()) {
 445   case DefinedAbsoluteKind:
 446     return cast<DefinedAbsolute>(this)->getRVA();
 447   case DefinedSyntheticKind:
 448     return cast<DefinedSynthetic>(this)->getRVA();
 449   case DefinedImportDataKind:
 450     return cast<DefinedImportData>(this)->getRVA();
 451   case DefinedImportThunkKind:
 452     return cast<DefinedImportThunk>(this)->getRVA();
 453   case DefinedLocalImportKind:
 454     return cast<DefinedLocalImport>(this)->getRVA();
 455   case DefinedCommonKind:
 456     return cast<DefinedCommon>(this)->getRVA();
 457   case DefinedRegularKind:
 458     return cast<DefinedRegular>(this)->getRVA();
 459   case LazyArchiveKind:
 460   case LazyObjectKind:
 461   case LazyDLLSymbolKind:
 462   case UndefinedKind:
 463     llvm_unreachable("Cannot get the address for an undefined symbol.");
 464   }
 465   llvm_unreachable("unknown symbol kind");
 466 }
 467
 468 inline Chunk *Defined::getChunk() {
 469   switch (kind()) {
 470   case DefinedRegularKind:
 471     return cast<DefinedRegular>(this)->getChunk();
 472   case DefinedAbsoluteKind:
 473     return nullptr;
 474   case DefinedSyntheticKind:
 475     return cast<DefinedSynthetic>(this)->getChunk();
 476   case DefinedImportDataKind:
 477     return cast<DefinedImportData>(this)->getChunk();
 478   case DefinedImportThunkKind:
 479     return cast<DefinedImportThunk>(this)->getChunk();
 480   case DefinedLocalImportKind:
 481     return cast<DefinedLocalImport>(this)->getChunk();
 482   case DefinedCommonKind:
 483     return cast<DefinedCommon>(this)->getChunk();
 484   case LazyArchiveKind:
 485   case LazyObjectKind:
 486   case LazyDLLSymbolKind:
 487   case UndefinedKind:
 488     llvm_unreachable("Cannot get the chunk of an undefined symbol.");
 489   }
 490   llvm_unreachable("unknown symbol kind");
 491 }
 492
 493 // A buffer class that is large enough to hold any Symbol-derived
 494 // object. We allocate memory using this class and instantiate a symbol
 495 // using the placement new.
 496 union SymbolUnion {
 497   alignas(DefinedRegular) char a[sizeof(DefinedRegular)];
 498   alignas(DefinedCommon) char b[sizeof(DefinedCommon)];
 499   alignas(DefinedAbsolute) char c[sizeof(DefinedAbsolute)];
 500   alignas(DefinedSynthetic) char d[sizeof(DefinedSynthetic)];
 501   alignas(LazyArchive) char e[sizeof(LazyArchive)];
 502   alignas(Undefined) char f[sizeof(Undefined)];
 503   alignas(DefinedImportData) char g[sizeof(DefinedImportData)];
 504   alignas(DefinedImportThunk) char h[sizeof(DefinedImportThunk)];
 505   alignas(DefinedLocalImport) char i[sizeof(DefinedLocalImport)];
 506   alignas(LazyObject) char j[sizeof(LazyObject)];
 507   alignas(LazyDLLSymbol) char k[sizeof(LazyDLLSymbol)];
 508 };
 509
 510 template <typename T, typename... ArgT>
 511 void replaceSymbol(Symbol *s, ArgT &&... arg) {
 512   static_assert(std::is_trivially_destructible<T>(),
 513                 "Symbol types must be trivially destructible");
 514   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
 515   static_assert(alignof(T) <= alignof(SymbolUnion),
 516                 "SymbolUnion not aligned enough");
 517   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
 518          "Not a Symbol");
 519   bool canInline = s->canInline;
 520   bool isUsedInRegularObj = s->isUsedInRegularObj;
 521   new (s) T(std::forward<ArgT>(arg)...);
 522   s->canInline = canInline;
 523   s->isUsedInRegularObj = isUsedInRegularObj;
 524 }
 525 } // namespace coff
 526
 527 std::string toString(const coff::COFFLinkerContext &ctx, coff::Symbol &b);
 528 std::string toCOFFString(const coff::COFFLinkerContext &ctx,
 529                          const llvm::object::Archive::Symbol &b);
 530
 531 } // namespace lld
 532
 533 #endif