blob: 54b30147528d719b6318ccc5f1b6a1be3ff09411 [file] [edit]
//===- SymbolTable.h --------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLD_ELF_SYMBOL_TABLE_H
#define LLD_ELF_SYMBOL_TABLE_H
#include "Symbols.h"
#include "llvm/ADT/CachedHashString.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/Compiler.h"
#include <array>
#include <mutex>
namespace lld::elf {
struct Ctx;
class InputFile;
class SharedFile;
struct ArmCmseEntryFunction {
Symbol *acleSeSym;
Symbol *sym;
};
// SymbolTable is a bucket of all known symbols, including defined,
// undefined, or lazy symbols (the last one is symbols in archive
// files whose archive members are not yet loaded).
//
// We put all symbols of all files to a SymbolTable, and the
// SymbolTable selects the "best" symbols if there are name
// conflicts. For example, obviously, a defined symbol is better than
// an undefined symbol. Or, if there's a conflict between a lazy and a
// undefined, it'll read an archive member to read a real definition
// to replace the lazy symbol. The logic is implemented in the
// add*() functions, which are called by input files as they are parsed. There
// is one add* function per symbol type.
class SymbolTable {
public:
SymbolTable(Ctx &ctx) : ctx(ctx) {}
ArrayRef<Symbol *> getSymbols() const { return symVector; }
void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
Symbol *insert(StringRef name);
// Add a symbol returned by intern to the symbol table.
Symbol *insert(Symbol *sym) {
if (!sym->inserted) {
sym->inserted = true;
symVector.push_back(sym);
}
return sym;
}
// Return the symbol named `name`, creating one that is not yet in the symbol
// table if needed. This is thread-safe while `concurrent` is true.
Symbol *intern(llvm::CachedHashStringRef name);
// True while worker threads run. The shards are locked only then.
bool concurrent = false;
template <typename T> Symbol *addSymbol(const T &newSym) {
Symbol *sym = insert(newSym.getName());
sym->resolve(ctx, newSym);
return sym;
}
Symbol *addAndCheckDuplicate(const Defined &newSym);
void scanVersionScript();
Symbol *find(StringRef name);
Symbol *addUnusedUndefined(StringRef name,
uint8_t binding = llvm::ELF::STB_GLOBAL);
// Set of .so files to not link the same shared object file more than once.
llvm::DenseMap<llvm::CachedHashStringRef, SharedFile *> soNames;
// Comdat groups define "link once" sections. If two comdat groups have the
// same name, only one of them is linked, and the other is ignored. This map
// is used to uniquify them.
llvm::DenseMap<llvm::CachedHashStringRef, const InputFile *> comdatGroups;
// The Map of __acle_se_<sym>, <sym> pairs found in the input objects.
// Key is the <sym> name.
llvm::SmallMapVector<StringRef, ArmCmseEntryFunction, 1> cmseSymMap;
// Map of symbols defined in the Arm CMSE import library. The linker must
// preserve the addresses in the output objects.
llvm::StringMap<Defined *> cmseImportLib;
// True if <sym> from the input Arm CMSE import library is written to the
// output Arm CMSE import library.
llvm::StringMap<bool> inCMSEOutImpLib;
private:
SmallVector<Symbol *, 0> findByVersion(SymbolVersion ver);
llvm::StringMap<SmallVector<Symbol *, 0>> &getDemangledSyms();
bool assignExactVersion(SymbolVersion ver, uint16_t versionId);
Ctx &ctx;
// Shard by the high bits of the hash so that lookups can run in parallel.
struct Shard {
// A map from symbol name to the symbol.
llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> map;
std::mutex mu;
std::unique_lock<std::mutex> getLock(bool concurrent) {
return concurrent ? std::unique_lock<std::mutex>(mu)
: std::unique_lock<std::mutex>();
}
};
std::array<Shard, 256> shards;
Shard &getShard(llvm::CachedHashStringRef key) {
return shards[key.hash() >> 24];
}
// Global symbols in insertion order, which must be deterministic even when
// cross linking.
SmallVector<Symbol *, 0> symVector;
// A map from demangled symbol names to their symbol objects.
// This mapping is 1:N because two symbols with different versions
// can have the same name. We use this map to handle "extern C++ {}"
// directive in version scripts.
std::optional<llvm::StringMap<SmallVector<Symbol *, 0>>> demangledSyms;
};
} // namespace lld::elf
#endif