2015-08-14 22:12:54 +08:00
|
|
|
//===- SymbolTable.h --------------------------------------------*- C++ -*-===//
|
2015-07-25 05:03:07 +08:00
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLD_ELF_SYMBOL_TABLE_H
|
|
|
|
#define LLD_ELF_SYMBOL_TABLE_H
|
|
|
|
|
|
|
|
#include "InputFiles.h"
|
2015-09-18 02:26:25 +08:00
|
|
|
#include "llvm/ADT/MapVector.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace elf2 {
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT> class OutputSectionBase;
|
2015-07-25 05:03:07 +08:00
|
|
|
struct Symbol;
|
|
|
|
|
|
|
|
// 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 resolve().
|
2015-10-10 05:07:25 +08:00
|
|
|
template <class ELFT> class SymbolTable {
|
2015-07-25 05:03:07 +08:00
|
|
|
public:
|
|
|
|
SymbolTable();
|
|
|
|
|
|
|
|
void addFile(std::unique_ptr<InputFile> File);
|
|
|
|
|
2015-09-17 22:02:10 +08:00
|
|
|
bool shouldUseRela() const;
|
|
|
|
|
2015-09-18 02:26:25 +08:00
|
|
|
const llvm::MapVector<StringRef, Symbol *> &getSymbols() const {
|
2015-08-14 21:07:05 +08:00
|
|
|
return Symtab;
|
|
|
|
}
|
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
const std::vector<std::unique_ptr<ObjectFile<ELFT>>> &getObjectFiles() const {
|
2015-09-04 02:56:20 +08:00
|
|
|
return ObjectFiles;
|
|
|
|
}
|
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
|
2015-09-09 03:43:27 +08:00
|
|
|
return SharedFiles;
|
|
|
|
}
|
|
|
|
|
2015-10-10 05:12:40 +08:00
|
|
|
SymbolBody *addUndefined(StringRef Name);
|
|
|
|
SymbolBody *addUndefinedOpt(StringRef Name);
|
2015-11-06 15:43:03 +08:00
|
|
|
void addAbsoluteSym(StringRef Name,
|
|
|
|
typename llvm::object::ELFFile<ELFT>::Elf_Sym &ESym);
|
2015-10-16 06:27:29 +08:00
|
|
|
void addSyntheticSym(StringRef Name, OutputSectionBase<ELFT> &Section,
|
2015-09-26 02:56:53 +08:00
|
|
|
typename llvm::object::ELFFile<ELFT>::uintX_t Value);
|
2015-10-10 05:07:25 +08:00
|
|
|
void addIgnoredSym(StringRef Name);
|
2015-10-16 01:11:03 +08:00
|
|
|
bool isUndefined(StringRef Name);
|
2015-10-14 02:10:33 +08:00
|
|
|
void scanShlibUndefined();
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
SymbolBody *find(StringRef Name);
|
2015-10-02 05:22:26 +08:00
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
private:
|
2015-09-05 06:28:10 +08:00
|
|
|
Symbol *insert(SymbolBody *New);
|
2015-10-12 09:55:32 +08:00
|
|
|
void addELFFile(ELFFileBase<ELFT> *File);
|
2015-09-05 06:28:10 +08:00
|
|
|
void addLazy(Lazy *New);
|
|
|
|
void addMemberFile(Lazy *Body);
|
2015-10-13 02:03:21 +08:00
|
|
|
void checkCompatibility(std::unique_ptr<InputFile> &File);
|
2015-10-10 05:07:25 +08:00
|
|
|
void resolve(SymbolBody *Body);
|
2015-10-09 17:58:39 +08:00
|
|
|
void reportConflict(const Twine &Message, const SymbolBody &Old,
|
|
|
|
const SymbolBody &New, bool Warning);
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
std::vector<std::unique_ptr<InputFile>> ArchiveFiles;
|
2015-09-05 06:28:10 +08:00
|
|
|
|
2015-09-18 02:26:25 +08:00
|
|
|
// 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.
|
|
|
|
// The default hashing of StringRef produces different results on 32 and 64
|
|
|
|
// bit systems so we use a MapVector. That is arbitrary, deterministic but
|
|
|
|
// a bit inefficient.
|
|
|
|
// FIXME: Experiment with passing in a custom hashing or sorting the symbols
|
|
|
|
// once symbol resolution is finished.
|
|
|
|
llvm::MapVector<StringRef, Symbol *> Symtab;
|
2015-07-25 05:03:07 +08:00
|
|
|
llvm::BumpPtrAllocator Alloc;
|
2015-09-04 02:56:20 +08:00
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
llvm::DenseSet<StringRef> Comdats;
|
|
|
|
|
2015-09-04 02:56:20 +08:00
|
|
|
// The writer needs to infer the machine type from the object files.
|
2015-10-10 05:07:25 +08:00
|
|
|
std::vector<std::unique_ptr<ObjectFile<ELFT>>> ObjectFiles;
|
2015-09-04 04:03:54 +08:00
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
std::vector<std::unique_ptr<SharedFile<ELFT>>> SharedFiles;
|
2015-10-02 03:52:48 +08:00
|
|
|
llvm::DenseSet<StringRef> IncludedSoNames;
|
2015-07-25 05:03:07 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace elf2
|
|
|
|
} // namespace lld
|
|
|
|
|
|
|
|
#endif
|