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"
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
#include "Driver.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;
|
2019-04-09 01:35:55 +08:00
|
|
|
std::vector<SharedFile *> elf::SharedFiles;
|
2017-09-19 17:20:54 +08:00
|
|
|
|
2018-12-19 07:50:37 +08:00
|
|
|
std::unique_ptr<TarWriter> elf::Tar;
|
2017-01-09 09:42:02 +08:00
|
|
|
|
2019-05-27 15:26:13 +08:00
|
|
|
static ELFKind getELFKind(MemoryBufferRef MB, StringRef ArchiveName) {
|
|
|
|
unsigned char Size;
|
|
|
|
unsigned char Endian;
|
|
|
|
std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
|
|
|
|
|
|
|
|
auto Fatal = [&](StringRef Msg) {
|
|
|
|
StringRef Filename = MB.getBufferIdentifier();
|
|
|
|
if (ArchiveName.empty())
|
|
|
|
fatal(Filename + ": " + Msg);
|
|
|
|
else
|
|
|
|
fatal(ArchiveName + "(" + Filename + "): " + Msg);
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!MB.getBuffer().startswith(ElfMagic))
|
|
|
|
Fatal("not an ELF file");
|
|
|
|
if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
|
|
|
|
Fatal("corrupted ELF file: invalid data encoding");
|
|
|
|
if (Size != ELFCLASS32 && Size != ELFCLASS64)
|
|
|
|
Fatal("corrupted ELF file: invalid file class");
|
|
|
|
|
|
|
|
size_t BufSize = MB.getBuffer().size();
|
|
|
|
if ((Size == ELFCLASS32 && BufSize < sizeof(Elf32_Ehdr)) ||
|
|
|
|
(Size == ELFCLASS64 && BufSize < sizeof(Elf64_Ehdr)))
|
|
|
|
Fatal("corrupted ELF file: file is too short");
|
|
|
|
|
|
|
|
if (Size == ELFCLASS32)
|
|
|
|
return (Endian == ELFDATA2LSB) ? ELF32LEKind : ELF32BEKind;
|
|
|
|
return (Endian == ELFDATA2LSB) ? ELF64LEKind : ELF64BEKind;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-05-14 20:03:13 +08:00
|
|
|
// All input object files must be for the same architecture
|
|
|
|
// (e.g. it does not make sense to link x86 object files with
|
|
|
|
// MIPS object files.) This function checks for that error.
|
|
|
|
static bool isCompatible(InputFile *File) {
|
|
|
|
if (!File->isElf() && !isa<BitcodeFile>(File))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (File->EKind == Config->EKind && File->EMachine == Config->EMachine) {
|
|
|
|
if (Config->EMachine != EM_MIPS)
|
|
|
|
return true;
|
|
|
|
if (isMipsN32Abi(File) == Config->MipsN32Abi)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Config->Emulation.empty()) {
|
|
|
|
error(toString(File) + " is incompatible with " + Config->Emulation);
|
|
|
|
} else {
|
|
|
|
InputFile *Existing;
|
|
|
|
if (!ObjectFiles.empty())
|
|
|
|
Existing = ObjectFiles[0];
|
|
|
|
else if (!SharedFiles.empty())
|
|
|
|
Existing = SharedFiles[0];
|
|
|
|
else
|
|
|
|
Existing = BitcodeFiles[0];
|
|
|
|
|
|
|
|
error(toString(File) + " is incompatible with " + toString(Existing));
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-05-16 11:45:13 +08:00
|
|
|
template <class ELFT> static void doParseFile(InputFile *File) {
|
2019-05-14 20:03:13 +08:00
|
|
|
if (!isCompatible(File))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Binary file
|
|
|
|
if (auto *F = dyn_cast<BinaryFile>(File)) {
|
|
|
|
BinaryFiles.push_back(F);
|
|
|
|
F->parse();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// .a file
|
|
|
|
if (auto *F = dyn_cast<ArchiveFile>(File)) {
|
2019-05-16 11:45:13 +08:00
|
|
|
F->parse();
|
2019-05-14 20:03:13 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Lazy object file
|
|
|
|
if (auto *F = dyn_cast<LazyObjFile>(File)) {
|
|
|
|
LazyObjFiles.push_back(F);
|
|
|
|
F->parse<ELFT>();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Config->Trace)
|
|
|
|
message(toString(File));
|
|
|
|
|
|
|
|
// .so file
|
|
|
|
if (auto *F = dyn_cast<SharedFile>(File)) {
|
|
|
|
F->parse<ELFT>();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// LLVM bitcode file
|
|
|
|
if (auto *F = dyn_cast<BitcodeFile>(File)) {
|
|
|
|
BitcodeFiles.push_back(F);
|
2019-05-22 17:06:42 +08:00
|
|
|
F->parse<ELFT>(Symtab->ComdatGroups);
|
2019-05-14 20:03:13 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Regular object file
|
|
|
|
ObjectFiles.push_back(File);
|
2019-05-22 17:06:42 +08:00
|
|
|
cast<ObjFile<ELFT>>(File)->parse(Symtab->ComdatGroups);
|
2019-05-14 20:03:13 +08:00
|
|
|
}
|
|
|
|
|
2019-05-16 11:45:13 +08:00
|
|
|
// Add symbols in File to the symbol table.
|
|
|
|
void elf::parseFile(InputFile *File) {
|
|
|
|
switch (Config->EKind) {
|
|
|
|
case ELF32LEKind:
|
|
|
|
doParseFile<ELF32LE>(File);
|
|
|
|
return;
|
|
|
|
case ELF32BEKind:
|
|
|
|
doParseFile<ELF32BE>(File);
|
|
|
|
return;
|
|
|
|
case ELF64LEKind:
|
|
|
|
doParseFile<ELF64LE>(File);
|
|
|
|
return;
|
|
|
|
case ELF64BEKind:
|
|
|
|
doParseFile<ELF64BE>(File);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("unknown ELFT");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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(
|
2019-04-10 14:32:05 +08:00
|
|
|
this->getObj().getSectionIndex(&Sym, getELFSyms<ELFT>(), ShndxTable),
|
2019-04-06 04:16:26 +08:00
|
|
|
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>
|
2019-05-22 17:06:42 +08:00
|
|
|
void ObjFile<ELFT>::parse(
|
|
|
|
DenseMap<CachedHashStringRef, const InputFile *> &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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
// An ELF object file may contain a `.deplibs` section. If it exists, the
|
|
|
|
// section contains a list of library specifiers such as `m` for libm. This
|
|
|
|
// function resolves a given name by finding the first matching library checking
|
|
|
|
// the various ways that a library can be specified to LLD. This ELF extension
|
|
|
|
// is a form of autolinking and is called `dependent libraries`. It is currently
|
|
|
|
// unique to LLVM and lld.
|
|
|
|
static void addDependentLibrary(StringRef Specifier, const InputFile *F) {
|
|
|
|
if (!Config->DependentLibraries)
|
|
|
|
return;
|
|
|
|
if (fs::exists(Specifier))
|
|
|
|
Driver->addFile(Specifier, /*WithLOption=*/false);
|
|
|
|
else if (Optional<std::string> S = findFromSearchPaths(Specifier))
|
|
|
|
Driver->addFile(*S, /*WithLOption=*/true);
|
|
|
|
else if (Optional<std::string> S = searchLibraryBaseName(Specifier))
|
|
|
|
Driver->addFile(*S, /*WithLOption=*/true);
|
|
|
|
else
|
|
|
|
error(toString(F) +
|
|
|
|
": unable to find library from dependent library specifier: " +
|
|
|
|
Specifier);
|
|
|
|
}
|
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
void ObjFile<ELFT>::initializeSections(
|
2019-05-22 17:06:42 +08:00
|
|
|
DenseMap<CachedHashStringRef, const InputFile *> &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");
|
|
|
|
|
2019-05-22 17:06:42 +08:00
|
|
|
bool IsNew =
|
|
|
|
ComdatGroups.try_emplace(CachedHashStringRef(Signature), this).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-10 14:32:05 +08:00
|
|
|
ShndxTable = 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
|
|
|
}
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
case SHT_LLVM_DEPENDENT_LIBRARIES: {
|
|
|
|
if (Config->Relocatable)
|
|
|
|
break;
|
|
|
|
ArrayRef<char> Data =
|
|
|
|
CHECK(this->getObj().template getSectionContentsAsArray<char>(&Sec), this);
|
|
|
|
if (!Data.empty() && Data.back() != '\0') {
|
|
|
|
error(toString(this) +
|
|
|
|
": corrupted dependent libraries section (unterminated string): " +
|
|
|
|
Name);
|
|
|
|
return &InputSection::Discarded;
|
|
|
|
}
|
|
|
|
for (const char *D = Data.begin(), *E = Data.end(); D < E;) {
|
|
|
|
StringRef S(D);
|
|
|
|
addDependentLibrary(S, this);
|
|
|
|
D += S.size() + 1;
|
|
|
|
}
|
|
|
|
return &InputSection::Discarded;
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Initialize this->Symbols. this->Symbols is a parallel array as
|
|
|
|
// its corresponding ELF symbol table.
|
2017-07-27 06:13:32 +08:00
|
|
|
template <class ELFT> void ObjFile<ELFT>::initializeSymbols() {
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
ArrayRef<Elf_Sym> ESyms = this->getELFSyms<ELFT>();
|
|
|
|
this->Symbols.resize(ESyms.size());
|
|
|
|
|
|
|
|
// Our symbol table may have already been partially initialized
|
|
|
|
// because of LazyObjFile.
|
|
|
|
for (size_t I = 0, End = ESyms.size(); I != End; ++I)
|
|
|
|
if (!this->Symbols[I] && ESyms[I].getBinding() != STB_LOCAL)
|
|
|
|
this->Symbols[I] =
|
|
|
|
Symtab->insert(CHECK(ESyms[I].getName(this->StringTable), this));
|
|
|
|
|
|
|
|
// Fill this->Symbols. A symbol is either local or global.
|
|
|
|
for (size_t I = 0, End = ESyms.size(); I != End; ++I) {
|
|
|
|
const Elf_Sym &ESym = ESyms[I];
|
|
|
|
|
|
|
|
// Read symbol attributes.
|
|
|
|
uint32_t SecIdx = getSectionIndex(ESym);
|
|
|
|
if (SecIdx >= this->Sections.size())
|
|
|
|
fatal(toString(this) + ": invalid section index: " + Twine(SecIdx));
|
|
|
|
|
|
|
|
InputSectionBase *Sec = this->Sections[SecIdx];
|
|
|
|
uint8_t Binding = ESym.getBinding();
|
|
|
|
uint8_t StOther = ESym.st_other;
|
|
|
|
uint8_t Type = ESym.getType();
|
|
|
|
uint64_t Value = ESym.st_value;
|
|
|
|
uint64_t Size = ESym.st_size;
|
|
|
|
StringRefZ Name = this->StringTable.data() + ESym.st_name;
|
|
|
|
|
|
|
|
// Handle local symbols. Local symbols are not added to the symbol
|
|
|
|
// table because they are not visible from other object files. We
|
|
|
|
// allocate symbol instances and add their pointers to Symbols.
|
|
|
|
if (Binding == STB_LOCAL) {
|
|
|
|
if (ESym.getType() == STT_FILE)
|
|
|
|
SourceFile = CHECK(ESym.getName(this->StringTable), this);
|
|
|
|
|
|
|
|
if (this->StringTable.size() <= ESym.st_name)
|
|
|
|
fatal(toString(this) + ": invalid symbol name offset");
|
|
|
|
|
|
|
|
if (ESym.st_shndx == SHN_UNDEF)
|
|
|
|
this->Symbols[I] = make<Undefined>(this, Name, Binding, StOther, Type);
|
|
|
|
else
|
|
|
|
this->Symbols[I] =
|
|
|
|
make<Defined>(this, Name, Binding, StOther, Type, Value, Size, Sec);
|
|
|
|
continue;
|
|
|
|
}
|
2016-03-11 20:06:30 +08:00
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Handle global undefined symbols.
|
|
|
|
if (ESym.st_shndx == SHN_UNDEF) {
|
2019-05-23 17:58:08 +08:00
|
|
|
this->Symbols[I]->resolve(Undefined{this, Name, Binding, StOther, Type});
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
continue;
|
|
|
|
}
|
2015-08-25 05:43:25 +08:00
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Handle global common symbols.
|
|
|
|
if (ESym.st_shndx == SHN_COMMON) {
|
|
|
|
if (Value == 0 || Value >= UINT32_MAX)
|
|
|
|
fatal(toString(this) + ": common symbol '" + StringRef(Name.Data) +
|
|
|
|
"' has invalid alignment: " + Twine(Value));
|
2019-05-23 17:58:08 +08:00
|
|
|
this->Symbols[I]->resolve(
|
|
|
|
CommonSymbol{this, Name, Binding, StOther, Type, Value, Size});
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
continue;
|
|
|
|
}
|
2019-05-22 12:56:25 +08:00
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// If a defined symbol is in a discarded section, handle it as if it
|
|
|
|
// were an undefined symbol. Such symbol doesn't comply with the
|
|
|
|
// standard, but in practice, a .eh_frame often directly refer
|
|
|
|
// COMDAT member sections, and if a comdat group is discarded, some
|
|
|
|
// defined symbol in a .eh_frame becomes dangling symbols.
|
|
|
|
if (Sec == &InputSection::Discarded) {
|
2019-05-23 17:58:08 +08:00
|
|
|
this->Symbols[I]->resolve(
|
|
|
|
Undefined{this, Name, Binding, StOther, Type, SecIdx});
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
continue;
|
|
|
|
}
|
2019-05-22 17:06:42 +08:00
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Handle global defined symbols.
|
|
|
|
if (Binding == STB_GLOBAL || Binding == STB_WEAK ||
|
|
|
|
Binding == STB_GNU_UNIQUE) {
|
2019-05-23 17:58:08 +08:00
|
|
|
this->Symbols[I]->resolve(
|
|
|
|
Defined{this, Name, Binding, StOther, Type, Value, Size, Sec});
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
continue;
|
|
|
|
}
|
2015-08-25 05:43:25 +08:00
|
|
|
|
2019-05-16 10:14:00 +08:00
|
|
|
fatal(toString(this) + ": unexpected binding: " + Twine((int)Binding));
|
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
|
|
|
|
2019-05-16 11:45:13 +08:00
|
|
|
void ArchiveFile::parse() {
|
2017-05-04 05:03:08 +08:00
|
|
|
for (const Archive::Symbol &Sym : File->symbols())
|
2019-05-17 09:55:20 +08:00
|
|
|
Symtab->addSymbol(LazyArchive{*this, Sym});
|
2015-09-05 06:28:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a buffer pointing to a member file containing a given symbol.
|
2019-05-23 18:15:12 +08:00
|
|
|
void 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)
|
2019-05-23 18:15:12 +08:00
|
|
|
return;
|
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;
|
2019-05-23 18:15:12 +08:00
|
|
|
parseFile(File);
|
2015-09-05 06:28:10 +08:00
|
|
|
}
|
|
|
|
|
2019-04-09 01:48:05 +08:00
|
|
|
unsigned SharedFile::VernauxNum;
|
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
SharedFile::SharedFile(MemoryBufferRef M, StringRef DefaultSoName)
|
2019-04-06 04:16:26 +08:00
|
|
|
: ELFFileBase(SharedKind, M), SoName(DefaultSoName),
|
2019-05-27 15:26:13 +08:00
|
|
|
IsNeeded(!Config->AsNeeded) {
|
|
|
|
switch (getELFKind(MB, "")) {
|
|
|
|
case ELF32LEKind:
|
|
|
|
parseHeader<ELF32LE>();
|
|
|
|
break;
|
|
|
|
case ELF32BEKind:
|
|
|
|
parseHeader<ELF32BE>();
|
|
|
|
break;
|
|
|
|
case ELF64LEKind:
|
|
|
|
parseHeader<ELF64LE>();
|
|
|
|
break;
|
|
|
|
case ELF64BEKind:
|
|
|
|
parseHeader<ELF64BE>();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("getELFKind");
|
|
|
|
}
|
|
|
|
}
|
2019-04-09 01:35:55 +08:00
|
|
|
|
|
|
|
// Parse the version definitions in the object file if present, and return a
|
|
|
|
// vector whose nth element contains a pointer to the Elf_Verdef for version
|
|
|
|
// identifier n. Version identifiers that are not definitions map to nullptr.
|
|
|
|
template <typename ELFT>
|
|
|
|
static std::vector<const void *> parseVerdefs(const uint8_t *Base,
|
|
|
|
const typename ELFT::Shdr *Sec) {
|
|
|
|
if (!Sec)
|
|
|
|
return {};
|
|
|
|
|
|
|
|
// 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 = Sec->sh_info;
|
|
|
|
std::vector<const void *> Verdefs(VerdefCount + 1);
|
|
|
|
|
|
|
|
// Build the Verdefs array by following the chain of Elf_Verdef objects
|
|
|
|
// from the start of the .gnu.version_d section.
|
|
|
|
const uint8_t *Verdef = Base + Sec->sh_offset;
|
|
|
|
for (unsigned I = 0; I != VerdefCount; ++I) {
|
|
|
|
auto *CurVerdef = reinterpret_cast<const typename ELFT::Verdef *>(Verdef);
|
|
|
|
Verdef += CurVerdef->vd_next;
|
|
|
|
unsigned VerdefIndex = CurVerdef->vd_ndx;
|
|
|
|
Verdefs.resize(VerdefIndex + 1);
|
|
|
|
Verdefs[VerdefIndex] = CurVerdef;
|
|
|
|
}
|
|
|
|
return Verdefs;
|
2019-04-06 04:16:26 +08:00
|
|
|
}
|
2015-09-08 23:50:05 +08:00
|
|
|
|
2019-04-09 01:35:55 +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 <typename ELFT>
|
|
|
|
static uint64_t getAlignment(ArrayRef<typename ELFT::Shdr> Sections,
|
|
|
|
const typename ELFT::Sym &Sym) {
|
|
|
|
uint64_t Ret = UINT64_MAX;
|
|
|
|
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);
|
|
|
|
return (Ret > UINT32_MAX) ? 0 : Ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fully parse the shared object file.
|
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
template <class ELFT> void SharedFile::parse() {
|
|
|
|
using Elf_Dyn = typename ELFT::Dyn;
|
|
|
|
using Elf_Shdr = typename ELFT::Shdr;
|
|
|
|
using Elf_Sym = typename ELFT::Sym;
|
|
|
|
using Elf_Verdef = typename ELFT::Verdef;
|
|
|
|
using Elf_Versym = typename ELFT::Versym;
|
|
|
|
|
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
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
const Elf_Shdr *VersymSec = nullptr;
|
|
|
|
const Elf_Shdr *VerdefSec = nullptr;
|
|
|
|
|
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:
|
2019-04-09 01:35:55 +08:00
|
|
|
VersymSec = &Sec;
|
2016-04-28 04:22:31 +08:00
|
|
|
break;
|
|
|
|
case SHT_GNU_verdef:
|
2019-04-09 01:35:55 +08:00
|
|
|
VerdefSec = &Sec;
|
2016-04-28 04:22:31 +08:00
|
|
|
break;
|
2015-11-03 22:13:40 +08:00
|
|
|
}
|
2015-09-08 23:50:05 +08:00
|
|
|
}
|
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
if (VersymSec && this->getELFSyms<ELFT>().empty()) {
|
2016-11-02 18:16:25 +08:00
|
|
|
error("SHT_GNU_versym should be associated with symbol table");
|
2019-04-09 01:35:55 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-11-02 18:16:25 +08:00
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
// DSOs are uniquified not by filename but by soname.
|
|
|
|
DenseMap<StringRef, SharedFile *>::iterator It;
|
|
|
|
bool WasInserted;
|
|
|
|
std::tie(It, WasInserted) = Symtab->SoNames.try_emplace(SoName, this);
|
|
|
|
|
|
|
|
// If a DSO appears more than once on the command line with and without
|
|
|
|
// --as-needed, --no-as-needed takes precedence over --as-needed because a
|
|
|
|
// user can add an extra DSO with --no-as-needed to force it to be added to
|
|
|
|
// the dependency list.
|
|
|
|
It->second->IsNeeded |= IsNeeded;
|
|
|
|
if (!WasInserted)
|
|
|
|
return;
|
2018-03-27 03:57:38 +08:00
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
SharedFiles.push_back(this);
|
2016-04-28 04:22:31 +08:00
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
Verdefs = parseVerdefs<ELFT>(Obj.base(), VerdefSec);
|
2016-04-28 04:22:31 +08:00
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
// Parse ".gnu.version" section which is a parallel array for the symbol
|
|
|
|
// table. If a given file doesn't have a ".gnu.version" section, we use
|
|
|
|
// VER_NDX_GLOBAL.
|
|
|
|
size_t Size = this->getELFSyms<ELFT>().size() - this->FirstGlobal;
|
|
|
|
std::vector<uint32_t> Versyms(Size, VER_NDX_GLOBAL);
|
|
|
|
if (VersymSec) {
|
|
|
|
ArrayRef<Elf_Versym> Versym =
|
|
|
|
CHECK(Obj.template getSectionContentsAsArray<Elf_Versym>(VersymSec),
|
|
|
|
this)
|
|
|
|
.slice(FirstGlobal);
|
|
|
|
for (size_t I = 0; I < Size; ++I)
|
|
|
|
Versyms[I] = Versym[I].vs_index;
|
2016-04-28 04:22:31 +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()) {
|
2019-05-17 09:55:20 +08:00
|
|
|
Symbol *S = Symtab->addSymbol(
|
2019-05-16 10:14:00 +08:00
|
|
|
Undefined{this, Name, Sym.getBinding(), Sym.st_other, Sym.getType()});
|
2018-10-04 07:53:11 +08:00
|
|
|
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
|
|
|
|
2019-05-16 10:14:00 +08:00
|
|
|
uint32_t Alignment = getAlignment<ELFT>(Sections, Sym);
|
|
|
|
if (!(Versyms[I] & VERSYM_HIDDEN)) {
|
2019-05-17 09:55:20 +08:00
|
|
|
Symtab->addSymbol(SharedSymbol{*this, Name, Sym.getBinding(),
|
2019-05-16 10:14:00 +08:00
|
|
|
Sym.st_other, Sym.getType(), Sym.st_value,
|
|
|
|
Sym.st_size, 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 =
|
2019-04-09 01:35:55 +08:00
|
|
|
this->StringTable.data() +
|
|
|
|
reinterpret_cast<const Elf_Verdef *>(Verdefs[Idx])->getAux()->vda_name;
|
2018-04-07 04:53:06 +08:00
|
|
|
VersionedNameBuffer.clear();
|
|
|
|
Name = (Name + "@" + VerName).toStringRef(VersionedNameBuffer);
|
2019-05-17 09:55:20 +08:00
|
|
|
Symtab->addSymbol(SharedSymbol{*this, Saver.save(Name), Sym.getBinding(),
|
2019-05-16 10:14:00 +08:00
|
|
|
Sym.st_other, Sym.getType(), Sym.st_value,
|
|
|
|
Sym.st_size, 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.
|
2019-05-16 13:23:25 +08:00
|
|
|
StringRef Name = ArchiveName.empty()
|
|
|
|
? Saver.save(Path)
|
|
|
|
: Saver.save(ArchiveName + "(" + Path + " at " +
|
|
|
|
utostr(OffsetInArchive) + ")");
|
|
|
|
MemoryBufferRef MBRef(MB.getBuffer(), Name);
|
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());
|
2019-05-16 10:14:00 +08:00
|
|
|
uint8_t Binding = ObjSym.isWeak() ? STB_WEAK : STB_GLOBAL;
|
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();
|
2019-05-16 10:14:00 +08:00
|
|
|
if (ObjSym.isUndefined() || (C != -1 && !KeptComdats[C])) {
|
|
|
|
Undefined New(&F, Name, Binding, Visibility, Type);
|
|
|
|
if (CanOmitFromDynSym)
|
|
|
|
New.ExportDynamic = false;
|
2019-05-17 09:55:20 +08:00
|
|
|
return Symtab->addSymbol(New);
|
2019-05-16 10:14:00 +08:00
|
|
|
}
|
2016-09-29 08:40:08 +08:00
|
|
|
|
2017-03-29 06:31:35 +08:00
|
|
|
if (ObjSym.isCommon())
|
2019-05-17 09:55:20 +08:00
|
|
|
return Symtab->addSymbol(
|
2019-05-16 11:29:03 +08:00
|
|
|
CommonSymbol{&F, Name, Binding, Visibility, STT_OBJECT,
|
|
|
|
ObjSym.getCommonAlignment(), ObjSym.getCommonSize()});
|
2019-05-16 10:14:00 +08:00
|
|
|
|
|
|
|
Defined New(&F, Name, Binding, Visibility, Type, 0, 0, nullptr);
|
|
|
|
if (CanOmitFromDynSym)
|
|
|
|
New.ExportDynamic = false;
|
2019-05-17 09:55:20 +08:00
|
|
|
return Symtab->addSymbol(New);
|
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>
|
2019-05-22 17:06:42 +08:00
|
|
|
void BitcodeFile::parse(
|
|
|
|
DenseMap<CachedHashStringRef, const InputFile *> &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())
|
2019-05-22 17:06:42 +08:00
|
|
|
KeptComdats.push_back(
|
|
|
|
ComdatGroups.try_emplace(CachedHashStringRef(S), this).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));
|
[ELF] Implement Dependent Libraries Feature
This patch implements a limited form of autolinking primarily designed to allow
either the --dependent-library compiler option, or "comment lib" pragmas (
https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=vs-2017) in
C/C++ e.g. #pragma comment(lib, "foo"), to cause an ELF linker to automatically
add the specified library to the link when processing the input file generated
by the compiler.
Currently this extension is unique to LLVM and LLD. However, care has been taken
to design this feature so that it could be supported by other ELF linkers.
The design goals were to provide:
- A simple linking model for developers to reason about.
- The ability to to override autolinking from the linker command line.
- Source code compatibility, where possible, with "comment lib" pragmas in other
environments (MSVC in particular).
Dependent library support is implemented differently for ELF platforms than on
the other platforms. Primarily this difference is that on ELF we pass the
dependent library specifiers directly to the linker without manipulating them.
This is in contrast to other platforms where they are mapped to a specific
linker option by the compiler. This difference is a result of the greater
variety of ELF linkers and the fact that ELF linkers tend to handle libraries in
a more complicated fashion than on other platforms. This forces us to defer
handling the specifiers to the linker.
In order to achieve a level of source code compatibility with other platforms
we have restricted this feature to work with libraries that meet the following
"reasonable" requirements:
1. There are no competing defined symbols in a given set of libraries, or
if they exist, the program owner doesn't care which is linked to their
program.
2. There may be circular dependencies between libraries.
The binary representation is a mergeable string section (SHF_MERGE,
SHF_STRINGS), called .deplibs, with custom type SHT_LLVM_DEPENDENT_LIBRARIES
(0x6fff4c04). The compiler forms this section by concatenating the arguments of
the "comment lib" pragmas and --dependent-library options in the order they are
encountered. Partial (-r, -Ur) links are handled by concatenating .deplibs
sections with the normal mergeable string section rules. As an example, #pragma
comment(lib, "foo") would result in:
.section ".deplibs","MS",@llvm_dependent_libraries,1
.asciz "foo"
For LTO, equivalent information to the contents of a the .deplibs section can be
retrieved by the LLD for bitcode input files.
LLD processes the dependent library specifiers in the following way:
1. Dependent libraries which are found from the specifiers in .deplibs sections
of relocatable object files are added when the linker decides to include that
file (which could itself be in a library) in the link. Dependent libraries
behave as if they were appended to the command line after all other options. As
a consequence the set of dependent libraries are searched last to resolve
symbols.
2. It is an error if a file cannot be found for a given specifier.
3. Any command line options in effect at the end of the command line parsing apply
to the dependent libraries, e.g. --whole-archive.
4. The linker tries to add a library or relocatable object file from each of the
strings in a .deplibs section by; first, handling the string as if it was
specified on the command line; second, by looking for the string in each of the
library search paths in turn; third, by looking for a lib<string>.a or
lib<string>.so (depending on the current mode of the linker) in each of the
library search paths.
5. A new command line option --no-dependent-libraries tells LLD to ignore the
dependent libraries.
Rationale for the above points:
1. Adding the dependent libraries last makes the process simple to understand
from a developers perspective. All linkers are able to implement this scheme.
2. Error-ing for libraries that are not found seems like better behavior than
failing the link during symbol resolution.
3. It seems useful for the user to be able to apply command line options which
will affect all of the dependent libraries. There is a potential problem of
surprise for developers, who might not realize that these options would apply
to these "invisible" input files; however, despite the potential for surprise,
this is easy for developers to reason about and gives developers the control
that they may require.
4. This algorithm takes into account all of the different ways that ELF linkers
find input files. The different search methods are tried by the linker in most
obvious to least obvious order.
5. I considered adding finer grained control over which dependent libraries were
ignored (e.g. MSVC has /nodefaultlib:<library>); however, I concluded that this
is not necessary: if finer control is required developers can fall back to using
the command line directly.
RFC thread: http://lists.llvm.org/pipermail/llvm-dev/2019-March/131004.html.
Differential Revision: https://reviews.llvm.org/D60274
llvm-svn: 360984
2019-05-17 11:44:15 +08:00
|
|
|
|
|
|
|
for (auto L : Obj->getDependentLibraries())
|
|
|
|
addDependentLibrary(L, this);
|
2016-02-13 04:54:57 +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] = '_';
|
|
|
|
|
2019-05-17 09:55:20 +08:00
|
|
|
Symtab->addSymbol(Defined{nullptr, Saver.save(S + "_start"), STB_GLOBAL,
|
|
|
|
STV_DEFAULT, STT_OBJECT, 0, 0, Section});
|
|
|
|
Symtab->addSymbol(Defined{nullptr, Saver.save(S + "_end"), STB_GLOBAL,
|
|
|
|
STV_DEFAULT, STT_OBJECT, Data.size(), 0, Section});
|
|
|
|
Symtab->addSymbol(Defined{nullptr, Saver.save(S + "_size"), STB_GLOBAL,
|
|
|
|
STV_DEFAULT, STT_OBJECT, Data.size(), 0, 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
|
|
|
}
|
|
|
|
|
2019-05-23 18:15:12 +08:00
|
|
|
void LazyObjFile::fetch() {
|
2019-05-23 18:08:56 +08:00
|
|
|
if (MB.getBuffer().empty())
|
2019-05-23 18:15:12 +08:00
|
|
|
return;
|
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
|
|
|
|
2019-05-23 18:08:56 +08:00
|
|
|
InputFile *File = createObjectFile(MB, ArchiveName, OffsetInArchive);
|
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
|
|
|
File->GroupId = GroupId;
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
|
2019-05-23 18:08:56 +08:00
|
|
|
MB = {};
|
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Copy symbol vector so that the new InputFile doesn't have to
|
|
|
|
// insert the same defined symbols to the symbol table again.
|
|
|
|
File->Symbols = std::move(Symbols);
|
2019-05-23 18:15:12 +08:00
|
|
|
|
|
|
|
parseFile(File);
|
2017-05-04 22:54:48 +08:00
|
|
|
}
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
template <class ELFT> void LazyObjFile::parse() {
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
using Elf_Sym = typename ELFT::Sym;
|
|
|
|
|
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);
|
2019-05-16 10:14:00 +08:00
|
|
|
for (const lto::InputFile::Symbol &Sym : Obj->symbols()) {
|
|
|
|
if (Sym.isUndefined())
|
|
|
|
continue;
|
2019-05-17 09:55:20 +08:00
|
|
|
Symtab->addSymbol(LazyObject{*this, Saver.save(Sym.getName())});
|
2019-05-16 10:14:00 +08:00
|
|
|
}
|
2018-03-08 09:05:58 +08:00
|
|
|
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
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// Find a symbol table.
|
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
|
|
|
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
// A symbol table is found.
|
|
|
|
ArrayRef<Elf_Sym> ESyms = CHECK(Obj.symbols(&Sec), this);
|
2018-03-29 06:55:40 +08:00
|
|
|
uint32_t FirstGlobal = Sec.sh_info;
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
StringRef Strtab = CHECK(Obj.getStringTableForSymtab(Sec, Sections), this);
|
|
|
|
this->Symbols.resize(ESyms.size());
|
|
|
|
|
|
|
|
// Get existing symbols or insert placeholder symbols.
|
|
|
|
for (size_t I = FirstGlobal, End = ESyms.size(); I != End; ++I)
|
|
|
|
if (ESyms[I].st_shndx != SHN_UNDEF)
|
|
|
|
this->Symbols[I] = Symtab->insert(CHECK(ESyms[I].getName(Strtab), this));
|
|
|
|
|
|
|
|
// Replace existing symbols with LazyObject symbols.
|
|
|
|
//
|
2019-05-23 17:58:08 +08:00
|
|
|
// resolve() may trigger this->fetch() if an existing symbol is an
|
|
|
|
// undefined symbol. If that happens, this LazyObjFile has served
|
|
|
|
// its purpose, and we can exit from the loop early.
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
for (Symbol *Sym : this->Symbols) {
|
|
|
|
if (!Sym)
|
2019-05-16 10:14:00 +08:00
|
|
|
continue;
|
2019-05-23 17:58:08 +08:00
|
|
|
Sym->resolve(LazyObject{*this, Sym->getName()});
|
2019-05-23 18:08:56 +08:00
|
|
|
|
|
|
|
// MemoryBuffer is emptied if this file is instantiated as ObjFile.
|
|
|
|
if (MB.getBuffer().empty())
|
Speed up --start-lib and --end-lib.
--{start,end}-lib give files grouped by the options the archive file
semantics. That is, each object file between them acts as if it were
in an archive file whose sole member is the file.
Therefore, files between --{start,end}-lib are linked to the final
output only if they are needed to resolve some undefined symbols.
Previously, the feature was implemented this way:
1. We read a symbol table and insert defined symbols to the symbol
table as lazy symbols.
2. If an undefind symbol is resolved to a lazy symbol, that lazy
symbol instantiate ObjFile class for that symbol, which re-insert
all defined symbols to the symbol table.
So, if an ObjFile is instantiated, defined symbols are inserted to the
symbol table twice. Since inserting long symbol names is not cheap,
there's a room to optimize here.
This patch optimzies it. Now, LazyObjFile remembers symbol handles and
passed them over to a new ObjFile instance, so that the ObjFile
doesn't insert the same strings.
Here is a quick benchmark to link clang. "Original" is the original
lld with unmodified command line options. For "Case 1" and "Case 2", I
extracted all files from archive files and replace .a's in a command
line with .o's wrapped with --{start,end}-lib. I used the original lld
for Case 1" and use this patch for Case 2.
Original: 5.892
Case 1: 6.001 (+1.8%)
Case 2: 5.701 (-3.2%)
So, interestingly, --{start,end}-lib are now faster than the regular
linking scheme with archive files. That's perhaps not too surprising,
though, because for regular archive files, we look up the symbol table
with the same string twice.
Differential Revision: https://reviews.llvm.org/D62188
llvm-svn: 361473
2019-05-23 17:53:30 +08:00
|
|
|
return;
|
2019-05-16 10:14:00 +08:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2019-05-22 17:06:42 +08:00
|
|
|
template void
|
|
|
|
BitcodeFile::parse<ELF32LE>(DenseMap<CachedHashStringRef, const InputFile *> &);
|
|
|
|
template void
|
|
|
|
BitcodeFile::parse<ELF32BE>(DenseMap<CachedHashStringRef, const InputFile *> &);
|
|
|
|
template void
|
|
|
|
BitcodeFile::parse<ELF64LE>(DenseMap<CachedHashStringRef, const InputFile *> &);
|
|
|
|
template void
|
|
|
|
BitcodeFile::parse<ELF64BE>(DenseMap<CachedHashStringRef, const InputFile *> &);
|
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
|
|
|
|
2019-04-09 01:35:55 +08:00
|
|
|
template void SharedFile::parse<ELF32LE>();
|
|
|
|
template void SharedFile::parse<ELF32BE>();
|
|
|
|
template void SharedFile::parse<ELF64LE>();
|
|
|
|
template void SharedFile::parse<ELF64BE>();
|