summaryrefslogtreecommitdiff
path: root/ELF/SymbolTable.h
diff options
context:
space:
mode:
Diffstat (limited to 'ELF/SymbolTable.h')
-rw-r--r--ELF/SymbolTable.h98
1 files changed, 32 insertions, 66 deletions
diff --git a/ELF/SymbolTable.h b/ELF/SymbolTable.h
index 898185fc96126..b64707f4ab02c 100644
--- a/ELF/SymbolTable.h
+++ b/ELF/SymbolTable.h
@@ -1,9 +1,8 @@
//===- SymbolTable.h --------------------------------------------*- C++ -*-===//
//
-// The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
@@ -11,15 +10,14 @@
#define LLD_ELF_SYMBOL_TABLE_H
#include "InputFiles.h"
-#include "LTO.h"
+#include "Symbols.h"
#include "lld/Common/Strings.h"
#include "llvm/ADT/CachedHashString.h"
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
namespace lld {
namespace elf {
-class Defined;
-class SectionBase;
// SymbolTable is a bucket of all known symbols, including defined,
// undefined, or lazy symbols (the last one is symbols in archive
@@ -35,62 +33,40 @@ class SectionBase;
// is one add* function per symbol type.
class SymbolTable {
public:
- template <class ELFT> void addFile(InputFile *File);
- template <class ELFT> void addCombinedLTOObject();
- void wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap);
-
- ArrayRef<Symbol *> getSymbols() const { return SymVector; }
-
- template <class ELFT>
- Symbol *addUndefined(StringRef Name, uint8_t Binding, uint8_t StOther,
- uint8_t Type, bool CanOmitFromDynSym, InputFile *File);
-
- Defined *addDefined(StringRef Name, uint8_t StOther, uint8_t Type,
- uint64_t Value, uint64_t Size, uint8_t Binding,
- SectionBase *Section, InputFile *File);
-
- template <class ELFT>
- void addShared(StringRef Name, SharedFile<ELFT> &F,
- const typename ELFT::Sym &Sym, uint32_t Alignment,
- uint32_t VerdefIndex);
-
- template <class ELFT>
- void addLazyArchive(StringRef Name, ArchiveFile &F,
- const llvm::object::Archive::Symbol S);
+ void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
- template <class ELFT> void addLazyObject(StringRef Name, LazyObjFile &Obj);
+ void forEachSymbol(llvm::function_ref<void(Symbol *)> fn) {
+ for (Symbol *sym : symVector)
+ if (!sym->isPlaceholder())
+ fn(sym);
+ }
- Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
- uint8_t Type, bool CanOmitFromDynSym, BitcodeFile &File);
+ Symbol *insert(StringRef name);
- Symbol *addCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
- uint8_t Binding, uint8_t StOther, uint8_t Type,
- InputFile &File);
-
- std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Visibility,
- bool CanOmitFromDynSym, InputFile *File);
-
- template <class ELFT> void fetchLazy(Symbol *Sym);
+ Symbol *addSymbol(const Symbol &New);
void scanVersionScript();
- Symbol *find(StringRef Name);
-
- void trace(StringRef Name);
+ Symbol *find(StringRef name);
void handleDynamicList();
-private:
- std::pair<Symbol *, bool> insertName(StringRef Name);
+ // Set of .so files to not link the same shared object file more than once.
+ llvm::DenseMap<StringRef, SharedFile *> soNames;
- std::vector<Symbol *> findByVersion(SymbolVersion Ver);
- std::vector<Symbol *> findAllByVersion(SymbolVersion Ver);
+ // 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;
+
+private:
+ std::vector<Symbol *> findByVersion(SymbolVersion ver);
+ std::vector<Symbol *> findAllByVersion(SymbolVersion ver);
llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
- void handleAnonymousVersion();
- void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
- StringRef VersionName);
- void assignWildcardVersion(SymbolVersion Ver, uint16_t VersionId);
+ void assignExactVersion(SymbolVersion ver, uint16_t versionId,
+ StringRef versionName);
+ void assignWildcardVersion(SymbolVersion ver, uint16_t versionId);
// The order the global symbols are in is not defined. We can use an arbitrary
// order, but it has to be reproducible. That is true even when cross linking.
@@ -99,28 +75,18 @@ private:
// but a bit inefficient.
// FIXME: Experiment with passing in a custom hashing or sorting the symbols
// once symbol resolution is finished.
- llvm::DenseMap<llvm::CachedHashStringRef, int> SymMap;
- std::vector<Symbol *> SymVector;
-
- // 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 set
- // is used to uniquify them.
- llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups;
-
- // Set of .so files to not link the same shared object file more than once.
- llvm::DenseMap<StringRef, InputFile *> SoNames;
+ llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
+ std::vector<Symbol *> 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.
- llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> DemangledSyms;
-
- // For LTO.
- std::unique_ptr<BitcodeCompiler> LTO;
+ llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> demangledSyms;
};
-extern SymbolTable *Symtab;
+extern SymbolTable *symtab;
+
} // namespace elf
} // namespace lld