lld/COFF/Symbols.cpp

   1 //===- Symbols.cpp --------------------------------------------------------===//
   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 #include "Symbols.h"
  10 #include "COFFLinkerContext.h"
  11 #include "InputFiles.h"
  12 #include "lld/Common/ErrorHandler.h"
  13 #include "lld/Common/Memory.h"
  14 #include "lld/Common/Strings.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/Demangle/Demangle.h"
  17 #include "llvm/Support/Debug.h"
  18 #include "llvm/Support/raw_ostream.h"
  19
  20 using namespace llvm;
  21 using namespace llvm::object;
  22
  23 using namespace lld::coff;
  24
  25 namespace lld {
  26
  27 static_assert(sizeof(SymbolUnion) <= 48,
  28               "symbols should be optimized for memory usage");
  29
  30 // Returns a symbol name for an error message.
  31 static std::string maybeDemangleSymbol(const COFFLinkerContext &ctx,
  32                                        StringRef symName) {
  33   if (ctx.config.demangle) {
  34     std::string prefix;
  35     StringRef prefixless = symName;
  36     if (prefixless.consume_front("__imp_"))
  37       prefix = "__declspec(dllimport) ";
  38     StringRef demangleInput = prefixless;
  39     if (ctx.config.machine == I386)
  40       demangleInput.consume_front("_");
  41     std::string demangled = demangle(demangleInput);
  42     if (demangled != demangleInput)
  43       return prefix + demangled;
  44     return (prefix + prefixless).str();
  45   }
  46   return std::string(symName);
  47 }
  48 std::string toString(const COFFLinkerContext &ctx, coff::Symbol &b) {
  49   return maybeDemangleSymbol(ctx, b.getName());
  50 }
  51 std::string toCOFFString(const COFFLinkerContext &ctx,
  52                          const Archive::Symbol &b) {
  53   return maybeDemangleSymbol(ctx, b.getName());
  54 }
  55
  56 namespace coff {
  57
  58 void Symbol::computeName() {
  59   assert(nameData == nullptr &&
  60          "should only compute the name once for DefinedCOFF symbols");
  61   auto *d = cast<DefinedCOFF>(this);
  62   StringRef nameStr =
  63       check(cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym));
  64   nameData = nameStr.data();
  65   nameSize = nameStr.size();
  66   assert(nameSize == nameStr.size() && "name length truncated");
  67 }
  68
  69 InputFile *Symbol::getFile() {
  70   if (auto *sym = dyn_cast<DefinedCOFF>(this))
  71     return sym->file;
  72   if (auto *sym = dyn_cast<LazyArchive>(this))
  73     return sym->file;
  74   if (auto *sym = dyn_cast<LazyObject>(this))
  75     return sym->file;
  76   if (auto *sym = dyn_cast<LazyDLLSymbol>(this))
  77     return sym->file;
  78   return nullptr;
  79 }
  80
  81 bool Symbol::isLive() const {
  82   if (auto *r = dyn_cast<DefinedRegular>(this))
  83     return r->getChunk()->live;
  84   if (auto *imp = dyn_cast<DefinedImportData>(this))
  85     return imp->file->live;
  86   if (auto *imp = dyn_cast<DefinedImportThunk>(this))
  87     return imp->wrappedSym->file->thunkLive;
  88   // Assume any other kind of symbol is live.
  89   return true;
  90 }
  91
  92 // MinGW specific.
  93 void Symbol::replaceKeepingName(Symbol *other, size_t size) {
  94   StringRef origName = getName();
  95   memcpy(this, other, size);
  96   nameData = origName.data();
  97   nameSize = origName.size();
  98 }
  99
 100 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
 101   size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize();
 102   if (symSize == sizeof(coff_symbol16))
 103     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym));
 104   assert(symSize == sizeof(coff_symbol32));
 105   return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym));
 106 }
 107
 108 uint64_t DefinedAbsolute::getRVA() { return va - ctx.config.imageBase; }
 109
 110 static Chunk *makeImportThunk(COFFLinkerContext &ctx, DefinedImportData *s,
 111                               uint16_t machine) {
 112   if (machine == AMD64)
 113     return make<ImportThunkChunkX64>(ctx, s);
 114   if (machine == I386)
 115     return make<ImportThunkChunkX86>(ctx, s);
 116   if (machine == ARM64)
 117     return make<ImportThunkChunkARM64>(ctx, s);
 118   assert(machine == ARMNT);
 119   return make<ImportThunkChunkARM>(ctx, s);
 120 }
 121
 122 DefinedImportThunk::DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
 123                                        DefinedImportData *s, uint16_t machine)
 124     : Defined(DefinedImportThunkKind, name), wrappedSym(s),
 125       data(makeImportThunk(ctx, s, machine)) {}
 126
 127 Defined *Undefined::getWeakAlias() {
 128   // A weak alias may be a weak alias to another symbol, so check recursively.
 129   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)
 130     if (auto *d = dyn_cast<Defined>(a))
 131       return d;
 132   return nullptr;
 133 }
 134
 135 MemoryBufferRef LazyArchive::getMemberBuffer() {
 136   Archive::Child c =
 137       CHECK(sym.getMember(), "could not get the member for symbol " +
 138                                  toCOFFString(file->ctx, sym));
 139   return CHECK(c.getMemoryBufferRef(),
 140                "could not get the buffer for the member defining symbol " +
 141                    toCOFFString(file->ctx, sym));
 142 }
 143 } // namespace coff
 144 } // namespace lld