2015-07-25 05:03:07 +08:00
|
|
|
//===- InputFiles.cpp -----------------------------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2015-07-25 05:03:07 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "InputFiles.h"
|
2016-02-11 23:24:48 +08:00
|
|
|
#include "InputSection.h"
|
2016-08-13 03:56:57 +08:00
|
|
|
#include "LinkerScript.h"
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
#include "SymbolTable.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
#include "Symbols.h"
|
2016-12-14 18:36:12 +08:00
|
|
|
#include "SyntheticSections.h"
|
[lld] unified COFF and ELF error handling on new Common/ErrorHandler
Summary:
The COFF linker and the ELF linker have long had similar but separate
Error.h and Error.cpp files to implement error handling. This change
introduces new error handling code in Common/ErrorHandler.h, changes the
COFF and ELF linkers to use it, and removes the old, separate
implementations.
Reviewers: ruiu
Reviewed By: ruiu
Subscribers: smeenai, jyknight, emaste, sdardis, nemanjai, nhaehnle, mgorny, javed.absar, kbarton, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D39259
llvm-svn: 316624
2017-10-26 06:28:38 +08:00
|
|
|
#include "lld/Common/ErrorHandler.h"
|
2017-11-29 04:39:17 +08:00
|
|
|
#include "lld/Common/Memory.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2016-04-22 05:44:25 +08:00
|
|
|
#include "llvm/CodeGen/Analysis.h"
|
2016-10-26 19:07:09 +08:00
|
|
|
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
|
2016-02-13 04:54:57 +08:00
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2016-03-02 23:43:50 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2016-09-29 08:40:08 +08:00
|
|
|
#include "llvm/LTO/LTO.h"
|
2016-09-10 06:08:04 +08:00
|
|
|
#include "llvm/MC/StringTableBuilder.h"
|
2016-11-01 17:17:50 +08:00
|
|
|
#include "llvm/Object/ELFObjectFile.h"
|
2017-11-28 21:51:48 +08:00
|
|
|
#include "llvm/Support/ARMAttributeParser.h"
|
|
|
|
#include "llvm/Support/ARMBuildAttributes.h"
|
2016-09-09 05:18:38 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2017-01-09 09:42:02 +08:00
|
|
|
#include "llvm/Support/TarWriter.h"
|
2016-02-13 04:54:57 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-09-05 06:28:10 +08:00
|
|
|
using namespace llvm;
|
2015-07-25 05:03:07 +08:00
|
|
|
using namespace llvm::ELF;
|
2015-09-04 04:03:54 +08:00
|
|
|
using namespace llvm::object;
|
2017-12-24 01:21:39 +08:00
|
|
|
using namespace llvm::sys;
|
2015-10-01 01:06:09 +08:00
|
|
|
using namespace llvm::sys::fs;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace lld;
|
2016-02-28 08:25:54 +08:00
|
|
|
using namespace lld::elf;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
Add --warn-backrefs to maintain compatibility with other linkers
I'm proposing a new command line flag, --warn-backrefs in this patch.
The flag and the feature proposed below don't exist in GNU linkers
nor the current lld.
--warn-backrefs is an option to detect reverse or cyclic dependencies
between static archives, and it can be used to keep your program
compatible with GNU linkers after you switch to lld. I'll explain the
feature and why you may find it useful below.
lld's symbol resolution semantics is more relaxed than traditional
Unix linkers. Therefore,
ld.lld foo.a bar.o
succeeds even if bar.o contains an undefined symbol that have to be
resolved by some object file in foo.a. Traditional Unix linkers
don't allow this kind of backward reference, as they visit each
file only once from left to right in the command line while
resolving all undefined symbol at the moment of visiting.
In the above case, since there's no undefined symbol when a linker
visits foo.a, no files are pulled out from foo.a, and because the
linker forgets about foo.a after visiting, it can't resolve
undefined symbols that could have been resolved otherwise.
That lld accepts more relaxed form means (besides it makes more
sense) that you can accidentally write a command line or a build
file that works only with lld, even if you have a plan to
distribute it to wider users who may be using GNU linkers. With
--check-library-dependency, you can detect a library order that
doesn't work with other Unix linkers.
The option is also useful to detect cyclic dependencies between
static archives. Again, lld accepts
ld.lld foo.a bar.a
even if foo.a and bar.a depend on each other. With --warn-backrefs
it is handled as an error.
Here is how the option works. We assign a group ID to each file. A
file with a smaller group ID can pull out object files from an
archive file with an equal or greater group ID. Otherwise, it is a
reverse dependency and an error.
A file outside --{start,end}-group gets a fresh ID when
instantiated. All files within the same --{start,end}-group get the
same group ID. E.g.
ld.lld A B --start-group C D --end-group E
A and B form group 0, C, D and their member object files form group
1, and E forms group 2. I think that you can see how this group
assignment rule simulates the traditional linker's semantics.
Differential Revision: https://reviews.llvm.org/D45195
llvm-svn: 329636
2018-04-10 07:05:48 +08:00
|
|
|
bool InputFile::IsInGroup;
|
|
|
|
uint32_t InputFile::NextGroupId;
|
2017-09-19 17:20:54 +08:00
|
|
|
std::vector<BinaryFile *> elf::BinaryFiles;
|
|
|
|
std::vector<BitcodeFile *> elf::BitcodeFiles;
|
2018-05-03 05:40:07 +08:00
|
|
|
std::vector<LazyObjFile *> elf::LazyObjFiles;
|
2017-09-19 17:20:54 +08:00
|
|
|
std::vector<InputFile *> elf::ObjectFiles;
|
|
|
|
std::vector<InputFile *> elf::SharedFiles;
|
|
|
|
|
2018-12-19 07:50:37 +08:00
|
|
|
std::unique_ptr<TarWriter> elf::Tar;
|
2017-01-09 09:42:02 +08:00
|
|
|
|
Add --warn-backrefs to maintain compatibility with other linkers
I'm proposing a new command line flag, --warn-backrefs in this patch.
The flag and the feature proposed below don't exist in GNU linkers
nor the current lld.
--warn-backrefs is an option to detect reverse or cyclic dependencies
between static archives, and it can be used to keep your program
compatible with GNU linkers after you switch to lld. I'll explain the
feature and why you may find it useful below.
lld's symbol resolution semantics is more relaxed than traditional
Unix linkers. Therefore,
ld.lld foo.a bar.o
succeeds even if bar.o contains an undefined symbol that have to be
resolved by some object file in foo.a. Traditional Unix linkers
don't allow this kind of backward reference, as they visit each
file only once from left to right in the command line while
resolving all undefined symbol at the moment of visiting.
In the above case, since there's no undefined symbol when a linker
visits foo.a, no files are pulled out from foo.a, and because the
linker forgets about foo.a after visiting, it can't resolve
undefined symbols that could have been resolved otherwise.
That lld accepts more relaxed form means (besides it makes more
sense) that you can accidentally write a command line or a build
file that works only with lld, even if you have a plan to
distribute it to wider users who may be using GNU linkers. With
--check-library-dependency, you can detect a library order that
doesn't work with other Unix linkers.
The option is also useful to detect cyclic dependencies between
static archives. Again, lld accepts
ld.lld foo.a bar.a
even if foo.a and bar.a depend on each other. With --warn-backrefs
it is handled as an error.
Here is how the option works. We assign a group ID to each file. A
file with a smaller group ID can pull out object files from an
archive file with an equal or greater group ID. Otherwise, it is a
reverse dependency and an error.
A file outside --{start,end}-group gets a fresh ID when
instantiated. All files within the same --{start,end}-group get the
same group ID. E.g.
ld.lld A B --start-group C D --end-group E
A and B form group 0, C, D and their member object files form group
1, and E forms group 2. I think that you can see how this group
assignment rule simulates the traditional linker's semantics.
Differential Revision: https://reviews.llvm.org/D45195
llvm-svn: 329636
2018-04-10 07:05:48 +08:00
|
|
|
InputFile::InputFile(Kind K, MemoryBufferRef M)
|
|
|
|
: MB(M), GroupId(NextGroupId), FileKind(K) {
|
|
|
|
// All files within the same --{start,end}-group get the same group ID.
|
|
|
|
// Otherwise, a new file will get a new group ID.
|
|
|
|
if (!IsInGroup)
|
|
|
|
++NextGroupId;
|
|
|
|
}
|
2017-03-31 05:13:00 +08:00
|
|
|
|
2017-01-09 09:42:02 +08:00
|
|
|
Optional<MemoryBufferRef> elf::readFile(StringRef Path) {
|
2017-07-21 02:17:55 +08:00
|
|
|
// The --chroot option changes our virtual root directory.
|
|
|
|
// This is useful when you are dealing with files created by --reproduce.
|
|
|
|
if (!Config->Chroot.empty() && Path.startswith("/"))
|
|
|
|
Path = Saver.save(Config->Chroot + Path);
|
|
|
|
|
2017-02-22 07:22:56 +08:00
|
|
|
log(Path);
|
2017-07-21 02:17:55 +08:00
|
|
|
|
2018-04-27 23:32:04 +08:00
|
|
|
auto MBOrErr = MemoryBuffer::getFile(Path, -1, false);
|
2017-01-09 09:42:02 +08:00
|
|
|
if (auto EC = MBOrErr.getError()) {
|
2017-01-13 06:18:04 +08:00
|
|
|
error("cannot open " + Path + ": " + EC.message());
|
2017-01-09 09:42:02 +08:00
|
|
|
return None;
|
|
|
|
}
|
2017-02-22 07:22:56 +08:00
|
|
|
|
2017-01-09 09:42:02 +08:00
|
|
|
std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
|
|
|
|
MemoryBufferRef MBRef = MB->getMemBufferRef();
|
|
|
|
make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
|
|
|
|
|
|
|
|
if (Tar)
|
|
|
|
Tar->append(relativeToRoot(Path), MBRef.getBuffer());
|
|
|
|
return MBRef;
|
|
|
|
}
|
|
|
|
|
2017-12-24 01:21:39 +08:00
|
|
|
// Concatenates arguments to construct a string representing an error location.
|
|
|
|
static std::string createFileLineMsg(StringRef Path, unsigned Line) {
|
|
|
|
std::string Filename = path::filename(Path);
|
|
|
|
std::string Lineno = ":" + std::to_string(Line);
|
|
|
|
if (Filename == Path)
|
|
|
|
return Filename + Lineno;
|
|
|
|
return Filename + Lineno + " (" + Path.str() + Lineno + ")";
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
static std::string getSrcMsgAux(ObjFile<ELFT> &File, const Symbol &Sym,
|
|
|
|
InputSectionBase &Sec, uint64_t Offset) {
|
|
|
|
// In DWARF, functions and variables are stored to different places.
|
|
|
|
// First, lookup a function for a given offset.
|
|
|
|
if (Optional<DILineInfo> Info = File.getDILineInfo(&Sec, Offset))
|
|
|
|
return createFileLineMsg(Info->FileName, Info->Line);
|
|
|
|
|
|
|
|
// If it failed, lookup again as a variable.
|
|
|
|
if (Optional<std::pair<std::string, unsigned>> FileLine =
|
|
|
|
File.getVariableLoc(Sym.getName()))
|
|
|
|
return createFileLineMsg(FileLine->first, FileLine->second);
|
|
|
|
|
|
|
|
// File.SourceFile contains STT_FILE symbol, and that is a last resort.
|
|
|
|
return File.SourceFile;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string InputFile::getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
|
|
|
|
uint64_t Offset) {
|
|
|
|
if (kind() != ObjKind)
|
|
|
|
return "";
|
|
|
|
switch (Config->EKind) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Invalid kind");
|
|
|
|
case ELF32LEKind:
|
|
|
|
return getSrcMsgAux(cast<ObjFile<ELF32LE>>(*this), Sym, Sec, Offset);
|
|
|
|
case ELF32BEKind:
|
|
|
|
return getSrcMsgAux(cast<ObjFile<ELF32BE>>(*this), Sym, Sec, Offset);
|
|
|
|
case ELF64LEKind:
|
|
|
|
return getSrcMsgAux(cast<ObjFile<ELF64LE>>(*this), Sym, Sec, Offset);
|
|
|
|
case ELF64BEKind:
|
|
|
|
return getSrcMsgAux(cast<ObjFile<ELF64BE>>(*this), Sym, Sec, Offset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-01 15:42:38 +08:00
|
|
|
template <class ELFT> void ObjFile<ELFT>::initializeDwarf() {
|
2018-03-23 08:42:47 +08:00
|
|
|
Dwarf = llvm::make_unique<DWARFContext>(make_unique<LLDDwarfObj<ELFT>>(this));
|
2018-08-02 05:57:15 +08:00
|
|
|
for (std::unique_ptr<DWARFUnit> &CU : Dwarf->compile_units()) {
|
2018-05-21 23:31:23 +08:00
|
|
|
auto Report = [](Error Err) {
|
|
|
|
handleAllErrors(std::move(Err),
|
|
|
|
[](ErrorInfoBase &Info) { warn(Info.message()); });
|
|
|
|
};
|
2018-05-10 18:52:21 +08:00
|
|
|
Expected<const DWARFDebugLine::LineTable *> ExpectedLT =
|
2018-05-21 23:31:23 +08:00
|
|
|
Dwarf->getLineTableForUnit(CU.get(), Report);
|
2018-05-10 18:52:21 +08:00
|
|
|
const DWARFDebugLine::LineTable *LT = nullptr;
|
|
|
|
if (ExpectedLT)
|
|
|
|
LT = *ExpectedLT;
|
|
|
|
else
|
2018-05-21 23:31:23 +08:00
|
|
|
Report(ExpectedLT.takeError());
|
2018-03-23 08:35:27 +08:00
|
|
|
if (!LT)
|
2017-11-01 15:42:38 +08:00
|
|
|
continue;
|
2018-03-23 08:35:27 +08:00
|
|
|
LineTables.push_back(LT);
|
|
|
|
|
|
|
|
// Loop over variable records and insert them to VariableLoc.
|
|
|
|
for (const auto &Entry : CU->dies()) {
|
|
|
|
DWARFDie Die(CU.get(), &Entry);
|
|
|
|
// Skip all tags that are not variables.
|
|
|
|
if (Die.getTag() != dwarf::DW_TAG_variable)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Skip if a local variable because we don't need them for generating
|
|
|
|
// error messages. In general, only non-local symbols can fail to be
|
|
|
|
// linked.
|
|
|
|
if (!dwarf::toUnsigned(Die.find(dwarf::DW_AT_external), 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Get the source filename index for the variable.
|
|
|
|
unsigned File = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_file), 0);
|
|
|
|
if (!LT->hasFileAtIndex(File))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Get the line number on which the variable is declared.
|
|
|
|
unsigned Line = dwarf::toUnsigned(Die.find(dwarf::DW_AT_decl_line), 0);
|
|
|
|
|
2018-06-04 18:28:45 +08:00
|
|
|
// Here we want to take the variable name to add it into VariableLoc.
|
|
|
|
// Variable can have regular and linkage name associated. At first, we try
|
|
|
|
// to get linkage name as it can be different, for example when we have
|
|
|
|
// two variables in different namespaces of the same object. Use common
|
|
|
|
// name otherwise, but handle the case when it also absent in case if the
|
2018-03-23 08:35:27 +08:00
|
|
|
// input object file lacks some debug info.
|
2018-06-04 18:28:45 +08:00
|
|
|
StringRef Name =
|
|
|
|
dwarf::toString(Die.find(dwarf::DW_AT_linkage_name),
|
|
|
|
dwarf::toString(Die.find(dwarf::DW_AT_name), ""));
|
2018-03-23 08:35:27 +08:00
|
|
|
if (!Name.empty())
|
|
|
|
VariableLoc.insert({Name, {LT, File, Line}});
|
|
|
|
}
|
2017-11-01 15:42:38 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the pair of file name and line number describing location of data
|
|
|
|
// object (variable, array, etc) definition.
|
|
|
|
template <class ELFT>
|
|
|
|
Optional<std::pair<std::string, unsigned>>
|
|
|
|
ObjFile<ELFT>::getVariableLoc(StringRef Name) {
|
|
|
|
llvm::call_once(InitDwarfLine, [this]() { initializeDwarf(); });
|
|
|
|
|
|
|
|
// Return if we have no debug information about data object.
|
|
|
|
auto It = VariableLoc.find(Name);
|
|
|
|
if (It == VariableLoc.end())
|
|
|
|
return None;
|
|
|
|
|
|
|
|
// Take file name string from line table.
|
|
|
|
std::string FileName;
|
2018-03-23 08:35:27 +08:00
|
|
|
if (!It->second.LT->getFileNameByIndex(
|
2018-03-22 06:32:17 +08:00
|
|
|
It->second.File, nullptr,
|
2017-11-01 15:42:38 +08:00
|
|
|
DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, FileName))
|
|
|
|
return None;
|
|
|
|
|
2018-03-22 06:32:17 +08:00
|
|
|
return std::make_pair(FileName, It->second.Line);
|
2016-10-26 19:07:09 +08:00
|
|
|
}
|
|
|
|
|
2016-11-03 02:42:13 +08:00
|
|
|
// Returns source line information for a given offset
|
|
|
|
// using DWARF debug info.
|
2016-11-01 17:17:50 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *S,
|
|
|
|
uint64_t Offset) {
|
2017-11-01 15:42:38 +08:00
|
|
|
llvm::call_once(InitDwarfLine, [this]() { initializeDwarf(); });
|
2016-10-26 19:07:09 +08:00
|
|
|
|
2019-02-27 21:17:36 +08:00
|
|
|
// Detect SectionIndex for specified section.
|
|
|
|
uint64_t SectionIndex = object::SectionedAddress::UndefSection;
|
|
|
|
ArrayRef<InputSectionBase *> Sections = S->File->getSections();
|
|
|
|
for (uint64_t CurIndex = 0; CurIndex < Sections.size(); ++CurIndex) {
|
|
|
|
if (S == Sections[CurIndex]) {
|
|
|
|
SectionIndex = CurIndex;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-01 17:17:50 +08:00
|
|
|
// Use fake address calcuated by adding section file offset and offset in
|
2016-11-03 02:42:13 +08:00
|
|
|
// section. See comments for ObjectInfo class.
|
|
|
|
DILineInfo Info;
|
2019-02-27 21:17:36 +08:00
|
|
|
for (const llvm::DWARFDebugLine::LineTable *LT : LineTables) {
|
2018-03-23 08:35:27 +08:00
|
|
|
if (LT->getFileLineInfoForAddress(
|
2019-02-27 21:17:36 +08:00
|
|
|
{S->getOffsetInFile() + Offset, SectionIndex}, nullptr,
|
2018-03-23 08:35:27 +08:00
|
|
|
DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, Info))
|
|
|
|
return Info;
|
2019-02-27 21:17:36 +08:00
|
|
|
}
|
2018-03-23 08:35:27 +08:00
|
|
|
return None;
|
2017-03-31 03:13:47 +08:00
|
|
|
}
|
|
|
|
|
2017-04-29 04:00:09 +08:00
|
|
|
// Returns "<internal>", "foo.a(bar.o)" or "baz.o".
|
2017-01-06 18:04:08 +08:00
|
|
|
std::string lld::toString(const InputFile *F) {
|
2017-04-04 03:11:23 +08:00
|
|
|
if (!F)
|
2017-04-29 04:00:09 +08:00
|
|
|
return "<internal>";
|
2017-04-04 03:11:23 +08:00
|
|
|
|
|
|
|
if (F->ToStringCache.empty()) {
|
|
|
|
if (F->ArchiveName.empty())
|
|
|
|
F->ToStringCache = F->getName();
|
|
|
|
else
|
|
|
|
F->ToStringCache = (F->ArchiveName + "(" + F->getName() + ")").str();
|
|
|
|
}
|
|
|
|
return F->ToStringCache;
|
2016-05-10 05:40:06 +08:00
|
|
|
}
|
|
|
|
|
2019-04-06 04:16:26 +08:00
|
|
|
ELFFileBase::ELFFileBase(Kind K, MemoryBufferRef MB) : InputFile(K, MB) {}
|
|
|
|
|
|
|
|
template <class ELFT> void ELFFileBase::parseHeader() {
|
2017-04-27 06:51:51 +08:00
|
|
|
if (ELFT::TargetEndianness == support::little)
|
|
|
|
EKind = ELFT::Is64Bits ? ELF64LEKind : ELF32LEKind;
|
|
|
|
else
|
|
|
|
EKind = ELFT::Is64Bits ? ELF64BEKind : ELF32BEKind;
|
|
|
|
|
2019-04-06 04:16:26 +08:00
|
|
|
EMachine = getObj<ELFT>().getHeader()->e_machine;
|
|
|
|
OSABI = getObj<ELFT>().getHeader()->e_ident[llvm::ELF::EI_OSABI];
|
|
|
|
ABIVersion = getObj<ELFT>().getHeader()->e_ident[llvm::ELF::EI_ABIVERSION];
|
2016-06-29 09:30:50 +08:00
|
|
|
}
|
|
|
|
|
2015-09-08 23:50:05 +08:00
|
|
|
template <class ELFT>
|
2019-04-06 04:16:26 +08:00
|
|
|
void ELFFileBase::initSymtab(ArrayRef<typename ELFT::Shdr> Sections,
|
|
|
|
const typename ELFT::Shdr *Symtab) {
|
2018-03-29 06:55:40 +08:00
|
|
|
FirstGlobal = Symtab->sh_info;
|
2019-04-06 04:16:26 +08:00
|
|
|
ArrayRef<typename ELFT::Sym> ELFSyms =
|
|
|
|
CHECK(getObj<ELFT>().symbols(Symtab), this);
|
2018-03-29 06:55:40 +08:00
|
|
|
if (FirstGlobal == 0 || FirstGlobal > ELFSyms.size())
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": invalid sh_info in symbol table");
|
2019-04-06 04:16:26 +08:00
|
|
|
this->ELFSyms = reinterpret_cast<const void *>(ELFSyms.data());
|
|
|
|
this->NumELFSyms = ELFSyms.size();
|
2016-11-04 00:55:44 +08:00
|
|
|
|
2017-12-07 11:24:57 +08:00
|
|
|
StringTable =
|
2019-04-06 04:16:26 +08:00
|
|
|
CHECK(getObj<ELFT>().getStringTableForSymtab(*Symtab, Sections), this);
|
2015-10-02 03:52:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
ObjFile<ELFT>::ObjFile(MemoryBufferRef M, StringRef ArchiveName)
|
2019-04-06 04:16:26 +08:00
|
|
|
: ELFFileBase(ObjKind, M) {
|
|
|
|
parseHeader<ELFT>();
|
2017-04-27 06:51:51 +08:00
|
|
|
this->ArchiveName = ArchiveName;
|
|
|
|
}
|
2016-03-11 20:06:30 +08:00
|
|
|
|
2019-04-04 11:13:51 +08:00
|
|
|
template <class ELFT>
|
|
|
|
uint32_t ObjFile<ELFT>::getSectionIndex(const Elf_Sym &Sym) const {
|
2019-04-06 04:16:26 +08:00
|
|
|
return CHECK(
|
|
|
|
this->getObj().getSectionIndex(&Sym, getELFSyms<ELFT>(), SymtabSHNDX),
|
|
|
|
this);
|
2019-04-04 11:13:51 +08:00
|
|
|
}
|
|
|
|
|
2017-11-04 05:21:47 +08:00
|
|
|
template <class ELFT> ArrayRef<Symbol *> ObjFile<ELFT>::getLocalSymbols() {
|
2017-08-04 19:07:42 +08:00
|
|
|
if (this->Symbols.empty())
|
|
|
|
return {};
|
2018-03-29 06:55:40 +08:00
|
|
|
return makeArrayRef(this->Symbols).slice(1, this->FirstGlobal - 1);
|
2015-09-08 23:50:05 +08:00
|
|
|
}
|
|
|
|
|
2018-03-29 06:45:39 +08:00
|
|
|
template <class ELFT> ArrayRef<Symbol *> ObjFile<ELFT>::getGlobalSymbols() {
|
2018-03-29 06:55:40 +08:00
|
|
|
return makeArrayRef(this->Symbols).slice(this->FirstGlobal);
|
2018-03-29 06:45:39 +08:00
|
|
|
}
|
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
void ObjFile<ELFT>::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
|
2018-03-30 09:15:36 +08:00
|
|
|
// Read a section table. JustSymbols is usually false.
|
|
|
|
if (this->JustSymbols)
|
|
|
|
initializeJustSymbols();
|
|
|
|
else
|
|
|
|
initializeSections(ComdatGroups);
|
|
|
|
|
|
|
|
// Read a symbol table.
|
2016-11-08 23:51:00 +08:00
|
|
|
initializeSymbols();
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2015-12-24 16:41:12 +08:00
|
|
|
// Sections with SHT_GROUP and comdat bits define comdat section groups.
|
|
|
|
// They are identified and deduplicated by group name. This function
|
|
|
|
// returns a group name.
|
2015-10-10 03:25:07 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
StringRef ObjFile<ELFT>::getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
|
|
|
|
const Elf_Shdr &Sec) {
|
2017-06-13 02:46:33 +08:00
|
|
|
// Group signatures are stored as symbol names in object files.
|
|
|
|
// sh_info contains a symbol index, so we fetch a symbol and read its name.
|
2019-04-06 04:16:26 +08:00
|
|
|
if (this->getELFSyms<ELFT>().empty())
|
|
|
|
this->initSymtab<ELFT>(
|
2017-12-07 11:24:57 +08:00
|
|
|
Sections, CHECK(object::getSection<ELFT>(Sections, Sec.sh_link), this));
|
2017-12-07 03:08:10 +08:00
|
|
|
|
2017-12-07 11:24:57 +08:00
|
|
|
const Elf_Sym *Sym =
|
2019-04-06 04:16:26 +08:00
|
|
|
CHECK(object::getSymbol<ELFT>(this->getELFSyms<ELFT>(), Sec.sh_info), this);
|
2017-12-07 11:24:57 +08:00
|
|
|
StringRef Signature = CHECK(Sym->getName(this->StringTable), this);
|
2017-06-13 02:46:33 +08:00
|
|
|
|
|
|
|
// As a special case, if a symbol is a section symbol and has no name,
|
|
|
|
// we use a section name as a signature.
|
|
|
|
//
|
|
|
|
// Such SHT_GROUP sections are invalid from the perspective of the ELF
|
2018-03-12 23:18:35 +08:00
|
|
|
// standard, but GNU gold 1.14 (the newest version as of July 2017) or
|
2017-06-13 02:46:33 +08:00
|
|
|
// older produce such sections as outputs for the -r option, so we need
|
|
|
|
// a bug-compatibility.
|
|
|
|
if (Signature.empty() && Sym->getType() == STT_SECTION)
|
|
|
|
return getSectionName(Sec);
|
|
|
|
return Signature;
|
2015-10-10 03:25:07 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template <class ELFT> bool ObjFile<ELFT>::shouldMerge(const Elf_Shdr &Sec) {
|
2018-03-28 01:09:23 +08:00
|
|
|
// On a regular link we don't merge sections if -O0 (default is -O1). This
|
|
|
|
// sometimes makes the linker significantly faster, although the output will
|
|
|
|
// be bigger.
|
|
|
|
//
|
|
|
|
// Doing the same for -r would create a problem as it would combine sections
|
|
|
|
// with different sh_entsize. One option would be to just copy every SHF_MERGE
|
|
|
|
// section as is to the output. While this would produce a valid ELF file with
|
|
|
|
// usable SHF_MERGE sections, tools like (llvm-)?dwarfdump get confused when
|
|
|
|
// they see two .debug_str. We could have separate logic for combining
|
|
|
|
// SHF_MERGE sections based both on their name and sh_entsize, but that seems
|
|
|
|
// to be more trouble than it is worth. Instead, we just use the regular (-O1)
|
|
|
|
// logic for -r.
|
|
|
|
if (Config->Optimize == 0 && !Config->Relocatable)
|
2016-04-30 00:12:29 +08:00
|
|
|
return false;
|
|
|
|
|
2016-08-03 13:28:02 +08:00
|
|
|
// A mergeable section with size 0 is useless because they don't have
|
|
|
|
// any data to merge. A mergeable string section with size 0 can be
|
|
|
|
// argued as invalid because it doesn't end with a null character.
|
|
|
|
// We'll avoid a mess by handling them as if they were non-mergeable.
|
|
|
|
if (Sec.sh_size == 0)
|
|
|
|
return false;
|
|
|
|
|
2016-09-21 11:22:18 +08:00
|
|
|
// Check for sh_entsize. The ELF spec is not clear about the zero
|
|
|
|
// sh_entsize. It says that "the member [sh_entsize] contains 0 if
|
|
|
|
// the section does not hold a table of fixed-size entries". We know
|
|
|
|
// that Rust 1.13 produces a string mergeable section with a zero
|
|
|
|
// sh_entsize. Here we just accept it rather than being picky about it.
|
2017-02-25 03:52:52 +08:00
|
|
|
uint64_t EntSize = Sec.sh_entsize;
|
2016-09-21 11:22:18 +08:00
|
|
|
if (EntSize == 0)
|
|
|
|
return false;
|
|
|
|
if (Sec.sh_size % EntSize)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) +
|
2016-09-21 11:22:18 +08:00
|
|
|
": SHF_MERGE section size must be a multiple of sh_entsize");
|
|
|
|
|
2017-02-25 03:52:52 +08:00
|
|
|
uint64_t Flags = Sec.sh_flags;
|
2015-10-25 06:51:01 +08:00
|
|
|
if (!(Flags & SHF_MERGE))
|
|
|
|
return false;
|
|
|
|
if (Flags & SHF_WRITE)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": writable SHF_MERGE section is not supported");
|
2015-10-25 06:51:01 +08:00
|
|
|
|
2017-11-16 01:31:27 +08:00
|
|
|
return true;
|
2015-10-25 06:51:01 +08:00
|
|
|
}
|
|
|
|
|
2018-03-30 09:15:36 +08:00
|
|
|
// This is for --just-symbols.
|
|
|
|
//
|
|
|
|
// --just-symbols is a very minor feature that allows you to link your
|
|
|
|
// output against other existing program, so that if you load both your
|
|
|
|
// program and the other program into memory, your output can refer the
|
|
|
|
// other program's symbols.
|
|
|
|
//
|
|
|
|
// When the option is given, we link "just symbols". The section table is
|
|
|
|
// initialized with null pointers.
|
|
|
|
template <class ELFT> void ObjFile<ELFT>::initializeJustSymbols() {
|
|
|
|
ArrayRef<Elf_Shdr> ObjSections = CHECK(this->getObj().sections(), this);
|
|
|
|
this->Sections.resize(ObjSections.size());
|
|
|
|
|
|
|
|
for (const Elf_Shdr &Sec : ObjSections) {
|
|
|
|
if (Sec.sh_type != SHT_SYMTAB)
|
|
|
|
continue;
|
2019-04-06 04:16:26 +08:00
|
|
|
this->initSymtab<ELFT>(ObjSections, &Sec);
|
2018-03-30 09:15:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
void ObjFile<ELFT>::initializeSections(
|
2017-05-26 05:53:02 +08:00
|
|
|
DenseSet<CachedHashStringRef> &ComdatGroups) {
|
2017-05-26 10:17:30 +08:00
|
|
|
const ELFFile<ELFT> &Obj = this->getObj();
|
|
|
|
|
2018-05-14 21:21:09 +08:00
|
|
|
ArrayRef<Elf_Shdr> ObjSections = CHECK(Obj.sections(), this);
|
2016-11-02 22:42:20 +08:00
|
|
|
uint64_t Size = ObjSections.size();
|
2017-03-21 16:44:25 +08:00
|
|
|
this->Sections.resize(Size);
|
2017-06-13 02:46:33 +08:00
|
|
|
this->SectionStringTable =
|
2017-12-07 11:24:57 +08:00
|
|
|
CHECK(Obj.getSectionStringTable(ObjSections), this);
|
2017-05-26 10:17:30 +08:00
|
|
|
|
|
|
|
for (size_t I = 0, E = ObjSections.size(); I < E; I++) {
|
2017-03-21 16:44:25 +08:00
|
|
|
if (this->Sections[I] == &InputSection::Discarded)
|
2015-10-10 03:25:07 +08:00
|
|
|
continue;
|
2017-05-26 10:17:30 +08:00
|
|
|
const Elf_Shdr &Sec = ObjSections[I];
|
2015-10-10 03:25:07 +08:00
|
|
|
|
2018-10-02 08:17:15 +08:00
|
|
|
if (Sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE)
|
2019-01-26 05:25:25 +08:00
|
|
|
CGProfile =
|
|
|
|
check(Obj.template getSectionContentsAsArray<Elf_CGProfile>(&Sec));
|
2018-10-02 08:17:15 +08:00
|
|
|
|
2016-10-05 00:47:49 +08:00
|
|
|
// SHF_EXCLUDE'ed sections are discarded by the linker. However,
|
|
|
|
// if -r is given, we'll let the final link discard such sections.
|
|
|
|
// This is compatible with GNU.
|
|
|
|
if ((Sec.sh_flags & SHF_EXCLUDE) && !Config->Relocatable) {
|
2018-07-19 06:49:31 +08:00
|
|
|
if (Sec.sh_type == SHT_LLVM_ADDRSIG) {
|
|
|
|
// We ignore the address-significance table if we know that the object
|
|
|
|
// file was created by objcopy or ld -r. This is because these tools
|
|
|
|
// will reorder the symbols in the symbol table, invalidating the data
|
|
|
|
// in the address-significance table, which refers to symbols by index.
|
|
|
|
if (Sec.sh_link != 0)
|
|
|
|
this->AddrsigSec = &Sec;
|
|
|
|
else if (Config->ICF == ICFLevel::Safe)
|
|
|
|
warn(toString(this) + ": --icf=safe is incompatible with object "
|
|
|
|
"files created using objcopy or ld -r");
|
|
|
|
}
|
2017-03-21 16:44:25 +08:00
|
|
|
this->Sections[I] = &InputSection::Discarded;
|
2016-09-28 16:42:02 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-08-13 22:45:44 +08:00
|
|
|
switch (Sec.sh_type) {
|
2017-05-29 16:37:50 +08:00
|
|
|
case SHT_GROUP: {
|
2017-06-09 10:42:20 +08:00
|
|
|
// De-duplicate section groups by their signatures.
|
|
|
|
StringRef Signature = getShtGroupSignature(ObjSections, Sec);
|
|
|
|
this->Sections[I] = &InputSection::Discarded;
|
|
|
|
|
2018-08-15 20:20:38 +08:00
|
|
|
|
2019-01-25 01:56:08 +08:00
|
|
|
ArrayRef<Elf_Word> Entries =
|
|
|
|
CHECK(Obj.template getSectionContentsAsArray<Elf_Word>(&Sec), this);
|
|
|
|
if (Entries.empty())
|
|
|
|
fatal(toString(this) + ": empty SHT_GROUP");
|
|
|
|
|
|
|
|
// The first word of a SHT_GROUP section contains flags. Currently,
|
|
|
|
// the standard defines only "GRP_COMDAT" flag for the COMDAT group.
|
|
|
|
// An group with the empty flag doesn't define anything; such sections
|
|
|
|
// are just skipped.
|
|
|
|
if (Entries[0] == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (Entries[0] != GRP_COMDAT)
|
|
|
|
fatal(toString(this) + ": unsupported SHT_GROUP format");
|
|
|
|
|
|
|
|
bool IsNew = ComdatGroups.insert(CachedHashStringRef(Signature)).second;
|
2017-06-09 10:42:20 +08:00
|
|
|
if (IsNew) {
|
|
|
|
if (Config->Relocatable)
|
2017-06-13 02:46:33 +08:00
|
|
|
this->Sections[I] = createInputSection(Sec);
|
2019-01-25 02:17:17 +08:00
|
|
|
continue;
|
2017-06-09 10:42:20 +08:00
|
|
|
}
|
2017-05-29 16:37:50 +08:00
|
|
|
|
2017-06-09 10:42:20 +08:00
|
|
|
// Otherwise, discard group members.
|
2019-01-25 01:56:08 +08:00
|
|
|
for (uint32_t SecIndex : Entries.slice(1)) {
|
2015-10-10 03:25:07 +08:00
|
|
|
if (SecIndex >= Size)
|
2017-03-21 16:44:25 +08:00
|
|
|
fatal(toString(this) +
|
|
|
|
": invalid section index in group: " + Twine(SecIndex));
|
|
|
|
this->Sections[SecIndex] = &InputSection::Discarded;
|
2015-10-10 03:25:07 +08:00
|
|
|
}
|
|
|
|
break;
|
2017-05-29 16:37:50 +08:00
|
|
|
}
|
2015-08-13 22:45:44 +08:00
|
|
|
case SHT_SYMTAB:
|
2019-04-06 04:16:26 +08:00
|
|
|
this->initSymtab<ELFT>(ObjSections, &Sec);
|
2015-08-13 22:45:44 +08:00
|
|
|
break;
|
2016-03-04 00:21:44 +08:00
|
|
|
case SHT_SYMTAB_SHNDX:
|
2019-04-06 04:16:26 +08:00
|
|
|
SymtabSHNDX = CHECK(Obj.getSHNDXTable(Sec, ObjSections), this);
|
2015-08-25 05:43:25 +08:00
|
|
|
break;
|
2015-08-13 22:45:44 +08:00
|
|
|
case SHT_STRTAB:
|
|
|
|
case SHT_NULL:
|
2015-08-28 07:15:56 +08:00
|
|
|
break;
|
2015-11-22 06:19:32 +08:00
|
|
|
default:
|
2017-06-13 02:46:33 +08:00
|
|
|
this->Sections[I] = createInputSection(Sec);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2016-11-02 21:36:31 +08:00
|
|
|
// .ARM.exidx sections have a reverse dependency on the InputSection they
|
|
|
|
// have a SHF_LINK_ORDER dependency, this is identified by the sh_link.
|
|
|
|
if (Sec.sh_flags & SHF_LINK_ORDER) {
|
2018-09-07 08:18:07 +08:00
|
|
|
InputSectionBase *LinkSec = nullptr;
|
|
|
|
if (Sec.sh_link < this->Sections.size())
|
|
|
|
LinkSec = this->Sections[Sec.sh_link];
|
|
|
|
if (!LinkSec)
|
2017-12-21 03:59:47 +08:00
|
|
|
fatal(toString(this) +
|
|
|
|
": invalid sh_link index: " + Twine(Sec.sh_link));
|
2018-03-08 23:06:58 +08:00
|
|
|
|
|
|
|
InputSection *IS = cast<InputSection>(this->Sections[I]);
|
|
|
|
LinkSec->DependentSections.push_back(IS);
|
|
|
|
if (!isa<InputSection>(LinkSec))
|
|
|
|
error("a section " + IS->Name +
|
|
|
|
" with SHF_LINK_ORDER should not refer a non-regular "
|
|
|
|
"section: " +
|
|
|
|
toString(LinkSec));
|
2016-11-02 21:36:31 +08:00
|
|
|
}
|
2016-10-10 18:10:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-31 21:41:59 +08:00
|
|
|
// For ARM only, to set the EF_ARM_ABI_FLOAT_SOFT or EF_ARM_ABI_FLOAT_HARD
|
|
|
|
// flag in the ELF Header we need to look at Tag_ABI_VFP_args to find out how
|
|
|
|
// the input objects have been compiled.
|
|
|
|
static void updateARMVFPArgs(const ARMAttributeParser &Attributes,
|
|
|
|
const InputFile *F) {
|
|
|
|
if (!Attributes.hasAttribute(ARMBuildAttrs::ABI_VFP_args))
|
|
|
|
// If an ABI tag isn't present then it is implicitly given the value of 0
|
|
|
|
// which maps to ARMBuildAttrs::BaseAAPCS. However many assembler files,
|
|
|
|
// including some in glibc that don't use FP args (and should have value 3)
|
|
|
|
// don't have the attribute so we do not consider an implicit value of 0
|
|
|
|
// as a clash.
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned VFPArgs = Attributes.getAttributeValue(ARMBuildAttrs::ABI_VFP_args);
|
|
|
|
ARMVFPArgKind Arg;
|
|
|
|
switch (VFPArgs) {
|
|
|
|
case ARMBuildAttrs::BaseAAPCS:
|
|
|
|
Arg = ARMVFPArgKind::Base;
|
|
|
|
break;
|
|
|
|
case ARMBuildAttrs::HardFPAAPCS:
|
|
|
|
Arg = ARMVFPArgKind::VFP;
|
|
|
|
break;
|
|
|
|
case ARMBuildAttrs::ToolChainFPPCS:
|
|
|
|
// Tool chain specific convention that conforms to neither AAPCS variant.
|
|
|
|
Arg = ARMVFPArgKind::ToolChain;
|
|
|
|
break;
|
|
|
|
case ARMBuildAttrs::CompatibleFPAAPCS:
|
|
|
|
// Object compatible with all conventions.
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
error(toString(F) + ": unknown Tag_ABI_VFP_args value: " + Twine(VFPArgs));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Follow ld.bfd and error if there is a mix of calling conventions.
|
|
|
|
if (Config->ARMVFPArgs != Arg && Config->ARMVFPArgs != ARMVFPArgKind::Default)
|
|
|
|
error(toString(F) + ": incompatible Tag_ABI_VFP_args");
|
|
|
|
else
|
|
|
|
Config->ARMVFPArgs = Arg;
|
|
|
|
}
|
|
|
|
|
2017-11-28 21:51:48 +08:00
|
|
|
// The ARM support in lld makes some use of instructions that are not available
|
|
|
|
// on all ARM architectures. Namely:
|
|
|
|
// - Use of BLX instruction for interworking between ARM and Thumb state.
|
|
|
|
// - Use of the extended Thumb branch encoding in relocation.
|
|
|
|
// - Use of the MOVT/MOVW instructions in Thumb Thunks.
|
|
|
|
// The ARM Attributes section contains information about the architecture chosen
|
|
|
|
// at compile time. We follow the convention that if at least one input object
|
|
|
|
// is compiled with an architecture that supports these features then lld is
|
|
|
|
// permitted to use them.
|
|
|
|
static void updateSupportedARMFeatures(const ARMAttributeParser &Attributes) {
|
|
|
|
if (!Attributes.hasAttribute(ARMBuildAttrs::CPU_arch))
|
|
|
|
return;
|
|
|
|
auto Arch = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
|
|
|
|
switch (Arch) {
|
|
|
|
case ARMBuildAttrs::Pre_v4:
|
|
|
|
case ARMBuildAttrs::v4:
|
|
|
|
case ARMBuildAttrs::v4T:
|
|
|
|
// Architectures prior to v5 do not support BLX instruction
|
|
|
|
break;
|
|
|
|
case ARMBuildAttrs::v5T:
|
|
|
|
case ARMBuildAttrs::v5TE:
|
|
|
|
case ARMBuildAttrs::v5TEJ:
|
|
|
|
case ARMBuildAttrs::v6:
|
|
|
|
case ARMBuildAttrs::v6KZ:
|
|
|
|
case ARMBuildAttrs::v6K:
|
|
|
|
Config->ARMHasBlx = true;
|
|
|
|
// Architectures used in pre-Cortex processors do not support
|
|
|
|
// The J1 = 1 J2 = 1 Thumb branch range extension, with the exception
|
|
|
|
// of Architecture v6T2 (arm1156t2-s and arm1156t2f-s) that do.
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// All other Architectures have BLX and extended branch encoding
|
|
|
|
Config->ARMHasBlx = true;
|
|
|
|
Config->ARMJ1J2BranchEncoding = true;
|
|
|
|
if (Arch != ARMBuildAttrs::v6_M && Arch != ARMBuildAttrs::v6S_M)
|
|
|
|
// All Architectures used in Cortex processors with the exception
|
|
|
|
// of v6-M and v6S-M have the MOVT and MOVW instructions.
|
|
|
|
Config->ARMHasMovtMovw = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-14 05:52:57 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
InputSectionBase *ObjFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
|
2016-03-14 05:52:57 +08:00
|
|
|
uint32_t Idx = Sec.sh_info;
|
2017-03-21 16:44:25 +08:00
|
|
|
if (Idx >= this->Sections.size())
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": invalid relocated section index: " + Twine(Idx));
|
2017-03-21 16:44:25 +08:00
|
|
|
InputSectionBase *Target = this->Sections[Idx];
|
2016-03-14 05:52:57 +08:00
|
|
|
|
|
|
|
// Strictly speaking, a relocation section must be included in the
|
|
|
|
// group of the section it relocates. However, LLVM 3.3 and earlier
|
|
|
|
// would fail to do so, so we gracefully handle that case.
|
2017-02-24 00:49:07 +08:00
|
|
|
if (Target == &InputSection::Discarded)
|
2016-03-14 05:52:57 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
if (!Target)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": unsupported relocation reference");
|
2016-03-14 05:52:57 +08:00
|
|
|
return Target;
|
|
|
|
}
|
|
|
|
|
2017-05-02 04:49:09 +08:00
|
|
|
// Create a regular InputSection class that has the same contents
|
|
|
|
// as a given section.
|
2017-12-21 10:11:51 +08:00
|
|
|
static InputSection *toRegularSection(MergeInputSection *Sec) {
|
|
|
|
return make<InputSection>(Sec->File, Sec->Flags, Sec->Type, Sec->Alignment,
|
Avoid unnecessary buffer allocation and memcpy for compressed sections.
Previously, we uncompress all compressed sections before doing anything.
That works, and that is conceptually simple, but that could results in
a waste of CPU time and memory if uncompressed sections are then
discarded or just copied to the output buffer.
In particular, if .debug_gnu_pub{names,types} are compressed and if no
-gdb-index option is given, we wasted CPU and memory because we
uncompress them into newly allocated bufers and then memcpy the buffers
to the output buffer. That temporary buffer was redundant.
This patch changes how to uncompress sections. Now, compressed sections
are uncompressed lazily. To do that, `Data` member of `InputSectionBase`
is now hidden from outside, and `data()` accessor automatically expands
an compressed buffer if necessary.
If no one calls `data()`, then `writeTo()` directly uncompresses
compressed data into the output buffer. That eliminates the redundant
memory allocation and redundant memcpy.
This patch significantly reduces memory consumption (20 GiB max RSS to
15 Gib) for an executable whose .debug_gnu_pub{names,types} are in total
5 GiB in an uncompressed form.
Differential Revision: https://reviews.llvm.org/D52917
llvm-svn: 343979
2018-10-09 00:58:59 +08:00
|
|
|
Sec->data(), Sec->Name);
|
2017-05-02 04:49:09 +08:00
|
|
|
}
|
|
|
|
|
2016-02-13 05:17:10 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
|
2017-06-13 02:46:33 +08:00
|
|
|
StringRef Name = getSectionName(Sec);
|
2015-12-24 16:41:12 +08:00
|
|
|
|
2016-09-08 22:06:08 +08:00
|
|
|
switch (Sec.sh_type) {
|
2017-11-28 21:51:48 +08:00
|
|
|
case SHT_ARM_ATTRIBUTES: {
|
2017-11-29 18:20:46 +08:00
|
|
|
if (Config->EMachine != EM_ARM)
|
|
|
|
break;
|
2017-11-28 21:51:48 +08:00
|
|
|
ARMAttributeParser Attributes;
|
|
|
|
ArrayRef<uint8_t> Contents = check(this->getObj().getSectionContents(&Sec));
|
2017-12-21 03:59:47 +08:00
|
|
|
Attributes.Parse(Contents, /*isLittle*/ Config->EKind == ELF32LEKind);
|
2017-11-28 21:51:48 +08:00
|
|
|
updateSupportedARMFeatures(Attributes);
|
2018-07-31 21:41:59 +08:00
|
|
|
updateARMVFPArgs(Attributes, this);
|
|
|
|
|
2017-11-28 21:51:48 +08:00
|
|
|
// FIXME: Retain the first attribute section we see. The eglibc ARM
|
|
|
|
// dynamic loaders require the presence of an attribute section for dlopen
|
|
|
|
// to work. In a full implementation we would merge all attribute sections.
|
2018-09-26 03:26:58 +08:00
|
|
|
if (In.ARMAttributes == nullptr) {
|
|
|
|
In.ARMAttributes = make<InputSection>(*this, Sec, Name);
|
|
|
|
return In.ARMAttributes;
|
2016-12-14 18:36:12 +08:00
|
|
|
}
|
2017-02-24 00:49:07 +08:00
|
|
|
return &InputSection::Discarded;
|
2017-11-28 21:51:48 +08:00
|
|
|
}
|
2016-09-08 22:06:08 +08:00
|
|
|
case SHT_RELA:
|
|
|
|
case SHT_REL: {
|
2018-03-27 10:52:58 +08:00
|
|
|
// Find a relocation target section and associate this section with that.
|
|
|
|
// Target may have been discarded if it is in a different section group
|
|
|
|
// and the group is discarded, even though it's a violation of the
|
|
|
|
// spec. We handle that situation gracefully by discarding dangling
|
|
|
|
// relocation sections.
|
2017-02-23 10:28:28 +08:00
|
|
|
InputSectionBase *Target = getRelocTarget(Sec);
|
2017-02-15 00:42:38 +08:00
|
|
|
if (!Target)
|
|
|
|
return nullptr;
|
|
|
|
|
2016-09-08 22:06:08 +08:00
|
|
|
// This section contains relocation information.
|
|
|
|
// If -r is given, we do not interpret or apply relocation
|
|
|
|
// but just copy relocation sections to output.
|
2018-11-01 17:20:06 +08:00
|
|
|
if (Config->Relocatable) {
|
|
|
|
InputSection *RelocSec = make<InputSection>(*this, Sec, Name);
|
|
|
|
// We want to add a dependency to target, similar like we do for
|
|
|
|
// -emit-relocs below. This is useful for the case when linker script
|
|
|
|
// contains the "/DISCARD/". It is perhaps uncommon to use a script with
|
|
|
|
// -r, but we faced it in the Linux kernel and have to handle such case
|
|
|
|
// and not to crash.
|
|
|
|
Target->DependentSections.push_back(RelocSec);
|
|
|
|
return RelocSec;
|
|
|
|
}
|
2016-09-08 22:06:08 +08:00
|
|
|
|
2016-11-10 22:53:24 +08:00
|
|
|
if (Target->FirstRelocation)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) +
|
2016-11-10 22:53:24 +08:00
|
|
|
": multiple relocation sections to one section are not supported");
|
2017-05-02 04:49:09 +08:00
|
|
|
|
2018-03-27 10:52:58 +08:00
|
|
|
// ELF spec allows mergeable sections with relocations, but they are
|
|
|
|
// rare, and it is in practice hard to merge such sections by contents,
|
|
|
|
// because applying relocations at end of linking changes section
|
|
|
|
// contents. So, we simply handle such sections as non-mergeable ones.
|
|
|
|
// Degrading like this is acceptable because section merging is optional.
|
2017-05-02 04:49:09 +08:00
|
|
|
if (auto *MS = dyn_cast<MergeInputSection>(Target)) {
|
|
|
|
Target = toRegularSection(MS);
|
|
|
|
this->Sections[Sec.sh_info] = Target;
|
2017-04-29 09:24:34 +08:00
|
|
|
}
|
2016-11-10 22:53:24 +08:00
|
|
|
|
|
|
|
if (Sec.sh_type == SHT_RELA) {
|
2019-04-06 04:16:26 +08:00
|
|
|
ArrayRef<Elf_Rela> Rels = CHECK(getObj().relas(&Sec), this);
|
2016-11-10 22:53:24 +08:00
|
|
|
Target->FirstRelocation = Rels.begin();
|
2018-03-27 10:53:08 +08:00
|
|
|
Target->NumRelocations = Rels.size();
|
2016-11-10 22:53:24 +08:00
|
|
|
Target->AreRelocsRela = true;
|
|
|
|
} else {
|
2019-04-06 04:16:26 +08:00
|
|
|
ArrayRef<Elf_Rel> Rels = CHECK(getObj().rels(&Sec), this);
|
2016-11-10 22:53:24 +08:00
|
|
|
Target->FirstRelocation = Rels.begin();
|
2018-03-27 10:53:08 +08:00
|
|
|
Target->NumRelocations = Rels.size();
|
2016-11-10 22:53:24 +08:00
|
|
|
Target->AreRelocsRela = false;
|
2016-09-08 22:06:08 +08:00
|
|
|
}
|
2018-03-27 10:53:08 +08:00
|
|
|
assert(isUInt<31>(Target->NumRelocations));
|
2017-02-09 00:18:10 +08:00
|
|
|
|
|
|
|
// Relocation sections processed by the linker are usually removed
|
|
|
|
// from the output, so returning `nullptr` for the normal case.
|
|
|
|
// However, if -emit-relocs is given, we need to leave them in the output.
|
|
|
|
// (Some post link analysis tools need this information.)
|
2017-02-18 03:46:47 +08:00
|
|
|
if (Config->EmitRelocs) {
|
2017-12-21 10:03:39 +08:00
|
|
|
InputSection *RelocSec = make<InputSection>(*this, Sec, Name);
|
2017-02-18 03:46:47 +08:00
|
|
|
// We will not emit relocation section if target was discarded.
|
|
|
|
Target->DependentSections.push_back(RelocSec);
|
|
|
|
return RelocSec;
|
|
|
|
}
|
2016-11-10 22:53:24 +08:00
|
|
|
return nullptr;
|
2016-09-08 22:06:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-23 15:06:43 +08:00
|
|
|
// The GNU linker uses .note.GNU-stack section as a marker indicating
|
|
|
|
// that the code in the object file does not expect that the stack is
|
|
|
|
// executable (in terms of NX bit). If all input files have the marker,
|
|
|
|
// the GNU linker adds a PT_GNU_STACK segment to tells the loader to
|
2017-02-23 15:15:46 +08:00
|
|
|
// make the stack non-executable. Most object files have this section as
|
|
|
|
// of 2017.
|
2017-02-23 15:06:43 +08:00
|
|
|
//
|
|
|
|
// But making the stack non-executable is a norm today for security
|
2017-02-23 15:15:46 +08:00
|
|
|
// reasons. Failure to do so may result in a serious security issue.
|
|
|
|
// Therefore, we make LLD always add PT_GNU_STACK unless it is
|
2017-02-23 15:06:43 +08:00
|
|
|
// explicitly told to do otherwise (by -z execstack). Because the stack
|
|
|
|
// executable-ness is controlled solely by command line options,
|
|
|
|
// .note.GNU-stack sections are simply ignored.
|
2015-12-24 16:41:12 +08:00
|
|
|
if (Name == ".note.GNU-stack")
|
2017-02-24 00:49:07 +08:00
|
|
|
return &InputSection::Discarded;
|
2015-12-24 16:41:12 +08:00
|
|
|
|
2018-07-18 07:16:02 +08:00
|
|
|
// Split stacks is a feature to support a discontiguous stack,
|
|
|
|
// commonly used in the programming language Go. For the details,
|
|
|
|
// see https://gcc.gnu.org/wiki/SplitStacks. An object file compiled
|
|
|
|
// for split stack will include a .note.GNU-split-stack section.
|
2016-04-08 05:04:51 +08:00
|
|
|
if (Name == ".note.GNU-split-stack") {
|
2018-07-18 07:16:02 +08:00
|
|
|
if (Config->Relocatable) {
|
2018-09-26 01:12:50 +08:00
|
|
|
error("cannot mix split-stack and non-split-stack in a relocatable link");
|
2018-07-18 07:16:02 +08:00
|
|
|
return &InputSection::Discarded;
|
|
|
|
}
|
|
|
|
this->SplitStack = true;
|
|
|
|
return &InputSection::Discarded;
|
|
|
|
}
|
|
|
|
|
|
|
|
// An object file cmpiled for split stack, but where some of the
|
|
|
|
// functions were compiled with the no_split_stack_attribute will
|
|
|
|
// include a .note.GNU-no-split-stack section.
|
|
|
|
if (Name == ".note.GNU-no-split-stack") {
|
|
|
|
this->SomeNoSplitStack = true;
|
2017-02-24 00:49:07 +08:00
|
|
|
return &InputSection::Discarded;
|
2016-04-08 05:04:51 +08:00
|
|
|
}
|
|
|
|
|
2017-01-10 04:26:33 +08:00
|
|
|
// The linkonce feature is a sort of proto-comdat. Some glibc i386 object
|
|
|
|
// files contain definitions of symbol "__x86.get_pc_thunk.bx" in linkonce
|
|
|
|
// sections. Drop those sections to avoid duplicate symbol errors.
|
|
|
|
// FIXME: This is glibc PR20543, we should remove this hack once that has been
|
|
|
|
// fixed for a while.
|
lld: elf: discard more specific .gnu.linkonce section
Summary:
lld discards .gnu.linonce.* sections work around a bug in glibc.
https://sourceware.org/bugzilla/show_bug.cgi?id=20543
Unfortunately, the Linux kernel uses a section named
.gnu.linkonce.this_module to store infomation about kernel modules. The
kernel reads data from this section when loading kernel modules, and
errors if it fails to find this section. The current behavior of lld
discards this section when kernel modules are linked, so kernel modules
linked with lld are unloadable by the linux kernel.
The Linux kernel should use a comdat section instead of .gnu.linkonce.
The minimum version of binutils supported by the kernel supports comdat
sections. The kernel is also not relying on the old linkonce behavior;
it seems to have chosen a name that contains a deprecated GNU feature.
Changing the section name now in the kernel would require all kernel
modules to be recompiled to make use of the new section name. Instead,
rather than discarding .gnu.linkonce.*, let's discard the more specific
section name to continue working around the glibc issue while supporting
linking Linux kernel modules.
Link: https://github.com/ClangBuiltLinux/linux/issues/329
Reviewers: pcc, espindola
Reviewed By: pcc
Subscribers: nathanchance, emaste, arichardson, void, srhines
Differential Revision: https://reviews.llvm.org/D57294
llvm-svn: 352302
2019-01-27 10:54:23 +08:00
|
|
|
if (Name == ".gnu.linkonce.t.__x86.get_pc_thunk.bx" ||
|
|
|
|
Name == ".gnu.linkonce.t.__i686.get_pc_thunk.bx")
|
2017-02-24 00:49:07 +08:00
|
|
|
return &InputSection::Discarded;
|
2017-01-10 04:26:33 +08:00
|
|
|
|
2018-02-03 05:56:24 +08:00
|
|
|
// If we are creating a new .build-id section, strip existing .build-id
|
|
|
|
// sections so that the output won't have more than one .build-id.
|
|
|
|
// This is not usually a problem because input object files normally don't
|
|
|
|
// have .build-id sections, but you can create such files by
|
|
|
|
// "ld.{bfd,gold,lld} -r --build-id", and we want to guard against it.
|
|
|
|
if (Name == ".note.gnu.build-id" && Config->BuildId != BuildIdKind::None)
|
|
|
|
return &InputSection::Discarded;
|
|
|
|
|
2016-07-15 12:57:44 +08:00
|
|
|
// The linker merges EH (exception handling) frames and creates a
|
|
|
|
// .eh_frame_hdr section for runtime. So we handle them with a special
|
|
|
|
// class. For relocatable outputs, they are just passed through.
|
|
|
|
if (Name == ".eh_frame" && !Config->Relocatable)
|
2017-12-21 10:03:39 +08:00
|
|
|
return make<EhInputSection>(*this, Sec, Name);
|
2016-07-15 12:57:44 +08:00
|
|
|
|
2016-07-16 04:38:28 +08:00
|
|
|
if (shouldMerge(Sec))
|
2017-12-21 10:03:39 +08:00
|
|
|
return make<MergeInputSection>(*this, Sec, Name);
|
|
|
|
return make<InputSection>(*this, Sec, Name);
|
2015-12-24 16:41:12 +08:00
|
|
|
}
|
|
|
|
|
2017-06-13 02:46:33 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
StringRef ObjFile<ELFT>::getSectionName(const Elf_Shdr &Sec) {
|
2019-04-06 04:16:26 +08:00
|
|
|
return CHECK(getObj().getSectionName(&Sec, SectionStringTable), this);
|
2017-06-13 02:46:33 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template <class ELFT> void ObjFile<ELFT>::initializeSymbols() {
|
2019-04-06 04:16:26 +08:00
|
|
|
this->Symbols.reserve(this->getELFSyms<ELFT>().size());
|
|
|
|
for (const Elf_Sym &Sym : this->getELFSyms<ELFT>())
|
2017-11-04 05:21:47 +08:00
|
|
|
this->Symbols.push_back(createSymbol(&Sym));
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2017-11-04 05:21:47 +08:00
|
|
|
template <class ELFT> Symbol *ObjFile<ELFT>::createSymbol(const Elf_Sym *Sym) {
|
2016-07-16 04:38:28 +08:00
|
|
|
int Binding = Sym->getBinding();
|
2016-11-23 14:59:47 +08:00
|
|
|
|
2019-04-06 04:16:26 +08:00
|
|
|
uint32_t SecIdx = getSectionIndex(*Sym);
|
2017-12-14 06:53:59 +08:00
|
|
|
if (SecIdx >= this->Sections.size())
|
|
|
|
fatal(toString(this) + ": invalid section index: " + Twine(SecIdx));
|
|
|
|
|
|
|
|
InputSectionBase *Sec = this->Sections[SecIdx];
|
2016-11-30 02:05:04 +08:00
|
|
|
uint8_t StOther = Sym->st_other;
|
|
|
|
uint8_t Type = Sym->getType();
|
2017-02-25 03:52:52 +08:00
|
|
|
uint64_t Value = Sym->st_value;
|
|
|
|
uint64_t Size = Sym->st_size;
|
2016-11-30 02:05:04 +08:00
|
|
|
|
2016-03-11 22:21:37 +08:00
|
|
|
if (Binding == STB_LOCAL) {
|
2016-10-26 19:07:09 +08:00
|
|
|
if (Sym->getType() == STT_FILE)
|
2017-12-07 11:24:57 +08:00
|
|
|
SourceFile = CHECK(Sym->getName(this->StringTable), this);
|
2016-11-23 12:57:25 +08:00
|
|
|
|
|
|
|
if (this->StringTable.size() <= Sym->st_name)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": invalid symbol name offset");
|
2016-11-23 12:57:25 +08:00
|
|
|
|
2016-11-30 03:11:39 +08:00
|
|
|
StringRefZ Name = this->StringTable.data() + Sym->st_name;
|
2016-04-04 22:04:16 +08:00
|
|
|
if (Sym->st_shndx == SHN_UNDEF)
|
2017-11-30 06:47:35 +08:00
|
|
|
return make<Undefined>(this, Name, Binding, StOther, Type);
|
2016-11-30 02:05:04 +08:00
|
|
|
|
2017-11-30 06:47:35 +08:00
|
|
|
return make<Defined>(this, Name, Binding, StOther, Type, Value, Size, Sec);
|
2016-03-11 22:21:37 +08:00
|
|
|
}
|
2016-03-11 20:06:30 +08:00
|
|
|
|
2017-12-07 11:24:57 +08:00
|
|
|
StringRef Name = CHECK(Sym->getName(this->StringTable), this);
|
2015-08-25 05:43:25 +08:00
|
|
|
|
2015-10-16 23:29:48 +08:00
|
|
|
switch (Sym->st_shndx) {
|
2015-08-29 05:26:51 +08:00
|
|
|
case SHN_UNDEF:
|
2017-11-17 09:37:50 +08:00
|
|
|
return Symtab->addUndefined<ELFT>(Name, Binding, StOther, Type,
|
2017-11-01 00:07:41 +08:00
|
|
|
/*CanOmitFromDynSym=*/false, this);
|
2015-08-29 05:26:51 +08:00
|
|
|
case SHN_COMMON:
|
2016-11-23 14:59:47 +08:00
|
|
|
if (Value == 0 || Value >= UINT32_MAX)
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": common symbol '" + Name +
|
2016-11-23 14:59:47 +08:00
|
|
|
"' has invalid alignment: " + Twine(Value));
|
2017-12-21 00:19:48 +08:00
|
|
|
return Symtab->addCommon(Name, Size, Value, Binding, StOther, Type, *this);
|
2015-08-29 05:26:51 +08:00
|
|
|
}
|
2015-08-25 05:43:25 +08:00
|
|
|
|
2016-03-11 20:06:30 +08:00
|
|
|
switch (Binding) {
|
2015-08-12 01:33:02 +08:00
|
|
|
default:
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": unexpected binding: " + Twine(Binding));
|
2015-08-12 01:33:02 +08:00
|
|
|
case STB_GLOBAL:
|
2015-08-29 04:19:34 +08:00
|
|
|
case STB_WEAK:
|
2016-03-11 22:21:37 +08:00
|
|
|
case STB_GNU_UNIQUE:
|
2017-02-24 00:49:07 +08:00
|
|
|
if (Sec == &InputSection::Discarded)
|
2017-11-17 09:37:50 +08:00
|
|
|
return Symtab->addUndefined<ELFT>(Name, Binding, StOther, Type,
|
2017-11-01 00:07:41 +08:00
|
|
|
/*CanOmitFromDynSym=*/false, this);
|
2018-10-12 04:43:01 +08:00
|
|
|
return Symtab->addDefined(Name, StOther, Type, Value, Size, Binding, Sec,
|
2017-12-24 01:21:39 +08:00
|
|
|
this);
|
2015-10-10 03:25:07 +08:00
|
|
|
}
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2017-05-04 05:03:08 +08:00
|
|
|
ArchiveFile::ArchiveFile(std::unique_ptr<Archive> &&File)
|
|
|
|
: InputFile(ArchiveKind, File->getMemoryBufferRef()),
|
|
|
|
File(std::move(File)) {}
|
2015-09-05 06:28:10 +08:00
|
|
|
|
2017-05-04 05:03:08 +08:00
|
|
|
template <class ELFT> void ArchiveFile::parse() {
|
|
|
|
for (const Archive::Symbol &Sym : File->symbols())
|
2018-02-17 04:23:54 +08:00
|
|
|
Symtab->addLazyArchive<ELFT>(Sym.getName(), *this, Sym);
|
2015-09-05 06:28:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a buffer pointing to a member file containing a given symbol.
|
2018-04-03 10:06:57 +08:00
|
|
|
InputFile *ArchiveFile::fetch(const Archive::Symbol &Sym) {
|
2016-03-04 00:21:44 +08:00
|
|
|
Archive::Child C =
|
2018-04-03 10:06:57 +08:00
|
|
|
CHECK(Sym.getMember(), toString(this) +
|
|
|
|
": could not get the member for symbol " +
|
|
|
|
Sym.getName());
|
2015-09-05 06:28:10 +08:00
|
|
|
|
2015-11-05 22:40:28 +08:00
|
|
|
if (!Seen.insert(C.getChildOffset()).second)
|
2018-04-03 10:06:57 +08:00
|
|
|
return nullptr;
|
2015-09-09 04:36:20 +08:00
|
|
|
|
2018-04-03 10:06:57 +08:00
|
|
|
MemoryBufferRef MB =
|
2017-12-07 06:08:17 +08:00
|
|
|
CHECK(C.getMemoryBufferRef(),
|
2017-04-04 03:11:23 +08:00
|
|
|
toString(this) +
|
2017-03-31 05:13:00 +08:00
|
|
|
": could not get the buffer for the member defining symbol " +
|
2018-04-03 10:06:57 +08:00
|
|
|
Sym.getName());
|
|
|
|
|
|
|
|
if (Tar && C.getParent()->isThin())
|
|
|
|
Tar->append(relativeToRoot(CHECK(C.getFullName(), this)), MB.getBuffer());
|
2016-05-02 21:54:10 +08:00
|
|
|
|
Add --warn-backrefs to maintain compatibility with other linkers
I'm proposing a new command line flag, --warn-backrefs in this patch.
The flag and the feature proposed below don't exist in GNU linkers
nor the current lld.
--warn-backrefs is an option to detect reverse or cyclic dependencies
between static archives, and it can be used to keep your program
compatible with GNU linkers after you switch to lld. I'll explain the
feature and why you may find it useful below.
lld's symbol resolution semantics is more relaxed than traditional
Unix linkers. Therefore,
ld.lld foo.a bar.o
succeeds even if bar.o contains an undefined symbol that have to be
resolved by some object file in foo.a. Traditional Unix linkers
don't allow this kind of backward reference, as they visit each
file only once from left to right in the command line while
resolving all undefined symbol at the moment of visiting.
In the above case, since there's no undefined symbol when a linker
visits foo.a, no files are pulled out from foo.a, and because the
linker forgets about foo.a after visiting, it can't resolve
undefined symbols that could have been resolved otherwise.
That lld accepts more relaxed form means (besides it makes more
sense) that you can accidentally write a command line or a build
file that works only with lld, even if you have a plan to
distribute it to wider users who may be using GNU linkers. With
--check-library-dependency, you can detect a library order that
doesn't work with other Unix linkers.
The option is also useful to detect cyclic dependencies between
static archives. Again, lld accepts
ld.lld foo.a bar.a
even if foo.a and bar.a depend on each other. With --warn-backrefs
it is handled as an error.
Here is how the option works. We assign a group ID to each file. A
file with a smaller group ID can pull out object files from an
archive file with an equal or greater group ID. Otherwise, it is a
reverse dependency and an error.
A file outside --{start,end}-group gets a fresh ID when
instantiated. All files within the same --{start,end}-group get the
same group ID. E.g.
ld.lld A B --start-group C D --end-group E
A and B form group 0, C, D and their member object files form group
1, and E forms group 2. I think that you can see how this group
assignment rule simulates the traditional linker's semantics.
Differential Revision: https://reviews.llvm.org/D45195
llvm-svn: 329636
2018-04-10 07:05:48 +08:00
|
|
|
InputFile *File = createObjectFile(
|
|
|
|
MB, getName(), C.getParent()->isThin() ? 0 : C.getChildOffset());
|
|
|
|
File->GroupId = GroupId;
|
|
|
|
return File;
|
2015-09-05 06:28:10 +08:00
|
|
|
}
|
|
|
|
|
2015-09-24 23:11:50 +08:00
|
|
|
template <class ELFT>
|
2017-04-25 05:44:20 +08:00
|
|
|
SharedFile<ELFT>::SharedFile(MemoryBufferRef M, StringRef DefaultSoName)
|
2019-04-06 04:16:26 +08:00
|
|
|
: ELFFileBase(SharedKind, M), SoName(DefaultSoName),
|
|
|
|
IsNeeded(!Config->AsNeeded) {
|
|
|
|
parseHeader<ELFT>();
|
|
|
|
}
|
2015-09-08 23:50:05 +08:00
|
|
|
|
2016-01-06 09:56:36 +08:00
|
|
|
// Partially parse the shared object file so that we can call
|
|
|
|
// getSoName on this object.
|
[ELF] Support --{,no-}allow-shlib-undefined
Summary:
In ld.bfd/gold, --no-allow-shlib-undefined is the default when linking
an executable. This patch implements a check to error on undefined
symbols in a shared object, if all of its DT_NEEDED entries are seen.
Our approach resembles the one used in gold, achieves a good balance to
be useful but not too smart (ld.bfd traces all DSOs and emulates the
behavior of a dynamic linker to catch more cases).
The error is issued based on the symbol table, different from undefined
reference errors issued for relocations. It is most effective when there
are DSOs that were not linked with -z defs (e.g. when static sanitizers
runtime is used).
gold has a comment that some system libraries on GNU/Linux may have
spurious undefined references and thus system libraries should be
excluded (https://sourceware.org/bugzilla/show_bug.cgi?id=6811). The
story may have changed now but we make --allow-shlib-undefined the
default for now. Its interaction with -shared can be discussed in the
future.
Reviewers: ruiu, grimar, pcc, espindola
Reviewed By: ruiu
Subscribers: joerg, emaste, arichardson, llvm-commits
Differential Revision: https://reviews.llvm.org/D57385
llvm-svn: 352826
2019-02-01 10:25:05 +08:00
|
|
|
template <class ELFT> void SharedFile<ELFT>::parseDynamic() {
|
2019-04-05 09:31:40 +08:00
|
|
|
ArrayRef<Elf_Dyn> DynamicTags;
|
2019-04-06 04:16:26 +08:00
|
|
|
const ELFFile<ELFT> Obj = this->getObj<ELFT>();
|
2017-12-07 11:24:57 +08:00
|
|
|
ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), this);
|
2017-04-13 08:23:32 +08:00
|
|
|
|
|
|
|
// Search for .dynsym, .dynamic, .symtab, .gnu.version and .gnu.version_d.
|
2016-11-03 20:21:00 +08:00
|
|
|
for (const Elf_Shdr &Sec : Sections) {
|
2015-11-03 22:13:40 +08:00
|
|
|
switch (Sec.sh_type) {
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
case SHT_DYNSYM:
|
2019-04-06 04:16:26 +08:00
|
|
|
this->initSymtab<ELFT>(Sections, &Sec);
|
2015-11-03 22:13:40 +08:00
|
|
|
break;
|
|
|
|
case SHT_DYNAMIC:
|
2019-04-05 09:31:40 +08:00
|
|
|
DynamicTags =
|
|
|
|
CHECK(Obj.template getSectionContentsAsArray<Elf_Dyn>(&Sec), this);
|
2015-11-03 22:13:40 +08:00
|
|
|
break;
|
2016-04-28 04:22:31 +08:00
|
|
|
case SHT_GNU_versym:
|
|
|
|
this->VersymSec = &Sec;
|
|
|
|
break;
|
|
|
|
case SHT_GNU_verdef:
|
|
|
|
this->VerdefSec = &Sec;
|
|
|
|
break;
|
2015-11-03 22:13:40 +08:00
|
|
|
}
|
2015-09-08 23:50:05 +08:00
|
|
|
}
|
|
|
|
|
2019-04-06 04:16:26 +08:00
|
|
|
if (this->VersymSec && this->getELFSyms<ELFT>().empty())
|
2016-11-02 18:16:25 +08:00
|
|
|
error("SHT_GNU_versym should be associated with symbol table");
|
|
|
|
|
2017-04-13 08:23:32 +08:00
|
|
|
// Search for a DT_SONAME tag to initialize this->SoName.
|
2019-04-05 09:31:40 +08:00
|
|
|
for (const Elf_Dyn &Dyn : DynamicTags) {
|
[ELF] Support --{,no-}allow-shlib-undefined
Summary:
In ld.bfd/gold, --no-allow-shlib-undefined is the default when linking
an executable. This patch implements a check to error on undefined
symbols in a shared object, if all of its DT_NEEDED entries are seen.
Our approach resembles the one used in gold, achieves a good balance to
be useful but not too smart (ld.bfd traces all DSOs and emulates the
behavior of a dynamic linker to catch more cases).
The error is issued based on the symbol table, different from undefined
reference errors issued for relocations. It is most effective when there
are DSOs that were not linked with -z defs (e.g. when static sanitizers
runtime is used).
gold has a comment that some system libraries on GNU/Linux may have
spurious undefined references and thus system libraries should be
excluded (https://sourceware.org/bugzilla/show_bug.cgi?id=6811). The
story may have changed now but we make --allow-shlib-undefined the
default for now. Its interaction with -shared can be discussed in the
future.
Reviewers: ruiu, grimar, pcc, espindola
Reviewed By: ruiu
Subscribers: joerg, emaste, arichardson, llvm-commits
Differential Revision: https://reviews.llvm.org/D57385
llvm-svn: 352826
2019-02-01 10:25:05 +08:00
|
|
|
if (Dyn.d_tag == DT_NEEDED) {
|
|
|
|
uint64_t Val = Dyn.getVal();
|
|
|
|
if (Val >= this->StringTable.size())
|
|
|
|
fatal(toString(this) + ": invalid DT_NEEDED entry");
|
|
|
|
DtNeeded.push_back(this->StringTable.data() + Val);
|
|
|
|
} else if (Dyn.d_tag == DT_SONAME) {
|
2017-02-25 03:52:52 +08:00
|
|
|
uint64_t Val = Dyn.getVal();
|
2015-10-12 23:49:02 +08:00
|
|
|
if (Val >= this->StringTable.size())
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(this) + ": invalid DT_SONAME entry");
|
2017-04-27 07:00:32 +08:00
|
|
|
SoName = this->StringTable.data() + Val;
|
2015-10-01 23:47:50 +08:00
|
|
|
}
|
|
|
|
}
|
2015-10-02 03:52:48 +08:00
|
|
|
}
|
2015-10-01 23:47:50 +08:00
|
|
|
|
2018-03-27 03:57:38 +08:00
|
|
|
// Parses ".gnu.version" section which is a parallel array for the symbol table.
|
|
|
|
// If a given file doesn't have ".gnu.version" section, returns VER_NDX_GLOBAL.
|
|
|
|
template <class ELFT> std::vector<uint32_t> SharedFile<ELFT>::parseVersyms() {
|
2019-04-06 04:16:26 +08:00
|
|
|
size_t Size = this->getELFSyms<ELFT>().size() - this->FirstGlobal;
|
2018-03-27 03:57:38 +08:00
|
|
|
if (!VersymSec)
|
|
|
|
return std::vector<uint32_t>(Size, VER_NDX_GLOBAL);
|
|
|
|
|
|
|
|
const char *Base = this->MB.getBuffer().data();
|
|
|
|
const Elf_Versym *Versym =
|
|
|
|
reinterpret_cast<const Elf_Versym *>(Base + VersymSec->sh_offset) +
|
2018-03-29 06:55:40 +08:00
|
|
|
this->FirstGlobal;
|
2018-03-27 03:57:38 +08:00
|
|
|
|
|
|
|
std::vector<uint32_t> Ret(Size);
|
|
|
|
for (size_t I = 0; I < Size; ++I)
|
|
|
|
Ret[I] = Versym[I].vs_index;
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2016-04-28 04:22:31 +08:00
|
|
|
// Parse the version definitions in the object file if present. Returns a vector
|
|
|
|
// whose nth element contains a pointer to the Elf_Verdef for version identifier
|
2018-03-24 08:25:24 +08:00
|
|
|
// n. Version identifiers that are not definitions map to nullptr.
|
2016-04-28 04:22:31 +08:00
|
|
|
template <class ELFT>
|
2018-03-27 03:57:38 +08:00
|
|
|
std::vector<const typename ELFT::Verdef *> SharedFile<ELFT>::parseVerdefs() {
|
|
|
|
if (!VerdefSec)
|
2018-03-24 08:25:24 +08:00
|
|
|
return {};
|
2016-04-28 04:22:31 +08:00
|
|
|
|
|
|
|
// We cannot determine the largest verdef identifier without inspecting
|
|
|
|
// every Elf_Verdef, but both bfd and gold assign verdef identifiers
|
|
|
|
// sequentially starting from 1, so we predict that the largest identifier
|
|
|
|
// will be VerdefCount.
|
|
|
|
unsigned VerdefCount = VerdefSec->sh_info;
|
2018-03-24 08:25:24 +08:00
|
|
|
std::vector<const Elf_Verdef *> Verdefs(VerdefCount + 1);
|
2016-04-28 04:22:31 +08:00
|
|
|
|
|
|
|
// Build the Verdefs array by following the chain of Elf_Verdef objects
|
|
|
|
// from the start of the .gnu.version_d section.
|
2018-03-27 03:57:38 +08:00
|
|
|
const char *Base = this->MB.getBuffer().data();
|
2016-11-04 04:44:50 +08:00
|
|
|
const char *Verdef = Base + VerdefSec->sh_offset;
|
2016-04-28 04:22:31 +08:00
|
|
|
for (unsigned I = 0; I != VerdefCount; ++I) {
|
|
|
|
auto *CurVerdef = reinterpret_cast<const Elf_Verdef *>(Verdef);
|
|
|
|
Verdef += CurVerdef->vd_next;
|
|
|
|
unsigned VerdefIndex = CurVerdef->vd_ndx;
|
2018-08-02 20:20:36 +08:00
|
|
|
Verdefs.resize(VerdefIndex + 1);
|
2016-04-28 04:22:31 +08:00
|
|
|
Verdefs[VerdefIndex] = CurVerdef;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Verdefs;
|
|
|
|
}
|
|
|
|
|
2018-03-27 03:57:38 +08:00
|
|
|
// We do not usually care about alignments of data in shared object
|
|
|
|
// files because the loader takes care of it. However, if we promote a
|
|
|
|
// DSO symbol to point to .bss due to copy relocation, we need to keep
|
|
|
|
// the original alignment requirements. We infer it in this function.
|
|
|
|
template <class ELFT>
|
|
|
|
uint32_t SharedFile<ELFT>::getAlignment(ArrayRef<Elf_Shdr> Sections,
|
|
|
|
const Elf_Sym &Sym) {
|
2018-06-07 05:43:34 +08:00
|
|
|
uint64_t Ret = UINT64_MAX;
|
2018-03-27 03:57:38 +08:00
|
|
|
if (Sym.st_value)
|
|
|
|
Ret = 1ULL << countTrailingZeros((uint64_t)Sym.st_value);
|
|
|
|
if (0 < Sym.st_shndx && Sym.st_shndx < Sections.size())
|
|
|
|
Ret = std::min<uint64_t>(Ret, Sections[Sym.st_shndx].sh_addralign);
|
2018-06-07 05:43:34 +08:00
|
|
|
return (Ret > UINT32_MAX) ? 0 : Ret;
|
2018-03-27 03:57:38 +08:00
|
|
|
}
|
|
|
|
|
[ELF] Support --{,no-}allow-shlib-undefined
Summary:
In ld.bfd/gold, --no-allow-shlib-undefined is the default when linking
an executable. This patch implements a check to error on undefined
symbols in a shared object, if all of its DT_NEEDED entries are seen.
Our approach resembles the one used in gold, achieves a good balance to
be useful but not too smart (ld.bfd traces all DSOs and emulates the
behavior of a dynamic linker to catch more cases).
The error is issued based on the symbol table, different from undefined
reference errors issued for relocations. It is most effective when there
are DSOs that were not linked with -z defs (e.g. when static sanitizers
runtime is used).
gold has a comment that some system libraries on GNU/Linux may have
spurious undefined references and thus system libraries should be
excluded (https://sourceware.org/bugzilla/show_bug.cgi?id=6811). The
story may have changed now but we make --allow-shlib-undefined the
default for now. Its interaction with -shared can be discussed in the
future.
Reviewers: ruiu, grimar, pcc, espindola
Reviewed By: ruiu
Subscribers: joerg, emaste, arichardson, llvm-commits
Differential Revision: https://reviews.llvm.org/D57385
llvm-svn: 352826
2019-02-01 10:25:05 +08:00
|
|
|
// Fully parse the shared object file. This must be called after parseDynamic().
|
2018-03-27 03:57:38 +08:00
|
|
|
//
|
|
|
|
// This function parses symbol versions. If a DSO has version information,
|
|
|
|
// the file has a ".gnu.version_d" section which contains symbol version
|
|
|
|
// definitions. Each symbol is associated to one version through a table in
|
|
|
|
// ".gnu.version" section. That table is a parallel array for the symbol
|
|
|
|
// table, and each table entry contains an index in ".gnu.version_d".
|
|
|
|
//
|
|
|
|
// The special index 0 is reserved for VERF_NDX_LOCAL and 1 is for
|
|
|
|
// VER_NDX_GLOBAL. There's no table entry for these special versions in
|
|
|
|
// ".gnu.version_d".
|
|
|
|
//
|
|
|
|
// The file format for symbol versioning is perhaps a bit more complicated
|
|
|
|
// than necessary, but you can easily understand the code if you wrap your
|
|
|
|
// head around the data structure described above.
|
2016-01-06 09:56:36 +08:00
|
|
|
template <class ELFT> void SharedFile<ELFT>::parseRest() {
|
2018-03-27 03:57:38 +08:00
|
|
|
Verdefs = parseVerdefs(); // parse .gnu.version_d
|
|
|
|
std::vector<uint32_t> Versyms = parseVersyms(); // parse .gnu.version
|
2019-04-06 04:16:26 +08:00
|
|
|
ArrayRef<Elf_Shdr> Sections = CHECK(this->getObj<ELFT>().sections(), this);
|
2017-10-29 04:15:56 +08:00
|
|
|
|
2018-04-07 04:53:06 +08:00
|
|
|
// System libraries can have a lot of symbols with versions. Using a
|
|
|
|
// fixed buffer for computing the versions name (foo@ver) can save a
|
|
|
|
// lot of allocations.
|
|
|
|
SmallString<0> VersionedNameBuffer;
|
|
|
|
|
2017-10-29 04:15:56 +08:00
|
|
|
// Add symbols to the symbol table.
|
2019-04-06 04:16:26 +08:00
|
|
|
ArrayRef<Elf_Sym> Syms = this->getGlobalELFSyms<ELFT>();
|
2018-03-27 03:57:38 +08:00
|
|
|
for (size_t I = 0; I < Syms.size(); ++I) {
|
|
|
|
const Elf_Sym &Sym = Syms[I];
|
2016-04-30 01:46:07 +08:00
|
|
|
|
2018-03-16 01:10:50 +08:00
|
|
|
// ELF spec requires that all local symbols precede weak or global
|
|
|
|
// symbols in each symbol table, and the index of first non-local symbol
|
|
|
|
// is stored to sh_info. If a local symbol appears after some non-local
|
|
|
|
// symbol, that's a violation of the spec.
|
2018-10-04 07:53:11 +08:00
|
|
|
StringRef Name = CHECK(Sym.getName(this->StringTable), this);
|
2017-12-15 08:01:33 +08:00
|
|
|
if (Sym.getBinding() == STB_LOCAL) {
|
2017-12-15 08:07:15 +08:00
|
|
|
warn("found local symbol '" + Name +
|
2017-12-15 08:01:33 +08:00
|
|
|
"' in global part of symbol table in file " + toString(this));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-10-04 07:53:11 +08:00
|
|
|
if (Sym.isUndefined()) {
|
|
|
|
Symbol *S = Symtab->addUndefined<ELFT>(Name, Sym.getBinding(),
|
|
|
|
Sym.st_other, Sym.getType(),
|
|
|
|
/*CanOmitFromDynSym=*/false, this);
|
|
|
|
S->ExportDynamic = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-03-24 06:48:17 +08:00
|
|
|
// MIPS BFD linker puts _gp_disp symbol into DSO files and incorrectly
|
|
|
|
// assigns VER_NDX_LOCAL to this section global symbol. Here is a
|
|
|
|
// workaround for this bug.
|
2018-03-27 03:57:38 +08:00
|
|
|
uint32_t Idx = Versyms[I] & ~VERSYM_HIDDEN;
|
|
|
|
if (Config->EMachine == EM_MIPS && Idx == VER_NDX_LOCAL &&
|
2018-03-24 06:48:17 +08:00
|
|
|
Name == "_gp_disp")
|
|
|
|
continue;
|
2018-02-07 18:02:49 +08:00
|
|
|
|
2018-03-27 03:57:38 +08:00
|
|
|
uint64_t Alignment = getAlignment(Sections, Sym);
|
|
|
|
if (!(Versyms[I] & VERSYM_HIDDEN))
|
|
|
|
Symtab->addShared(Name, *this, Sym, Alignment, Idx);
|
2017-01-07 06:30:35 +08:00
|
|
|
|
|
|
|
// Also add the symbol with the versioned name to handle undefined symbols
|
|
|
|
// with explicit versions.
|
2018-03-27 03:57:38 +08:00
|
|
|
if (Idx == VER_NDX_GLOBAL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (Idx >= Verdefs.size() || Idx == VER_NDX_LOCAL) {
|
|
|
|
error("corrupt input file: version definition index " + Twine(Idx) +
|
|
|
|
" for symbol " + Name + " is out of bounds\n>>> defined in " +
|
|
|
|
toString(this));
|
|
|
|
continue;
|
2017-01-07 06:30:35 +08:00
|
|
|
}
|
2018-03-27 03:57:38 +08:00
|
|
|
|
|
|
|
StringRef VerName =
|
|
|
|
this->StringTable.data() + Verdefs[Idx]->getAux()->vda_name;
|
2018-04-07 04:53:06 +08:00
|
|
|
VersionedNameBuffer.clear();
|
|
|
|
Name = (Name + "@" + VerName).toStringRef(VersionedNameBuffer);
|
|
|
|
Symtab->addShared(Saver.save(Name), *this, Sym, Alignment, Idx);
|
2015-09-08 23:50:05 +08:00
|
|
|
}
|
|
|
|
}
|
2015-09-04 04:03:54 +08:00
|
|
|
|
2017-04-14 10:55:06 +08:00
|
|
|
static ELFKind getBitcodeELFKind(const Triple &T) {
|
2016-08-04 04:25:29 +08:00
|
|
|
if (T.isLittleEndian())
|
|
|
|
return T.isArch64Bit() ? ELF64LEKind : ELF32LEKind;
|
|
|
|
return T.isArch64Bit() ? ELF64BEKind : ELF32BEKind;
|
2016-06-29 14:12:39 +08:00
|
|
|
}
|
|
|
|
|
2017-04-14 10:55:06 +08:00
|
|
|
static uint8_t getBitcodeMachineKind(StringRef Path, const Triple &T) {
|
2016-08-04 04:25:29 +08:00
|
|
|
switch (T.getArch()) {
|
2016-07-07 10:46:30 +08:00
|
|
|
case Triple::aarch64:
|
|
|
|
return EM_AARCH64;
|
2018-08-27 20:40:00 +08:00
|
|
|
case Triple::amdgcn:
|
|
|
|
case Triple::r600:
|
|
|
|
return EM_AMDGPU;
|
2016-07-07 10:46:30 +08:00
|
|
|
case Triple::arm:
|
2017-02-28 11:00:48 +08:00
|
|
|
case Triple::thumb:
|
2016-07-07 10:46:30 +08:00
|
|
|
return EM_ARM;
|
2017-06-15 10:27:50 +08:00
|
|
|
case Triple::avr:
|
|
|
|
return EM_AVR;
|
2016-07-07 10:46:30 +08:00
|
|
|
case Triple::mips:
|
|
|
|
case Triple::mipsel:
|
|
|
|
case Triple::mips64:
|
|
|
|
case Triple::mips64el:
|
|
|
|
return EM_MIPS;
|
2019-01-10 21:43:06 +08:00
|
|
|
case Triple::msp430:
|
|
|
|
return EM_MSP430;
|
2016-07-07 10:46:30 +08:00
|
|
|
case Triple::ppc:
|
|
|
|
return EM_PPC;
|
|
|
|
case Triple::ppc64:
|
2018-09-20 08:26:49 +08:00
|
|
|
case Triple::ppc64le:
|
2016-07-07 10:46:30 +08:00
|
|
|
return EM_PPC64;
|
|
|
|
case Triple::x86:
|
2016-08-04 04:25:29 +08:00
|
|
|
return T.isOSIAMCU() ? EM_IAMCU : EM_386;
|
2016-07-07 10:46:30 +08:00
|
|
|
case Triple::x86_64:
|
|
|
|
return EM_X86_64;
|
|
|
|
default:
|
2018-05-23 04:20:25 +08:00
|
|
|
error(Path + ": could not infer e_machine from bitcode target triple " +
|
2017-04-14 10:55:06 +08:00
|
|
|
T.str());
|
2018-05-23 04:20:25 +08:00
|
|
|
return EM_NONE;
|
2016-06-29 14:12:39 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-14 10:55:06 +08:00
|
|
|
BitcodeFile::BitcodeFile(MemoryBufferRef MB, StringRef ArchiveName,
|
|
|
|
uint64_t OffsetInArchive)
|
|
|
|
: InputFile(BitcodeKind, MB) {
|
|
|
|
this->ArchiveName = ArchiveName;
|
|
|
|
|
2018-05-17 05:04:08 +08:00
|
|
|
std::string Path = MB.getBufferIdentifier().str();
|
|
|
|
if (Config->ThinLTOIndexOnly)
|
2018-05-18 02:27:12 +08:00
|
|
|
Path = replaceThinLTOSuffix(MB.getBufferIdentifier());
|
|
|
|
|
|
|
|
// ThinLTO assumes that all MemoryBufferRefs given to it have a unique
|
|
|
|
// name. If two archives define two members with the same name, this
|
|
|
|
// causes a collision which result in only one of the objects being taken
|
|
|
|
// into consideration at LTO time (which very likely causes undefined
|
|
|
|
// symbols later in the link stage). So we append file offset to make
|
|
|
|
// filename unique.
|
2018-05-03 05:40:07 +08:00
|
|
|
MemoryBufferRef MBRef(
|
|
|
|
MB.getBuffer(),
|
2018-05-17 05:04:08 +08:00
|
|
|
Saver.save(ArchiveName + Path +
|
2018-05-03 05:40:07 +08:00
|
|
|
(ArchiveName.empty() ? "" : utostr(OffsetInArchive))));
|
2018-05-18 02:27:12 +08:00
|
|
|
|
2017-12-07 11:24:57 +08:00
|
|
|
Obj = CHECK(lto::InputFile::create(MBRef), this);
|
2017-04-14 10:55:06 +08:00
|
|
|
|
|
|
|
Triple T(Obj->getTargetTriple());
|
|
|
|
EKind = getBitcodeELFKind(T);
|
|
|
|
EMachine = getBitcodeMachineKind(MB.getBufferIdentifier(), T);
|
2016-06-29 14:12:39 +08:00
|
|
|
}
|
2016-02-13 04:54:57 +08:00
|
|
|
|
2016-09-29 08:40:08 +08:00
|
|
|
static uint8_t mapVisibility(GlobalValue::VisibilityTypes GvVisibility) {
|
|
|
|
switch (GvVisibility) {
|
2016-03-08 03:06:14 +08:00
|
|
|
case GlobalValue::DefaultVisibility:
|
|
|
|
return STV_DEFAULT;
|
2016-03-07 08:54:17 +08:00
|
|
|
case GlobalValue::HiddenVisibility:
|
|
|
|
return STV_HIDDEN;
|
|
|
|
case GlobalValue::ProtectedVisibility:
|
|
|
|
return STV_PROTECTED;
|
|
|
|
}
|
2016-03-12 16:31:34 +08:00
|
|
|
llvm_unreachable("unknown visibility");
|
2016-03-12 02:46:51 +08:00
|
|
|
}
|
|
|
|
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
template <class ELFT>
|
2017-11-04 05:21:47 +08:00
|
|
|
static Symbol *createBitcodeSymbol(const std::vector<bool> &KeptComdats,
|
|
|
|
const lto::InputFile::Symbol &ObjSym,
|
2017-12-21 00:16:40 +08:00
|
|
|
BitcodeFile &F) {
|
2018-05-23 04:20:25 +08:00
|
|
|
StringRef Name = Saver.save(ObjSym.getName());
|
2017-03-29 06:31:35 +08:00
|
|
|
uint32_t Binding = ObjSym.isWeak() ? STB_WEAK : STB_GLOBAL;
|
2016-04-23 02:26:33 +08:00
|
|
|
|
2016-09-29 08:40:08 +08:00
|
|
|
uint8_t Type = ObjSym.isTLS() ? STT_TLS : STT_NOTYPE;
|
|
|
|
uint8_t Visibility = mapVisibility(ObjSym.getVisibility());
|
|
|
|
bool CanOmitFromDynSym = ObjSym.canBeOmittedFromSymbolTable();
|
2016-03-12 02:46:51 +08:00
|
|
|
|
2017-03-31 12:47:07 +08:00
|
|
|
int C = ObjSym.getComdatIndex();
|
2016-10-25 20:02:31 +08:00
|
|
|
if (C != -1 && !KeptComdats[C])
|
2018-05-23 04:20:25 +08:00
|
|
|
return Symtab->addUndefined<ELFT>(Name, Binding, Visibility, Type,
|
2017-12-21 00:16:40 +08:00
|
|
|
CanOmitFromDynSym, &F);
|
2016-03-12 02:46:51 +08:00
|
|
|
|
2017-03-29 06:31:35 +08:00
|
|
|
if (ObjSym.isUndefined())
|
2018-05-23 04:20:25 +08:00
|
|
|
return Symtab->addUndefined<ELFT>(Name, Binding, Visibility, Type,
|
2017-12-21 00:16:40 +08:00
|
|
|
CanOmitFromDynSym, &F);
|
2016-09-29 08:40:08 +08:00
|
|
|
|
2017-03-29 06:31:35 +08:00
|
|
|
if (ObjSym.isCommon())
|
2018-05-23 04:20:25 +08:00
|
|
|
return Symtab->addCommon(Name, ObjSym.getCommonSize(),
|
2017-07-27 02:42:48 +08:00
|
|
|
ObjSym.getCommonAlignment(), Binding, Visibility,
|
2017-12-21 00:19:48 +08:00
|
|
|
STT_OBJECT, F);
|
2016-04-23 02:26:33 +08:00
|
|
|
|
2018-05-23 04:20:25 +08:00
|
|
|
return Symtab->addBitcode(Name, Binding, Visibility, Type, CanOmitFromDynSym,
|
|
|
|
F);
|
2016-03-12 00:11:47 +08:00
|
|
|
}
|
|
|
|
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
template <class ELFT>
|
2017-05-26 05:53:02 +08:00
|
|
|
void BitcodeFile::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
|
2016-10-25 20:02:31 +08:00
|
|
|
std::vector<bool> KeptComdats;
|
2017-03-31 12:47:07 +08:00
|
|
|
for (StringRef S : Obj->getComdatTable())
|
2017-05-26 05:53:02 +08:00
|
|
|
KeptComdats.push_back(ComdatGroups.insert(CachedHashStringRef(S)).second);
|
2016-10-25 20:02:31 +08:00
|
|
|
|
2016-09-29 08:40:08 +08:00
|
|
|
for (const lto::InputFile::Symbol &ObjSym : Obj->symbols())
|
2017-12-21 00:16:40 +08:00
|
|
|
Symbols.push_back(createBitcodeSymbol<ELFT>(KeptComdats, ObjSym, *this));
|
2016-02-13 04:54:57 +08:00
|
|
|
}
|
|
|
|
|
2019-03-12 08:24:34 +08:00
|
|
|
static ELFKind getELFKind(MemoryBufferRef MB, StringRef ArchiveName) {
|
2016-04-08 08:18:25 +08:00
|
|
|
unsigned char Size;
|
|
|
|
unsigned char Endian;
|
|
|
|
std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
|
2017-04-27 06:51:51 +08:00
|
|
|
|
2019-03-12 08:24:34 +08:00
|
|
|
auto Fatal = [&](StringRef Msg) {
|
|
|
|
StringRef Filename = MB.getBufferIdentifier();
|
|
|
|
if (ArchiveName.empty())
|
2019-03-12 09:24:39 +08:00
|
|
|
fatal(Filename + ": " + Msg);
|
2019-03-12 08:24:34 +08:00
|
|
|
else
|
2019-03-12 09:24:39 +08:00
|
|
|
fatal(ArchiveName + "(" + Filename + "): " + Msg);
|
2019-03-12 08:24:34 +08:00
|
|
|
};
|
|
|
|
|
2019-03-12 09:24:39 +08:00
|
|
|
if (!MB.getBuffer().startswith(ElfMagic))
|
|
|
|
Fatal("not an ELF file");
|
2016-04-08 08:18:25 +08:00
|
|
|
if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
|
2019-03-12 09:24:39 +08:00
|
|
|
Fatal("corrupted ELF file: invalid data encoding");
|
2017-04-27 06:51:51 +08:00
|
|
|
if (Size != ELFCLASS32 && Size != ELFCLASS64)
|
2019-03-12 09:24:39 +08:00
|
|
|
Fatal("corrupted ELF file: invalid file class");
|
2015-10-12 23:31:09 +08:00
|
|
|
|
2016-11-04 04:17:25 +08:00
|
|
|
size_t BufSize = MB.getBuffer().size();
|
|
|
|
if ((Size == ELFCLASS32 && BufSize < sizeof(Elf32_Ehdr)) ||
|
|
|
|
(Size == ELFCLASS64 && BufSize < sizeof(Elf64_Ehdr)))
|
2019-03-12 09:24:39 +08:00
|
|
|
Fatal("corrupted ELF file: file is too short");
|
2016-11-04 04:17:25 +08:00
|
|
|
|
2017-04-27 06:51:51 +08:00
|
|
|
if (Size == ELFCLASS32)
|
|
|
|
return (Endian == ELFDATA2LSB) ? ELF32LEKind : ELF32BEKind;
|
|
|
|
return (Endian == ELFDATA2LSB) ? ELF64LEKind : ELF64BEKind;
|
2015-10-12 23:31:09 +08:00
|
|
|
}
|
|
|
|
|
2017-12-24 01:21:39 +08:00
|
|
|
void BinaryFile::parse() {
|
2018-10-22 16:35:39 +08:00
|
|
|
ArrayRef<uint8_t> Data = arrayRefFromStringRef(MB.getBuffer());
|
2018-02-05 17:47:24 +08:00
|
|
|
auto *Section = make<InputSection>(this, SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
|
|
|
|
8, Data, ".data");
|
2016-10-28 01:45:40 +08:00
|
|
|
Sections.push_back(Section);
|
|
|
|
|
2017-04-27 12:01:36 +08:00
|
|
|
// For each input file foo that is embedded to a result as a binary
|
|
|
|
// blob, we define _binary_foo_{start,end,size} symbols, so that
|
|
|
|
// user programs can access blobs by name. Non-alphanumeric
|
|
|
|
// characters in a filename are replaced with underscore.
|
|
|
|
std::string S = "_binary_" + MB.getBufferIdentifier().str();
|
|
|
|
for (size_t I = 0; I < S.size(); ++I)
|
2017-10-04 16:50:34 +08:00
|
|
|
if (!isAlnum(S[I]))
|
2017-04-27 12:01:36 +08:00
|
|
|
S[I] = '_';
|
|
|
|
|
2018-10-12 04:43:01 +08:00
|
|
|
Symtab->addDefined(Saver.save(S + "_start"), STV_DEFAULT, STT_OBJECT, 0, 0,
|
2017-12-24 01:21:39 +08:00
|
|
|
STB_GLOBAL, Section, nullptr);
|
2018-10-12 04:43:01 +08:00
|
|
|
Symtab->addDefined(Saver.save(S + "_end"), STV_DEFAULT, STT_OBJECT,
|
2017-12-24 01:21:39 +08:00
|
|
|
Data.size(), 0, STB_GLOBAL, Section, nullptr);
|
2018-10-12 04:43:01 +08:00
|
|
|
Symtab->addDefined(Saver.save(S + "_size"), STV_DEFAULT, STT_OBJECT,
|
2017-12-24 01:21:39 +08:00
|
|
|
Data.size(), 0, STB_GLOBAL, nullptr, nullptr);
|
2016-09-10 06:08:04 +08:00
|
|
|
}
|
|
|
|
|
2016-10-29 04:57:25 +08:00
|
|
|
InputFile *elf::createObjectFile(MemoryBufferRef MB, StringRef ArchiveName,
|
2016-10-13 03:35:54 +08:00
|
|
|
uint64_t OffsetInArchive) {
|
2017-04-27 06:51:51 +08:00
|
|
|
if (isBitcode(MB))
|
|
|
|
return make<BitcodeFile>(MB, ArchiveName, OffsetInArchive);
|
|
|
|
|
2019-03-12 08:24:34 +08:00
|
|
|
switch (getELFKind(MB, ArchiveName)) {
|
2017-04-27 06:51:51 +08:00
|
|
|
case ELF32LEKind:
|
2017-07-27 06:13:32 +08:00
|
|
|
return make<ObjFile<ELF32LE>>(MB, ArchiveName);
|
2017-04-27 06:51:51 +08:00
|
|
|
case ELF32BEKind:
|
2017-07-27 06:13:32 +08:00
|
|
|
return make<ObjFile<ELF32BE>>(MB, ArchiveName);
|
2017-04-27 06:51:51 +08:00
|
|
|
case ELF64LEKind:
|
2017-07-27 06:13:32 +08:00
|
|
|
return make<ObjFile<ELF64LE>>(MB, ArchiveName);
|
2017-04-27 06:51:51 +08:00
|
|
|
case ELF64BEKind:
|
2017-07-27 06:13:32 +08:00
|
|
|
return make<ObjFile<ELF64BE>>(MB, ArchiveName);
|
2017-04-27 06:51:51 +08:00
|
|
|
default:
|
|
|
|
llvm_unreachable("getELFKind");
|
|
|
|
}
|
2016-01-06 08:09:43 +08:00
|
|
|
}
|
|
|
|
|
2017-04-25 05:44:20 +08:00
|
|
|
InputFile *elf::createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName) {
|
2019-03-12 08:24:34 +08:00
|
|
|
switch (getELFKind(MB, "")) {
|
2017-04-27 06:51:51 +08:00
|
|
|
case ELF32LEKind:
|
|
|
|
return make<SharedFile<ELF32LE>>(MB, DefaultSoName);
|
|
|
|
case ELF32BEKind:
|
|
|
|
return make<SharedFile<ELF32BE>>(MB, DefaultSoName);
|
|
|
|
case ELF64LEKind:
|
|
|
|
return make<SharedFile<ELF64LE>>(MB, DefaultSoName);
|
|
|
|
case ELF64BEKind:
|
|
|
|
return make<SharedFile<ELF64BE>>(MB, DefaultSoName);
|
|
|
|
default:
|
|
|
|
llvm_unreachable("getELFKind");
|
|
|
|
}
|
2016-01-06 08:09:43 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
MemoryBufferRef LazyObjFile::getBuffer() {
|
2018-05-03 05:40:07 +08:00
|
|
|
if (AddedToLink)
|
2016-06-15 05:56:36 +08:00
|
|
|
return MemoryBufferRef();
|
2018-05-03 05:40:07 +08:00
|
|
|
AddedToLink = true;
|
2016-06-15 05:56:36 +08:00
|
|
|
return MB;
|
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
InputFile *LazyObjFile::fetch() {
|
2017-05-04 22:54:48 +08:00
|
|
|
MemoryBufferRef MBRef = getBuffer();
|
|
|
|
if (MBRef.getBuffer().empty())
|
|
|
|
return nullptr;
|
Add --warn-backrefs to maintain compatibility with other linkers
I'm proposing a new command line flag, --warn-backrefs in this patch.
The flag and the feature proposed below don't exist in GNU linkers
nor the current lld.
--warn-backrefs is an option to detect reverse or cyclic dependencies
between static archives, and it can be used to keep your program
compatible with GNU linkers after you switch to lld. I'll explain the
feature and why you may find it useful below.
lld's symbol resolution semantics is more relaxed than traditional
Unix linkers. Therefore,
ld.lld foo.a bar.o
succeeds even if bar.o contains an undefined symbol that have to be
resolved by some object file in foo.a. Traditional Unix linkers
don't allow this kind of backward reference, as they visit each
file only once from left to right in the command line while
resolving all undefined symbol at the moment of visiting.
In the above case, since there's no undefined symbol when a linker
visits foo.a, no files are pulled out from foo.a, and because the
linker forgets about foo.a after visiting, it can't resolve
undefined symbols that could have been resolved otherwise.
That lld accepts more relaxed form means (besides it makes more
sense) that you can accidentally write a command line or a build
file that works only with lld, even if you have a plan to
distribute it to wider users who may be using GNU linkers. With
--check-library-dependency, you can detect a library order that
doesn't work with other Unix linkers.
The option is also useful to detect cyclic dependencies between
static archives. Again, lld accepts
ld.lld foo.a bar.a
even if foo.a and bar.a depend on each other. With --warn-backrefs
it is handled as an error.
Here is how the option works. We assign a group ID to each file. A
file with a smaller group ID can pull out object files from an
archive file with an equal or greater group ID. Otherwise, it is a
reverse dependency and an error.
A file outside --{start,end}-group gets a fresh ID when
instantiated. All files within the same --{start,end}-group get the
same group ID. E.g.
ld.lld A B --start-group C D --end-group E
A and B form group 0, C, D and their member object files form group
1, and E forms group 2. I think that you can see how this group
assignment rule simulates the traditional linker's semantics.
Differential Revision: https://reviews.llvm.org/D45195
llvm-svn: 329636
2018-04-10 07:05:48 +08:00
|
|
|
|
|
|
|
InputFile *File = createObjectFile(MBRef, ArchiveName, OffsetInArchive);
|
|
|
|
File->GroupId = GroupId;
|
|
|
|
return File;
|
2017-05-04 22:54:48 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template <class ELFT> void LazyObjFile::parse() {
|
2018-03-08 09:05:58 +08:00
|
|
|
// A lazy object file wraps either a bitcode file or an ELF file.
|
|
|
|
if (isBitcode(this->MB)) {
|
|
|
|
std::unique_ptr<lto::InputFile> Obj =
|
|
|
|
CHECK(lto::InputFile::create(this->MB), this);
|
|
|
|
for (const lto::InputFile::Symbol &Sym : Obj->symbols())
|
|
|
|
if (!Sym.isUndefined())
|
|
|
|
Symtab->addLazyObject<ELFT>(Saver.save(Sym.getName()), *this);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-12 08:24:34 +08:00
|
|
|
if (getELFKind(this->MB, ArchiveName) != Config->EKind) {
|
2018-08-21 16:13:06 +08:00
|
|
|
error("incompatible file: " + this->MB.getBufferIdentifier());
|
2018-03-08 09:05:58 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-04-08 03:24:51 +08:00
|
|
|
|
2018-03-08 09:05:58 +08:00
|
|
|
ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(MB.getBuffer()));
|
|
|
|
ArrayRef<typename ELFT::Shdr> Sections = CHECK(Obj.sections(), this);
|
2016-04-08 03:24:51 +08:00
|
|
|
|
2018-03-08 09:05:58 +08:00
|
|
|
for (const typename ELFT::Shdr &Sec : Sections) {
|
2016-04-08 03:24:51 +08:00
|
|
|
if (Sec.sh_type != SHT_SYMTAB)
|
|
|
|
continue;
|
2017-03-31 05:13:00 +08:00
|
|
|
|
2018-03-08 09:05:58 +08:00
|
|
|
typename ELFT::SymRange Syms = CHECK(Obj.symbols(&Sec), this);
|
2018-03-29 06:55:40 +08:00
|
|
|
uint32_t FirstGlobal = Sec.sh_info;
|
2017-03-31 05:13:00 +08:00
|
|
|
StringRef StringTable =
|
2017-12-07 11:24:57 +08:00
|
|
|
CHECK(Obj.getStringTableForSymtab(Sec, Sections), this);
|
2017-03-31 05:13:00 +08:00
|
|
|
|
2018-03-29 06:55:40 +08:00
|
|
|
for (const typename ELFT::Sym &Sym : Syms.slice(FirstGlobal))
|
2016-04-09 04:49:31 +08:00
|
|
|
if (Sym.st_shndx != SHN_UNDEF)
|
2018-03-08 09:05:58 +08:00
|
|
|
Symtab->addLazyObject<ELFT>(CHECK(Sym.getName(StringTable), this),
|
|
|
|
*this);
|
2018-03-08 09:22:30 +08:00
|
|
|
return;
|
2017-04-27 06:51:51 +08:00
|
|
|
}
|
2016-04-08 03:24:51 +08:00
|
|
|
}
|
|
|
|
|
2018-05-18 02:27:12 +08:00
|
|
|
std::string elf::replaceThinLTOSuffix(StringRef Path) {
|
|
|
|
StringRef Suffix = Config->ThinLTOObjectSuffixReplace.first;
|
|
|
|
StringRef Repl = Config->ThinLTOObjectSuffixReplace.second;
|
|
|
|
|
[ELF] -thinlto-object-suffix-replace=: don't error if the path does not end with old suffix
Summary:
For -thinlto-object-suffix-replace=old\;new, in
tools/gold/gold-plugin.cpp, the thinlto object filename is Path minus
optional old suffix.
static std::string getThinLTOObjectFileName(StringRef Path, StringRef OldSuffix,
StringRef NewSuffix) {
if (OldSuffix.empty() && NewSuffix.empty())
return Path;
StringRef NewPath = Path;
NewPath.consume_back(OldSuffix);
std::string NewNewPath = NewPath;
NewNewPath += NewSuffix;
return NewNewPath;
}
Currently lld will error that the path does not end with old suffix.
This patch makes lld accept such paths but only add new suffix if Path
ends with old suffix. This fixes a link error where bitcode members in
an archive are regular LTO objects without old suffix.
Acording to tejohnson, this will "enable supporting mix and match of
minimized ThinLTO bitcode files with normal ThinLTO bitcode files in a
single link (where we want to apply the suffix replacement to the
minimized files, and just ignore it for the normal ThinLTO files)."
Reviewers: ruiu, pcc, tejohnson, espindola
Reviewed By: tejohnson
Subscribers: emaste, inglorion, arichardson, eraman, steven_wu, dexonsmith, llvm-commits
Differential Revision: https://reviews.llvm.org/D51055
llvm-svn: 340364
2018-08-22 07:28:12 +08:00
|
|
|
if (Path.consume_back(Suffix))
|
|
|
|
return (Path + Repl).str();
|
|
|
|
return Path;
|
2018-05-18 02:27:12 +08:00
|
|
|
}
|
|
|
|
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
template void ArchiveFile::parse<ELF32LE>();
|
|
|
|
template void ArchiveFile::parse<ELF32BE>();
|
|
|
|
template void ArchiveFile::parse<ELF64LE>();
|
|
|
|
template void ArchiveFile::parse<ELF64BE>();
|
|
|
|
|
2017-05-26 05:53:02 +08:00
|
|
|
template void BitcodeFile::parse<ELF32LE>(DenseSet<CachedHashStringRef> &);
|
|
|
|
template void BitcodeFile::parse<ELF32BE>(DenseSet<CachedHashStringRef> &);
|
|
|
|
template void BitcodeFile::parse<ELF64LE>(DenseSet<CachedHashStringRef> &);
|
|
|
|
template void BitcodeFile::parse<ELF64BE>(DenseSet<CachedHashStringRef> &);
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template void LazyObjFile::parse<ELF32LE>();
|
|
|
|
template void LazyObjFile::parse<ELF32BE>();
|
|
|
|
template void LazyObjFile::parse<ELF64LE>();
|
|
|
|
template void LazyObjFile::parse<ELF64BE>();
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template class elf::ObjFile<ELF32LE>;
|
|
|
|
template class elf::ObjFile<ELF32BE>;
|
|
|
|
template class elf::ObjFile<ELF64LE>;
|
|
|
|
template class elf::ObjFile<ELF64BE>;
|
2015-11-20 10:19:36 +08:00
|
|
|
|
2016-02-28 08:25:54 +08:00
|
|
|
template class elf::SharedFile<ELF32LE>;
|
|
|
|
template class elf::SharedFile<ELF32BE>;
|
|
|
|
template class elf::SharedFile<ELF64LE>;
|
|
|
|
template class elf::SharedFile<ELF64BE>;
|