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 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 const COFFSyncStream &
  57 coff::operator<<(const COFFSyncStream &s,
  58                  const llvm::object::Archive::Symbol *sym) {
  59   s << maybeDemangleSymbol(s.ctx, sym->getName());
  60   return s;
  61 }
  62
  63 const COFFSyncStream &coff::operator<<(const COFFSyncStream &s, Symbol *sym) {
  64   return s << maybeDemangleSymbol(s.ctx, sym->getName());
  65 }
  66
  67 namespace coff {
  68
  69 void Symbol::computeName() {
  70   assert(nameData == nullptr &&
  71          "should only compute the name once for DefinedCOFF symbols");
  72   auto *d = cast<DefinedCOFF>(this);
  73   StringRef nameStr =
  74       check(cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym));
  75   nameData = nameStr.data();
  76   nameSize = nameStr.size();
  77   assert(nameSize == nameStr.size() && "name length truncated");
  78 }
  79
  80 InputFile *Symbol::getFile() {
  81   if (auto *sym = dyn_cast<DefinedCOFF>(this))
  82     return sym->file;
  83   if (auto *sym = dyn_cast<LazyArchive>(this))
  84     return sym->file;
  85   if (auto *sym = dyn_cast<LazyObject>(this))
  86     return sym->file;
  87   if (auto *sym = dyn_cast<LazyDLLSymbol>(this))
  88     return sym->file;
  89   return nullptr;
  90 }
  91
  92 bool Symbol::isLive() const {
  93   if (auto *r = dyn_cast<DefinedRegular>(this))
  94     return r->getChunk()->live;
  95   if (auto *imp = dyn_cast<DefinedImportData>(this))
  96     return imp->file->live;
  97   if (auto *imp = dyn_cast<DefinedImportThunk>(this))
  98     return imp->getChunk()->live;
  99   // Assume any other kind of symbol is live.
 100   return true;
 101 }
 102
 103 // MinGW specific.
 104 void Symbol::replaceKeepingName(Symbol *other, size_t size) {
 105   StringRef origName = getName();
 106   memcpy(this, other, size);
 107   nameData = origName.data();
 108   nameSize = origName.size();
 109 }
 110
 111 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
 112   size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize();
 113   if (symSize == sizeof(coff_symbol16))
 114     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym));
 115   assert(symSize == sizeof(coff_symbol32));
 116   return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym));
 117 }
 118
 119 uint64_t DefinedAbsolute::getRVA() { return va - ctx.config.imageBase; }
 120
 121 DefinedImportThunk::DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
 122                                        DefinedImportData *s,
 123                                        ImportThunkChunk *chunk)
 124     : Defined(DefinedImportThunkKind, name), wrappedSym(s), data(chunk) {}
 125
 126 Symbol *Undefined::getWeakAlias() {
 127   // A weak alias may be a weak alias to another symbol, so check recursively.
 128   DenseSet<Symbol *> weakChain;
 129   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias) {
 130     // Anti-dependency symbols can't be chained.
 131     if (a->isAntiDep)
 132       break;
 133     if (!isa<Undefined>(a))
 134       return a;
 135     if (!weakChain.insert(a).second)
 136       break; // We have a cycle.
 137   }
 138   return nullptr;
 139 }
 140
 141 bool Undefined::resolveWeakAlias() {
 142   Defined *d = getDefinedWeakAlias();
 143   if (!d)
 144     return false;
 145
 146   // We want to replace Sym with D. However, we can't just blindly
 147   // copy sizeof(SymbolUnion) bytes from D to Sym because D may be an
 148   // internal symbol, and internal symbols are stored as "unparented"
 149   // Symbols. For that reason we need to check which type of symbol we
 150   // are dealing with and copy the correct number of bytes.
 151   StringRef name = getName();
 152   bool wasAntiDep = isAntiDep;
 153   if (isa<DefinedRegular>(d))
 154     memcpy(this, d, sizeof(DefinedRegular));
 155   else if (isa<DefinedAbsolute>(d))
 156     memcpy(this, d, sizeof(DefinedAbsolute));
 157   else
 158     memcpy(this, d, sizeof(SymbolUnion));
 159
 160   nameData = name.data();
 161   nameSize = name.size();
 162   isAntiDep = wasAntiDep;
 163   return true;
 164 }
 165
 166 MemoryBufferRef LazyArchive::getMemberBuffer() {
 167   Archive::Child c =
 168       CHECK(sym.getMember(), "could not get the member for symbol " +
 169                                  toCOFFString(file->symtab.ctx, sym));
 170   return CHECK(c.getMemoryBufferRef(),
 171                "could not get the buffer for the member defining symbol " +
 172                    toCOFFString(file->symtab.ctx, sym));
 173 }
 174 } // namespace coff
 175 } // namespace lld