2020-04-03 02:54:05 +08:00
|
|
|
//===- InputFiles.cpp -----------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// 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
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains functions to parse Mach-O object files. In this comment,
|
|
|
|
// we describe the Mach-O file structure and how we parse it.
|
|
|
|
//
|
|
|
|
// Mach-O is not very different from ELF or COFF. The notion of symbols,
|
|
|
|
// sections and relocations exists in Mach-O as it does in ELF and COFF.
|
|
|
|
//
|
|
|
|
// Perhaps the notion that is new to those who know ELF/COFF is "subsections".
|
|
|
|
// In ELF/COFF, sections are an atomic unit of data copied from input files to
|
|
|
|
// output files. When we merge or garbage-collect sections, we treat each
|
|
|
|
// section as an atomic unit. In Mach-O, that's not the case. Sections can
|
|
|
|
// consist of multiple subsections, and subsections are a unit of merging and
|
|
|
|
// garbage-collecting. Therefore, Mach-O's subsections are more similar to
|
|
|
|
// ELF/COFF's sections than Mach-O's sections are.
|
|
|
|
//
|
|
|
|
// A section can have multiple symbols. A symbol that does not have the
|
|
|
|
// N_ALT_ENTRY attribute indicates a beginning of a subsection. Therefore, by
|
|
|
|
// definition, a symbol is always present at the beginning of each subsection. A
|
|
|
|
// symbol with N_ALT_ENTRY attribute does not start a new subsection and can
|
|
|
|
// point to a middle of a subsection.
|
|
|
|
//
|
|
|
|
// The notion of subsections also affects how relocations are represented in
|
|
|
|
// Mach-O. All references within a section need to be explicitly represented as
|
|
|
|
// relocations if they refer to different subsections, because we obviously need
|
|
|
|
// to fix up addresses if subsections are laid out in an output file differently
|
|
|
|
// than they were in object files. To represent that, Mach-O relocations can
|
|
|
|
// refer to an unnamed location via its address. Scattered relocations (those
|
|
|
|
// with the R_SCATTERED bit set) always refer to unnamed locations.
|
|
|
|
// Non-scattered relocations refer to an unnamed location if r_extern is not set
|
|
|
|
// and r_symbolnum is zero.
|
|
|
|
//
|
|
|
|
// Without the above differences, I think you can use your knowledge about ELF
|
|
|
|
// and COFF for Mach-O.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "InputFiles.h"
|
2020-04-24 11:16:49 +08:00
|
|
|
#include "Config.h"
|
2020-11-19 01:31:47 +08:00
|
|
|
#include "Driver.h"
|
[lld-macho] Emit STABS symbols for debugging, and drop debug sections
Debug sections contain a large amount of data. In order not to bloat the size
of the final binary, we remove them and instead emit STABS symbols for
`dsymutil` and the debugger to locate their contents in the object files.
With this diff, `dsymutil` is able to locate the debug info. However, we need
a few more features before `lldb` is able to work well with our binaries --
e.g. having `LC_DYSYMTAB` accurately reflect the number of local symbols,
emitting `LC_UUID`, and more. Those will be handled in follow-up diffs.
Note also that the STABS we emit differ slightly from what ld64 does. First, we
emit the path to the source file as one `N_SO` symbol instead of two. (`ld64`
emits one `N_SO` for the dirname and one of the basename.) Second, we do not
emit `N_BNSYM` and `N_ENSYM` STABS to mark the start and end of functions,
because the `N_FUN` STABS already serve that purpose. @clayborg recommended
these changes based on his knowledge of what the debugging tools look for.
Additionally, this current implementation doesn't accurately reflect the size
of function symbols. It uses the size of their containing sectioins as a proxy,
but that is only accurate if `.subsections_with_symbols` is set, and if there
isn't an `N_ALT_ENTRY` in that particular subsection. I think we have two
options to solve this:
1. We can split up subsections by symbol even if `.subsections_with_symbols`
is not set, but include constraints to ensure those subsections retain
their order in the final output. This is `ld64`'s approach.
2. We could just add a `size` field to our `Symbol` class. This seems simpler,
and I'm more inclined toward it, but I'm not sure if there are use cases
that it doesn't handle well. As such I'm punting on the decision for now.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D89257
2020-12-02 06:45:01 +08:00
|
|
|
#include "Dwarf.h"
|
[lld-macho] Use export trie instead of symtab when linking against dylibs
Summary:
This allows us to link against stripped dylibs. Moreover, it's simply
more correct: The symbol table includes symbols that the dylib uses but
doesn't export.
This temporarily regresses our ability to do lazy symbol binding because
dyld_stub_binder isn't in libSystem's export trie. Rather, it is in one
of the sub-libraries libSystem re-exports. (This doesn't affect our
tests since we are mocking out dyld_stub_binder there.) A follow-up diff
will address this by adding support for sub-libraries.
Depends on D79114.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Subscribers: mgorny, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79226
2020-04-23 11:00:57 +08:00
|
|
|
#include "ExportTrie.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
#include "InputSection.h"
|
2020-05-22 06:26:35 +08:00
|
|
|
#include "MachOStructs.h"
|
2020-08-19 05:37:04 +08:00
|
|
|
#include "ObjC.h"
|
2020-05-02 07:29:06 +08:00
|
|
|
#include "OutputSection.h"
|
2020-08-19 05:37:04 +08:00
|
|
|
#include "OutputSegment.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
#include "SymbolTable.h"
|
|
|
|
#include "Symbols.h"
|
|
|
|
#include "Target.h"
|
|
|
|
|
[lld-macho] Emit STABS symbols for debugging, and drop debug sections
Debug sections contain a large amount of data. In order not to bloat the size
of the final binary, we remove them and instead emit STABS symbols for
`dsymutil` and the debugger to locate their contents in the object files.
With this diff, `dsymutil` is able to locate the debug info. However, we need
a few more features before `lldb` is able to work well with our binaries --
e.g. having `LC_DYSYMTAB` accurately reflect the number of local symbols,
emitting `LC_UUID`, and more. Those will be handled in follow-up diffs.
Note also that the STABS we emit differ slightly from what ld64 does. First, we
emit the path to the source file as one `N_SO` symbol instead of two. (`ld64`
emits one `N_SO` for the dirname and one of the basename.) Second, we do not
emit `N_BNSYM` and `N_ENSYM` STABS to mark the start and end of functions,
because the `N_FUN` STABS already serve that purpose. @clayborg recommended
these changes based on his knowledge of what the debugging tools look for.
Additionally, this current implementation doesn't accurately reflect the size
of function symbols. It uses the size of their containing sectioins as a proxy,
but that is only accurate if `.subsections_with_symbols` is set, and if there
isn't an `N_ALT_ENTRY` in that particular subsection. I think we have two
options to solve this:
1. We can split up subsections by symbol even if `.subsections_with_symbols`
is not set, but include constraints to ensure those subsections retain
their order in the final output. This is `ld64`'s approach.
2. We could just add a `size` field to our `Symbol` class. This seems simpler,
and I'm more inclined toward it, but I'm not sure if there are use cases
that it doesn't handle well. As such I'm punting on the decision for now.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D89257
2020-12-02 06:45:01 +08:00
|
|
|
#include "lld/Common/DWARF.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
#include "lld/Common/ErrorHandler.h"
|
|
|
|
#include "lld/Common/Memory.h"
|
2020-11-29 11:38:27 +08:00
|
|
|
#include "lld/Common/Reproduce.h"
|
2020-08-14 04:48:47 +08:00
|
|
|
#include "llvm/ADT/iterator.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
#include "llvm/BinaryFormat/MachO.h"
|
2020-10-27 10:18:29 +08:00
|
|
|
#include "llvm/LTO/LTO.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2020-04-24 11:16:49 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2020-11-29 11:38:27 +08:00
|
|
|
#include "llvm/Support/TarWriter.h"
|
2021-02-24 10:42:00 +08:00
|
|
|
#include "llvm/TextAPI/MachO/Architecture.h"
|
2020-04-03 02:54:05 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::MachO;
|
|
|
|
using namespace llvm::support::endian;
|
2020-04-24 11:16:49 +08:00
|
|
|
using namespace llvm::sys;
|
2020-04-03 02:54:05 +08:00
|
|
|
using namespace lld;
|
|
|
|
using namespace lld::macho;
|
|
|
|
|
2020-12-02 08:00:48 +08:00
|
|
|
// Returns "<internal>", "foo.a(bar.o)", or "baz.o".
|
|
|
|
std::string lld::toString(const InputFile *f) {
|
|
|
|
if (!f)
|
|
|
|
return "<internal>";
|
|
|
|
if (f->archiveName.empty())
|
|
|
|
return std::string(f->getName());
|
|
|
|
return (path::filename(f->archiveName) + "(" + path::filename(f->getName()) +
|
|
|
|
")")
|
|
|
|
.str();
|
|
|
|
}
|
|
|
|
|
2020-12-15 06:59:22 +08:00
|
|
|
SetVector<InputFile *> macho::inputFiles;
|
2020-11-29 11:38:27 +08:00
|
|
|
std::unique_ptr<TarWriter> macho::tar;
|
2020-12-02 06:45:12 +08:00
|
|
|
int InputFile::idCount = 0;
|
2020-04-03 02:54:05 +08:00
|
|
|
|
|
|
|
// Open a given file path and return it as a memory-mapped file.
|
|
|
|
Optional<MemoryBufferRef> macho::readFile(StringRef path) {
|
|
|
|
// Open a file.
|
|
|
|
auto mbOrErr = MemoryBuffer::getFile(path);
|
|
|
|
if (auto ec = mbOrErr.getError()) {
|
|
|
|
error("cannot open " + path + ": " + ec.message());
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
|
|
|
|
MemoryBufferRef mbref = mb->getMemBufferRef();
|
|
|
|
make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
|
2020-04-22 04:37:57 +08:00
|
|
|
|
|
|
|
// If this is a regular non-fat file, return it.
|
|
|
|
const char *buf = mbref.getBufferStart();
|
|
|
|
auto *hdr = reinterpret_cast<const MachO::fat_header *>(buf);
|
2020-11-29 11:38:27 +08:00
|
|
|
if (read32be(&hdr->magic) != MachO::FAT_MAGIC) {
|
|
|
|
if (tar)
|
|
|
|
tar->append(relativeToRoot(path), mbref.getBuffer());
|
2020-04-22 04:37:57 +08:00
|
|
|
return mbref;
|
2020-11-29 11:38:27 +08:00
|
|
|
}
|
2020-04-22 04:37:57 +08:00
|
|
|
|
2020-04-30 06:42:36 +08:00
|
|
|
// Object files and archive files may be fat files, which contains
|
|
|
|
// multiple real files for different CPU ISAs. Here, we search for a
|
|
|
|
// file that matches with the current link target and returns it as
|
|
|
|
// a MemoryBufferRef.
|
|
|
|
auto *arch = reinterpret_cast<const MachO::fat_arch *>(buf + sizeof(*hdr));
|
|
|
|
|
|
|
|
for (uint32_t i = 0, n = read32be(&hdr->nfat_arch); i < n; ++i) {
|
|
|
|
if (reinterpret_cast<const char *>(arch + i + 1) >
|
|
|
|
buf + mbref.getBufferSize()) {
|
|
|
|
error(path + ": fat_arch struct extends beyond end of file");
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (read32be(&arch[i].cputype) != target->cpuType ||
|
|
|
|
read32be(&arch[i].cpusubtype) != target->cpuSubtype)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
uint32_t offset = read32be(&arch[i].offset);
|
|
|
|
uint32_t size = read32be(&arch[i].size);
|
|
|
|
if (offset + size > mbref.getBufferSize())
|
|
|
|
error(path + ": slice extends beyond end of file");
|
2020-11-29 11:38:27 +08:00
|
|
|
if (tar)
|
|
|
|
tar->append(relativeToRoot(path), mbref.getBuffer());
|
2020-04-30 06:42:36 +08:00
|
|
|
return MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
|
|
|
|
}
|
|
|
|
|
|
|
|
error("unable to find matching architecture in " + path);
|
2020-04-22 04:37:57 +08:00
|
|
|
return None;
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
|
2020-08-19 05:37:04 +08:00
|
|
|
const load_command *macho::findCommand(const mach_header_64 *hdr,
|
2020-04-03 02:54:05 +08:00
|
|
|
uint32_t type) {
|
|
|
|
const uint8_t *p =
|
|
|
|
reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
|
|
|
|
|
|
|
|
for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
|
|
|
|
auto *cmd = reinterpret_cast<const load_command *>(p);
|
|
|
|
if (cmd->cmd == type)
|
|
|
|
return cmd;
|
|
|
|
p += cmd->cmdsize;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2020-12-02 11:57:37 +08:00
|
|
|
void ObjFile::parseSections(ArrayRef<section_64> sections) {
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
subsections.reserve(sections.size());
|
2020-04-03 02:54:05 +08:00
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
|
|
|
|
|
|
for (const section_64 &sec : sections) {
|
|
|
|
InputSection *isec = make<InputSection>();
|
|
|
|
isec->file = this;
|
2020-08-19 05:37:04 +08:00
|
|
|
isec->name =
|
|
|
|
StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
|
|
|
|
isec->segname =
|
|
|
|
StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
|
[lld-macho] Ensure __bss sections we output have file offset of zero
Summary:
llvm-mc emits `__bss` sections with an offset of zero, but we weren't expecting
that in our input, so we were copying non-zero data from the start of the file and
putting it in `__bss`, with obviously undesirable runtime results. (It appears that
the kernel will copy those nonzero bytes as long as the offset is nonzero, regardless
of whether S_ZERO_FILL is set.)
I debated on whether to make a special ZeroFillSection -- separate from a
regular InputSection -- but it seemed like too much work for now. But I'm happy
to refactor if anyone feels strongly about having it as a separate class.
Depends on D80857.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D80859
2020-06-14 11:00:36 +08:00
|
|
|
isec->data = {isZeroFill(sec.flags) ? nullptr : buf + sec.offset,
|
|
|
|
static_cast<size_t>(sec.size)};
|
2020-04-03 02:54:05 +08:00
|
|
|
if (sec.align >= 32)
|
|
|
|
error("alignment " + std::to_string(sec.align) + " of section " +
|
|
|
|
isec->name + " is too large");
|
|
|
|
else
|
|
|
|
isec->align = 1 << sec.align;
|
|
|
|
isec->flags = sec.flags;
|
2020-12-09 09:47:19 +08:00
|
|
|
|
|
|
|
if (!(isDebugSection(isec->flags) &&
|
|
|
|
isec->segname == segment_names::dwarf)) {
|
|
|
|
subsections.push_back({{0, isec}});
|
|
|
|
} else {
|
|
|
|
// Instead of emitting DWARF sections, we emit STABS symbols to the
|
|
|
|
// object files that contain them. We filter them out early to avoid
|
|
|
|
// parsing their relocations unnecessarily. But we must still push an
|
|
|
|
// empty map to ensure the indices line up for the remaining sections.
|
|
|
|
subsections.push_back({});
|
|
|
|
debugSections.push_back(isec);
|
|
|
|
}
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
}
|
2020-04-03 02:54:05 +08:00
|
|
|
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
// Find the subsection corresponding to the greatest section offset that is <=
|
|
|
|
// that of the given offset.
|
|
|
|
//
|
|
|
|
// offset: an offset relative to the start of the original InputSection (before
|
|
|
|
// any subsection splitting has occurred). It will be updated to represent the
|
|
|
|
// same location as an offset relative to the start of the containing
|
|
|
|
// subsection.
|
|
|
|
static InputSection *findContainingSubsection(SubsectionMap &map,
|
|
|
|
uint32_t *offset) {
|
|
|
|
auto it = std::prev(map.upper_bound(*offset));
|
|
|
|
*offset -= it->first;
|
|
|
|
return it->second;
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
|
2021-02-24 10:41:52 +08:00
|
|
|
static bool validateRelocationInfo(InputFile *file, const section_64 &sec,
|
2021-01-19 23:44:42 +08:00
|
|
|
relocation_info rel) {
|
|
|
|
const TargetInfo::RelocAttrs &relocAttrs = target->getRelocAttrs(rel.r_type);
|
|
|
|
bool valid = true;
|
2021-02-24 10:41:52 +08:00
|
|
|
auto message = [relocAttrs, file, sec, rel, &valid](const Twine &diagnostic) {
|
2021-01-19 23:44:42 +08:00
|
|
|
valid = false;
|
|
|
|
return (relocAttrs.name + " relocation " + diagnostic + " at offset " +
|
|
|
|
std::to_string(rel.r_address) + " of " + sec.segname + "," +
|
2021-02-24 10:41:52 +08:00
|
|
|
sec.sectname + " in " + toString(file))
|
2021-01-19 23:44:42 +08:00
|
|
|
.str();
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!relocAttrs.hasAttr(RelocAttrBits::LOCAL) && !rel.r_extern)
|
|
|
|
error(message("must be extern"));
|
|
|
|
if (relocAttrs.hasAttr(RelocAttrBits::PCREL) != rel.r_pcrel)
|
|
|
|
error(message(Twine("must ") + (rel.r_pcrel ? "not " : "") +
|
|
|
|
"be PC-relative"));
|
|
|
|
if (isThreadLocalVariables(sec.flags) &&
|
2021-02-24 10:41:54 +08:00
|
|
|
!relocAttrs.hasAttr(RelocAttrBits::UNSIGNED))
|
2021-01-19 23:44:42 +08:00
|
|
|
error(message("not allowed in thread-local section, must be UNSIGNED"));
|
|
|
|
if (rel.r_length < 2 || rel.r_length > 3 ||
|
|
|
|
!relocAttrs.hasAttr(static_cast<RelocAttrBits>(1 << rel.r_length))) {
|
2020-09-27 04:00:22 +08:00
|
|
|
static SmallVector<StringRef, 4> widths{"0", "4", "8", "4 or 8"};
|
2021-01-19 23:44:42 +08:00
|
|
|
error(message("has width " + std::to_string(1 << rel.r_length) +
|
|
|
|
" bytes, but must be " +
|
|
|
|
widths[(static_cast<int>(relocAttrs.bits) >> 2) & 3] +
|
|
|
|
" bytes"));
|
|
|
|
}
|
|
|
|
return valid;
|
|
|
|
}
|
|
|
|
|
2020-12-02 11:57:37 +08:00
|
|
|
void ObjFile::parseRelocations(const section_64 &sec,
|
|
|
|
SubsectionMap &subsecMap) {
|
2020-04-03 02:54:05 +08:00
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
2020-10-15 00:49:54 +08:00
|
|
|
ArrayRef<relocation_info> relInfos(
|
|
|
|
reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
|
2020-04-03 02:54:05 +08:00
|
|
|
|
2020-10-15 00:49:54 +08:00
|
|
|
for (size_t i = 0; i < relInfos.size(); i++) {
|
|
|
|
// Paired relocations serve as Mach-O's method for attaching a
|
|
|
|
// supplemental datum to a primary relocation record. ELF does not
|
|
|
|
// need them because the *_RELOC_RELA records contain the extra
|
|
|
|
// addend field, vs. *_RELOC_REL which omit the addend.
|
|
|
|
//
|
|
|
|
// The {X86_64,ARM64}_RELOC_SUBTRACTOR record holds the subtrahend,
|
|
|
|
// and the paired *_RELOC_UNSIGNED record holds the minuend. The
|
2021-01-19 23:44:42 +08:00
|
|
|
// datum for each is a symbolic address. The result is the offset
|
|
|
|
// between two addresses.
|
2020-10-15 00:49:54 +08:00
|
|
|
//
|
|
|
|
// The ARM64_RELOC_ADDEND record holds the addend, and the paired
|
|
|
|
// ARM64_RELOC_BRANCH26 or ARM64_RELOC_PAGE21/PAGEOFF12 holds the
|
|
|
|
// base symbolic address.
|
|
|
|
//
|
|
|
|
// Note: X86 does not use *_RELOC_ADDEND because it can embed an
|
|
|
|
// addend into the instruction stream. On X86, a relocatable address
|
|
|
|
// field always occupies an entire contiguous sequence of byte(s),
|
|
|
|
// so there is no need to merge opcode bits with address
|
|
|
|
// bits. Therefore, it's easy and convenient to store addends in the
|
|
|
|
// instruction-stream bytes that would otherwise contain zeroes. By
|
|
|
|
// contrast, RISC ISAs such as ARM64 mix opcode bits with with
|
|
|
|
// address bits so that bitwise arithmetic is necessary to extract
|
|
|
|
// and insert them. Storing addends in the instruction stream is
|
|
|
|
// possible, but inconvenient and more costly at link time.
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
|
2021-01-19 23:44:42 +08:00
|
|
|
uint64_t pairedAddend = 0;
|
|
|
|
relocation_info relInfo = relInfos[i];
|
|
|
|
if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
|
|
|
|
pairedAddend = SignExtend64<24>(relInfo.r_symbolnum);
|
|
|
|
relInfo = relInfos[++i];
|
|
|
|
}
|
2020-10-15 00:49:54 +08:00
|
|
|
assert(i < relInfos.size());
|
2021-02-24 10:41:52 +08:00
|
|
|
if (!validateRelocationInfo(this, sec, relInfo))
|
2021-01-19 23:44:42 +08:00
|
|
|
continue;
|
2020-10-15 00:49:54 +08:00
|
|
|
if (relInfo.r_address & R_SCATTERED)
|
|
|
|
fatal("TODO: Scattered relocations not supported");
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
|
2021-01-19 23:44:42 +08:00
|
|
|
Reloc p;
|
|
|
|
if (target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND)) {
|
|
|
|
p.type = relInfo.r_type;
|
|
|
|
p.referent = symbols[relInfo.r_symbolnum];
|
|
|
|
relInfo = relInfos[++i];
|
2021-02-28 01:30:16 +08:00
|
|
|
// SUBTRACTOR relocations should always be followed by an UNSIGNED one
|
|
|
|
// indicating the minuend symbol.
|
|
|
|
assert(target->hasAttr(relInfo.r_type, RelocAttrBits::UNSIGNED) &&
|
|
|
|
relInfo.r_extern);
|
2021-01-19 23:44:42 +08:00
|
|
|
}
|
2021-02-28 01:30:19 +08:00
|
|
|
uint64_t embeddedAddend = target->getEmbeddedAddend(mb, sec, relInfo);
|
|
|
|
assert(!(embeddedAddend && pairedAddend));
|
|
|
|
uint64_t totalAddend = pairedAddend + embeddedAddend;
|
2020-04-03 02:54:05 +08:00
|
|
|
Reloc r;
|
2020-09-13 11:45:00 +08:00
|
|
|
r.type = relInfo.r_type;
|
|
|
|
r.pcrel = relInfo.r_pcrel;
|
|
|
|
r.length = relInfo.r_length;
|
2020-10-15 00:49:54 +08:00
|
|
|
r.offset = relInfo.r_address;
|
2020-09-13 11:45:00 +08:00
|
|
|
if (relInfo.r_extern) {
|
|
|
|
r.referent = symbols[relInfo.r_symbolnum];
|
2021-01-19 23:44:42 +08:00
|
|
|
r.addend = totalAddend;
|
2020-04-03 02:54:05 +08:00
|
|
|
} else {
|
2020-09-13 11:45:00 +08:00
|
|
|
SubsectionMap &referentSubsecMap = subsections[relInfo.r_symbolnum - 1];
|
|
|
|
const section_64 &referentSec = sectionHeaders[relInfo.r_symbolnum - 1];
|
|
|
|
uint32_t referentOffset;
|
|
|
|
if (relInfo.r_pcrel) {
|
2020-06-14 10:56:04 +08:00
|
|
|
// The implicit addend for pcrel section relocations is the pcrel offset
|
|
|
|
// in terms of the addresses in the input file. Here we adjust it so
|
2020-09-13 11:45:00 +08:00
|
|
|
// that it describes the offset from the start of the referent section.
|
2020-06-14 10:56:04 +08:00
|
|
|
// TODO: The offset of 4 is probably not right for ARM64, nor for
|
|
|
|
// relocations with r_length != 2.
|
2020-09-13 11:45:00 +08:00
|
|
|
referentOffset =
|
2021-01-19 23:44:42 +08:00
|
|
|
sec.addr + relInfo.r_address + 4 + totalAddend - referentSec.addr;
|
2020-06-14 10:56:04 +08:00
|
|
|
} else {
|
|
|
|
// The addend for a non-pcrel relocation is its absolute address.
|
2021-01-19 23:44:42 +08:00
|
|
|
referentOffset = totalAddend - referentSec.addr;
|
2020-06-14 10:56:04 +08:00
|
|
|
}
|
2020-09-13 11:45:00 +08:00
|
|
|
r.referent = findContainingSubsection(referentSubsecMap, &referentOffset);
|
|
|
|
r.addend = referentOffset;
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
|
2020-05-16 04:42:28 +08:00
|
|
|
InputSection *subsec = findContainingSubsection(subsecMap, &r.offset);
|
2021-02-28 01:30:16 +08:00
|
|
|
if (p.type != GENERIC_RELOC_INVALID)
|
2021-01-19 23:44:42 +08:00
|
|
|
subsec->relocs.push_back(p);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
subsec->relocs.push_back(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-18 23:40:46 +08:00
|
|
|
static macho::Symbol *createDefined(const structs::nlist_64 &sym,
|
|
|
|
StringRef name, InputSection *isec,
|
|
|
|
uint32_t value) {
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
// Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
|
|
|
|
// N_EXT: Global symbols
|
|
|
|
// N_EXT | N_PEXT: Linkage unit (think: dylib) scoped
|
|
|
|
// N_PEXT: Does not occur in input files in practice,
|
|
|
|
// a private extern must be external.
|
|
|
|
// 0: Translation-unit scoped. These are not in the symbol table.
|
|
|
|
|
|
|
|
if (sym.n_type & (N_EXT | N_PEXT)) {
|
|
|
|
assert((sym.n_type & N_EXT) && "invalid input");
|
2021-02-04 02:31:40 +08:00
|
|
|
return symtab->addDefined(name, isec->file, isec, value,
|
|
|
|
sym.n_desc & N_WEAK_DEF, sym.n_type & N_PEXT);
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
}
|
2021-02-04 02:31:40 +08:00
|
|
|
return make<Defined>(name, isec->file, isec, value, sym.n_desc & N_WEAK_DEF,
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
/*isExternal=*/false, /*isPrivateExtern=*/false);
|
2020-09-18 23:40:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Absolute symbols are defined symbols that do not have an associated
|
|
|
|
// InputSection. They cannot be weak.
|
|
|
|
static macho::Symbol *createAbsolute(const structs::nlist_64 &sym,
|
2021-02-04 02:31:40 +08:00
|
|
|
InputFile *file, StringRef name) {
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
if (sym.n_type & (N_EXT | N_PEXT)) {
|
|
|
|
assert((sym.n_type & N_EXT) && "invalid input");
|
2021-02-04 02:31:40 +08:00
|
|
|
return symtab->addDefined(name, file, nullptr, sym.n_value,
|
|
|
|
/*isWeakDef=*/false, sym.n_type & N_PEXT);
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
}
|
2021-02-04 02:31:40 +08:00
|
|
|
return make<Defined>(name, file, nullptr, sym.n_value, /*isWeakDef=*/false,
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
/*isExternal=*/false, /*isPrivateExtern=*/false);
|
2020-09-18 23:40:46 +08:00
|
|
|
}
|
|
|
|
|
2020-12-02 11:57:37 +08:00
|
|
|
macho::Symbol *ObjFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
|
|
|
|
StringRef name) {
|
2020-09-18 23:40:46 +08:00
|
|
|
uint8_t type = sym.n_type & N_TYPE;
|
|
|
|
switch (type) {
|
|
|
|
case N_UNDF:
|
|
|
|
return sym.n_value == 0
|
2021-02-04 02:31:40 +08:00
|
|
|
? symtab->addUndefined(name, this, sym.n_desc & N_WEAK_REF)
|
2020-09-18 23:40:46 +08:00
|
|
|
: symtab->addCommon(name, this, sym.n_value,
|
[lld/mac] Implement support for private extern symbols
Private extern symbols are used for things scoped to the linkage unit.
They cause duplicate symbol errors (so they're in the symbol table,
unlike TU-scoped truly local symbols), but they don't make it into the
export trie. They are created e.g. by compiling with
-fvisibility=hidden.
If two weak symbols have differing privateness, the combined symbol is
non-private external. (Example: inline functions and some TUs that
include the header defining it were built with
-fvisibility-inlines-hidden and some weren't).
A weak private external symbol implicitly has its "weak" dropped and
behaves like a regular strong private external symbol: Weak is an export
trie concept, and private symbols are not in the export trie.
If a weak and a strong symbol have different privateness, the strong
symbol wins.
If two common symbols have differing privateness, the larger symbol
wins. If they have the same size, the privateness of the symbol seen
later during the link wins (!) -- this is a bit lame, but it matches
ld64 and this behavior takes 2 lines less to implement than the less
surprising "result is non-private external), so match ld64.
(Example: `int a` in two .c files, both built with -fcommon,
one built with -fvisibility=hidden and one without.)
This also makes `__dyld_private` a true TU-local symbol, matching ld64.
To make this work, make the `const char*` StringRefZ ctor to correctly
set `size` (without this, writing the string table crashed when calling
getName() on the __dyld_private symbol).
Mention in CommonSymbol's comment that common symbols are now disabled
by default in clang.
Mention in -keep_private_externs's HelpText that the flag only has an
effect with `-r` (which we don't implement yet -- so this patch here
doesn't regress any behavior around -r + -keep_private_externs)). ld64
doesn't explicitly document it, but the commit text of
http://reviews.llvm.org/rL216146 does, and ld64's
OutputFile::buildSymbolTable() checks `_options.outputKind() ==
Options::kObjectFile` before calling `_options.keepPrivateExterns()`
(the only reference to that function).
Fixes PR48536.
Differential Revision: https://reviews.llvm.org/D93609
2020-12-18 02:30:18 +08:00
|
|
|
1 << GET_COMM_ALIGN(sym.n_desc),
|
|
|
|
sym.n_type & N_PEXT);
|
2020-09-18 23:40:46 +08:00
|
|
|
case N_ABS:
|
2021-02-04 02:31:40 +08:00
|
|
|
return createAbsolute(sym, this, name);
|
2020-09-18 23:40:46 +08:00
|
|
|
case N_PBUD:
|
|
|
|
case N_INDR:
|
|
|
|
error("TODO: support symbols of type " + std::to_string(type));
|
|
|
|
return nullptr;
|
|
|
|
case N_SECT:
|
|
|
|
llvm_unreachable(
|
|
|
|
"N_SECT symbols should not be passed to parseNonSectionSymbol");
|
|
|
|
default:
|
|
|
|
llvm_unreachable("invalid symbol type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-02 11:57:37 +08:00
|
|
|
void ObjFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
|
|
|
|
const char *strtab, bool subsectionsViaSymbols) {
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
// resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
|
|
|
|
// out-of-sequence.
|
|
|
|
symbols.resize(nList.size());
|
|
|
|
std::vector<size_t> altEntrySymIdxs;
|
|
|
|
|
|
|
|
for (size_t i = 0, n = nList.size(); i < n; ++i) {
|
2020-05-22 06:26:35 +08:00
|
|
|
const structs::nlist_64 &sym = nList[i];
|
2020-09-18 23:40:46 +08:00
|
|
|
StringRef name = strtab + sym.n_strx;
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
|
2020-09-18 23:40:46 +08:00
|
|
|
if ((sym.n_type & N_TYPE) != N_SECT) {
|
|
|
|
symbols[i] = parseNonSectionSymbol(sym, name);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
const section_64 &sec = sectionHeaders[sym.n_sect - 1];
|
|
|
|
SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
|
2020-12-09 09:47:19 +08:00
|
|
|
assert(!subsecMap.empty());
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
uint64_t offset = sym.n_value - sec.addr;
|
|
|
|
|
|
|
|
// If the input file does not use subsections-via-symbols, all symbols can
|
|
|
|
// use the same subsection. Otherwise, we must split the sections along
|
|
|
|
// symbol boundaries.
|
|
|
|
if (!subsectionsViaSymbols) {
|
2020-09-18 23:40:46 +08:00
|
|
|
symbols[i] = createDefined(sym, name, subsecMap[0], offset);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// nList entries aren't necessarily arranged in address order. Therefore,
|
|
|
|
// we can't create alt-entry symbols at this point because a later symbol
|
|
|
|
// may split its section, which may affect which subsection the alt-entry
|
|
|
|
// symbol is assigned to. So we need to handle them in a second pass below.
|
|
|
|
if (sym.n_desc & N_ALT_ENTRY) {
|
|
|
|
altEntrySymIdxs.push_back(i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the subsection corresponding to the greatest section offset that is
|
|
|
|
// <= that of the current symbol. The subsection that we find either needs
|
|
|
|
// to be used directly or split in two.
|
|
|
|
uint32_t firstSize = offset;
|
|
|
|
InputSection *firstIsec = findContainingSubsection(subsecMap, &firstSize);
|
|
|
|
|
|
|
|
if (firstSize == 0) {
|
|
|
|
// Alias of an existing symbol, or the first symbol in the section. These
|
|
|
|
// are handled by reusing the existing section.
|
2020-09-18 23:40:46 +08:00
|
|
|
symbols[i] = createDefined(sym, name, firstIsec, 0);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We saw a symbol definition at a new offset. Split the section into two
|
|
|
|
// subsections. The new symbol uses the second subsection.
|
|
|
|
auto *secondIsec = make<InputSection>(*firstIsec);
|
|
|
|
secondIsec->data = firstIsec->data.slice(firstSize);
|
|
|
|
firstIsec->data = firstIsec->data.slice(0, firstSize);
|
|
|
|
// TODO: ld64 appears to preserve the original alignment as well as each
|
|
|
|
// subsection's offset from the last aligned address. We should consider
|
|
|
|
// emulating that behavior.
|
|
|
|
secondIsec->align = MinAlign(firstIsec->align, offset);
|
|
|
|
|
|
|
|
subsecMap[offset] = secondIsec;
|
|
|
|
// By construction, the symbol will be at offset zero in the new section.
|
2020-09-18 23:40:46 +08:00
|
|
|
symbols[i] = createDefined(sym, name, secondIsec, 0);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
for (size_t idx : altEntrySymIdxs) {
|
2020-05-22 06:26:35 +08:00
|
|
|
const structs::nlist_64 &sym = nList[idx];
|
2020-09-18 23:40:46 +08:00
|
|
|
StringRef name = strtab + sym.n_strx;
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
|
|
|
|
uint32_t off = sym.n_value - sectionHeaders[sym.n_sect - 1].addr;
|
|
|
|
InputSection *subsec = findContainingSubsection(subsecMap, &off);
|
2020-09-18 23:40:46 +08:00
|
|
|
symbols[idx] = createDefined(sym, name, subsec, off);
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-11 09:47:13 +08:00
|
|
|
OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
|
|
|
|
StringRef sectName)
|
|
|
|
: InputFile(OpaqueKind, mb) {
|
|
|
|
InputSection *isec = make<InputSection>();
|
|
|
|
isec->file = this;
|
|
|
|
isec->name = sectName.take_front(16);
|
|
|
|
isec->segname = segName.take_front(16);
|
|
|
|
const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
|
|
isec->data = {buf, mb.getBufferSize()};
|
|
|
|
subsections.push_back({{0, isec}});
|
|
|
|
}
|
|
|
|
|
2020-12-02 08:00:48 +08:00
|
|
|
ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
|
2020-12-02 06:45:11 +08:00
|
|
|
: InputFile(ObjKind, mb), modTime(modTime) {
|
2020-12-02 08:00:48 +08:00
|
|
|
this->archiveName = std::string(archiveName);
|
|
|
|
|
2020-04-03 02:54:05 +08:00
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
|
|
auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
|
|
|
|
|
2021-02-24 10:42:00 +08:00
|
|
|
MachO::Architecture arch =
|
|
|
|
MachO::getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
|
|
|
|
if (arch != config->arch) {
|
|
|
|
error(toString(this) + " has architecture " + getArchitectureName(arch) +
|
|
|
|
" which is incompatible with target architecture " +
|
|
|
|
getArchitectureName(config->arch));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-12-04 05:40:04 +08:00
|
|
|
if (const load_command *cmd = findCommand(hdr, LC_LINKER_OPTION)) {
|
|
|
|
auto *c = reinterpret_cast<const linker_option_command *>(cmd);
|
|
|
|
StringRef data{reinterpret_cast<const char *>(c + 1),
|
|
|
|
c->cmdsize - sizeof(linker_option_command)};
|
|
|
|
parseLCLinkerOption(this, c->count, data);
|
|
|
|
}
|
|
|
|
|
2020-04-03 02:54:05 +08:00
|
|
|
if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
|
|
|
|
auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
sectionHeaders = ArrayRef<section_64>{
|
2020-04-03 02:54:05 +08:00
|
|
|
reinterpret_cast<const section_64 *>(c + 1), c->nsects};
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
parseSections(sectionHeaders);
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
|
2020-04-22 04:37:57 +08:00
|
|
|
// TODO: Error on missing LC_SYMTAB?
|
2020-04-03 02:54:05 +08:00
|
|
|
if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
|
|
|
|
auto *c = reinterpret_cast<const symtab_command *>(cmd);
|
2020-05-22 06:26:35 +08:00
|
|
|
ArrayRef<structs::nlist_64> nList(
|
|
|
|
reinterpret_cast<const structs::nlist_64 *>(buf + c->symoff), c->nsyms);
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
|
|
|
|
bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
|
|
|
|
parseSymbols(nList, strtab, subsectionsViaSymbols);
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// The relocations may refer to the symbols, so we parse them after we have
|
[lld-macho][re-land] Support .subsections_via_symbols
Summary:
This diff restores and builds upon @pcc and @ruiu's initial work on
subsections.
The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.
We exercise this functionality in our tests by using order files that
rearrange those symbols.
Depends on D79668.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Reviewed By: smeenai
Subscribers: thakis, llvm-commits, pcc, ruiu
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79926
2020-05-19 23:46:07 +08:00
|
|
|
// parsed all the symbols.
|
|
|
|
for (size_t i = 0, n = subsections.size(); i < n; ++i)
|
2020-12-09 09:47:19 +08:00
|
|
|
if (!subsections[i].empty())
|
|
|
|
parseRelocations(sectionHeaders[i], subsections[i]);
|
[lld-macho] Emit STABS symbols for debugging, and drop debug sections
Debug sections contain a large amount of data. In order not to bloat the size
of the final binary, we remove them and instead emit STABS symbols for
`dsymutil` and the debugger to locate their contents in the object files.
With this diff, `dsymutil` is able to locate the debug info. However, we need
a few more features before `lldb` is able to work well with our binaries --
e.g. having `LC_DYSYMTAB` accurately reflect the number of local symbols,
emitting `LC_UUID`, and more. Those will be handled in follow-up diffs.
Note also that the STABS we emit differ slightly from what ld64 does. First, we
emit the path to the source file as one `N_SO` symbol instead of two. (`ld64`
emits one `N_SO` for the dirname and one of the basename.) Second, we do not
emit `N_BNSYM` and `N_ENSYM` STABS to mark the start and end of functions,
because the `N_FUN` STABS already serve that purpose. @clayborg recommended
these changes based on his knowledge of what the debugging tools look for.
Additionally, this current implementation doesn't accurately reflect the size
of function symbols. It uses the size of their containing sectioins as a proxy,
but that is only accurate if `.subsections_with_symbols` is set, and if there
isn't an `N_ALT_ENTRY` in that particular subsection. I think we have two
options to solve this:
1. We can split up subsections by symbol even if `.subsections_with_symbols`
is not set, but include constraints to ensure those subsections retain
their order in the final output. This is `ld64`'s approach.
2. We could just add a `size` field to our `Symbol` class. This seems simpler,
and I'm more inclined toward it, but I'm not sure if there are use cases
that it doesn't handle well. As such I'm punting on the decision for now.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D89257
2020-12-02 06:45:01 +08:00
|
|
|
|
|
|
|
parseDebugInfo();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ObjFile::parseDebugInfo() {
|
|
|
|
std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
|
|
|
|
if (!dObj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
auto *ctx = make<DWARFContext>(
|
|
|
|
std::move(dObj), "",
|
2020-12-02 08:00:48 +08:00
|
|
|
[&](Error err) {
|
|
|
|
warn(toString(this) + ": " + toString(std::move(err)));
|
|
|
|
},
|
[lld-macho] Emit STABS symbols for debugging, and drop debug sections
Debug sections contain a large amount of data. In order not to bloat the size
of the final binary, we remove them and instead emit STABS symbols for
`dsymutil` and the debugger to locate their contents in the object files.
With this diff, `dsymutil` is able to locate the debug info. However, we need
a few more features before `lldb` is able to work well with our binaries --
e.g. having `LC_DYSYMTAB` accurately reflect the number of local symbols,
emitting `LC_UUID`, and more. Those will be handled in follow-up diffs.
Note also that the STABS we emit differ slightly from what ld64 does. First, we
emit the path to the source file as one `N_SO` symbol instead of two. (`ld64`
emits one `N_SO` for the dirname and one of the basename.) Second, we do not
emit `N_BNSYM` and `N_ENSYM` STABS to mark the start and end of functions,
because the `N_FUN` STABS already serve that purpose. @clayborg recommended
these changes based on his knowledge of what the debugging tools look for.
Additionally, this current implementation doesn't accurately reflect the size
of function symbols. It uses the size of their containing sectioins as a proxy,
but that is only accurate if `.subsections_with_symbols` is set, and if there
isn't an `N_ALT_ENTRY` in that particular subsection. I think we have two
options to solve this:
1. We can split up subsections by symbol even if `.subsections_with_symbols`
is not set, but include constraints to ensure those subsections retain
their order in the final output. This is `ld64`'s approach.
2. We could just add a `size` field to our `Symbol` class. This seems simpler,
and I'm more inclined toward it, but I'm not sure if there are use cases
that it doesn't handle well. As such I'm punting on the decision for now.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D89257
2020-12-02 06:45:01 +08:00
|
|
|
[&](Error warning) {
|
2020-12-02 08:00:48 +08:00
|
|
|
warn(toString(this) + ": " + toString(std::move(warning)));
|
[lld-macho] Emit STABS symbols for debugging, and drop debug sections
Debug sections contain a large amount of data. In order not to bloat the size
of the final binary, we remove them and instead emit STABS symbols for
`dsymutil` and the debugger to locate their contents in the object files.
With this diff, `dsymutil` is able to locate the debug info. However, we need
a few more features before `lldb` is able to work well with our binaries --
e.g. having `LC_DYSYMTAB` accurately reflect the number of local symbols,
emitting `LC_UUID`, and more. Those will be handled in follow-up diffs.
Note also that the STABS we emit differ slightly from what ld64 does. First, we
emit the path to the source file as one `N_SO` symbol instead of two. (`ld64`
emits one `N_SO` for the dirname and one of the basename.) Second, we do not
emit `N_BNSYM` and `N_ENSYM` STABS to mark the start and end of functions,
because the `N_FUN` STABS already serve that purpose. @clayborg recommended
these changes based on his knowledge of what the debugging tools look for.
Additionally, this current implementation doesn't accurately reflect the size
of function symbols. It uses the size of their containing sectioins as a proxy,
but that is only accurate if `.subsections_with_symbols` is set, and if there
isn't an `N_ALT_ENTRY` in that particular subsection. I think we have two
options to solve this:
1. We can split up subsections by symbol even if `.subsections_with_symbols`
is not set, but include constraints to ensure those subsections retain
their order in the final output. This is `ld64`'s approach.
2. We could just add a `size` field to our `Symbol` class. This seems simpler,
and I'm more inclined toward it, but I'm not sure if there are use cases
that it doesn't handle well. As such I'm punting on the decision for now.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D89257
2020-12-02 06:45:01 +08:00
|
|
|
});
|
|
|
|
|
|
|
|
// TODO: Since object files can contain a lot of DWARF info, we should verify
|
|
|
|
// that we are parsing just the info we need
|
|
|
|
const DWARFContext::compile_unit_range &units = ctx->compile_units();
|
|
|
|
auto it = units.begin();
|
|
|
|
compileUnit = it->get();
|
|
|
|
assert(std::next(it) == units.end());
|
2020-04-03 02:54:05 +08:00
|
|
|
}
|
|
|
|
|
2020-08-14 04:48:47 +08:00
|
|
|
// The path can point to either a dylib or a .tbd file.
|
|
|
|
static Optional<DylibFile *> loadDylib(StringRef path, DylibFile *umbrella) {
|
|
|
|
Optional<MemoryBufferRef> mbref = readFile(path);
|
|
|
|
if (!mbref) {
|
|
|
|
error("could not read dylib file at " + path);
|
|
|
|
return {};
|
|
|
|
}
|
2020-12-10 14:29:28 +08:00
|
|
|
return loadDylib(*mbref, umbrella);
|
2020-08-14 04:48:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// TBD files are parsed into a series of TAPI documents (InterfaceFiles), with
|
|
|
|
// the first document storing child pointers to the rest of them. When we are
|
|
|
|
// processing a given TBD file, we store that top-level document here. When
|
|
|
|
// processing re-exports, we search its children for potentially matching
|
|
|
|
// documents in the same TBD file. Note that the children themselves don't
|
|
|
|
// point to further documents, i.e. this is a two-level tree.
|
|
|
|
//
|
|
|
|
// ld64 allows a TAPI re-export to reference documents nested within other TBD
|
|
|
|
// files, but that seems like a strange design, so this is an intentional
|
|
|
|
// deviation.
|
|
|
|
const InterfaceFile *currentTopLevelTapi = nullptr;
|
|
|
|
|
|
|
|
// Re-exports can either refer to on-disk files, or to documents within .tbd
|
|
|
|
// files.
|
2020-12-10 07:08:05 +08:00
|
|
|
static Optional<DylibFile *> loadReexportHelper(StringRef path,
|
|
|
|
DylibFile *umbrella) {
|
2020-08-14 04:48:47 +08:00
|
|
|
if (path::is_absolute(path, path::Style::posix))
|
|
|
|
for (StringRef root : config->systemLibraryRoots)
|
|
|
|
if (Optional<std::string> dylibPath =
|
|
|
|
resolveDylibPath((root + path).str()))
|
|
|
|
return loadDylib(*dylibPath, umbrella);
|
|
|
|
|
|
|
|
// TODO: Expand @loader_path, @executable_path etc
|
|
|
|
|
2020-09-24 11:09:49 +08:00
|
|
|
if (currentTopLevelTapi) {
|
2020-08-14 04:48:47 +08:00
|
|
|
for (InterfaceFile &child :
|
|
|
|
make_pointee_range(currentTopLevelTapi->documents())) {
|
|
|
|
if (path == child.getInstallName())
|
|
|
|
return make<DylibFile>(child, umbrella);
|
|
|
|
assert(child.documents().empty());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Optional<std::string> dylibPath = resolveDylibPath(path))
|
|
|
|
return loadDylib(*dylibPath, umbrella);
|
|
|
|
|
|
|
|
error("unable to locate re-export with install name " + path);
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2020-12-10 07:08:05 +08:00
|
|
|
// If a re-exported dylib is public (lives in /usr/lib or
|
|
|
|
// /System/Library/Frameworks), then it is considered implicitly linked: we
|
|
|
|
// should bind to its symbols directly instead of via the re-exporting umbrella
|
|
|
|
// library.
|
|
|
|
static bool isImplicitlyLinked(StringRef path) {
|
|
|
|
if (!config->implicitDylibs)
|
|
|
|
return false;
|
|
|
|
|
2020-12-15 13:49:03 +08:00
|
|
|
if (path::parent_path(path) == "/usr/lib")
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Match /System/Library/Frameworks/$FOO.framework/**/$FOO
|
|
|
|
if (path.consume_front("/System/Library/Frameworks/")) {
|
|
|
|
StringRef frameworkName = path.take_until([](char c) { return c == '.'; });
|
|
|
|
return path::filename(path) == frameworkName;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2020-12-10 07:08:05 +08:00
|
|
|
}
|
|
|
|
|
2020-12-10 14:29:28 +08:00
|
|
|
void loadReexport(StringRef path, DylibFile *umbrella) {
|
2020-12-10 07:08:05 +08:00
|
|
|
Optional<DylibFile *> reexport = loadReexportHelper(path, umbrella);
|
|
|
|
if (reexport && isImplicitlyLinked(path))
|
2020-12-15 06:59:22 +08:00
|
|
|
inputFiles.insert(*reexport);
|
2020-12-10 07:08:05 +08:00
|
|
|
}
|
|
|
|
|
2021-02-23 02:03:02 +08:00
|
|
|
DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
|
|
|
|
bool isBundleLoader)
|
|
|
|
: InputFile(DylibKind, mb), refState(RefState::Unreferenced),
|
|
|
|
isBundleLoader(isBundleLoader) {
|
|
|
|
assert(!isBundleLoader || !umbrella);
|
2020-04-24 11:16:49 +08:00
|
|
|
if (umbrella == nullptr)
|
|
|
|
umbrella = this;
|
|
|
|
|
2020-04-22 04:37:57 +08:00
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
|
|
auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
|
|
|
|
|
|
|
|
// Initialize dylibName.
|
|
|
|
if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
|
|
|
|
auto *c = reinterpret_cast<const dylib_command *>(cmd);
|
2020-12-16 04:25:15 +08:00
|
|
|
currentVersion = read32le(&c->dylib.current_version);
|
|
|
|
compatibilityVersion = read32le(&c->dylib.compatibility_version);
|
2020-04-22 04:37:57 +08:00
|
|
|
dylibName = reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
|
2021-02-23 02:03:02 +08:00
|
|
|
} else if (!isBundleLoader) {
|
|
|
|
// macho_executable and macho_bundle don't have LC_ID_DYLIB,
|
|
|
|
// so it's OK.
|
2020-12-02 08:00:48 +08:00
|
|
|
error("dylib " + toString(this) + " missing LC_ID_DYLIB load command");
|
2020-04-22 04:37:57 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize symbols.
|
2020-12-10 07:08:05 +08:00
|
|
|
DylibFile *exportingFile = isImplicitlyLinked(dylibName) ? this : umbrella;
|
[lld-macho] Use export trie instead of symtab when linking against dylibs
Summary:
This allows us to link against stripped dylibs. Moreover, it's simply
more correct: The symbol table includes symbols that the dylib uses but
doesn't export.
This temporarily regresses our ability to do lazy symbol binding because
dyld_stub_binder isn't in libSystem's export trie. Rather, it is in one
of the sub-libraries libSystem re-exports. (This doesn't affect our
tests since we are mocking out dyld_stub_binder there.) A follow-up diff
will address this by adding support for sub-libraries.
Depends on D79114.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Subscribers: mgorny, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79226
2020-04-23 11:00:57 +08:00
|
|
|
if (const load_command *cmd = findCommand(hdr, LC_DYLD_INFO_ONLY)) {
|
|
|
|
auto *c = reinterpret_cast<const dyld_info_command *>(cmd);
|
|
|
|
parseTrie(buf + c->export_off, c->export_size,
|
|
|
|
[&](const Twine &name, uint64_t flags) {
|
2020-07-25 06:55:25 +08:00
|
|
|
bool isWeakDef = flags & EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
|
2020-08-13 10:50:09 +08:00
|
|
|
bool isTlv = flags & EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL;
|
2020-12-10 07:08:05 +08:00
|
|
|
symbols.push_back(symtab->addDylib(
|
|
|
|
saver.save(name), exportingFile, isWeakDef, isTlv));
|
[lld-macho] Use export trie instead of symtab when linking against dylibs
Summary:
This allows us to link against stripped dylibs. Moreover, it's simply
more correct: The symbol table includes symbols that the dylib uses but
doesn't export.
This temporarily regresses our ability to do lazy symbol binding because
dyld_stub_binder isn't in libSystem's export trie. Rather, it is in one
of the sub-libraries libSystem re-exports. (This doesn't affect our
tests since we are mocking out dyld_stub_binder there.) A follow-up diff
will address this by adding support for sub-libraries.
Depends on D79114.
Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee
Subscribers: mgorny, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D79226
2020-04-23 11:00:57 +08:00
|
|
|
});
|
|
|
|
} else {
|
2020-12-02 08:00:48 +08:00
|
|
|
error("LC_DYLD_INFO_ONLY not found in " + toString(this));
|
2020-04-24 11:16:49 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hdr->flags & MH_NO_REEXPORTED_DYLIBS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
const uint8_t *p =
|
|
|
|
reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
|
|
|
|
for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
|
|
|
|
auto *cmd = reinterpret_cast<const load_command *>(p);
|
|
|
|
p += cmd->cmdsize;
|
|
|
|
if (cmd->cmd != LC_REEXPORT_DYLIB)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
auto *c = reinterpret_cast<const dylib_command *>(cmd);
|
|
|
|
StringRef reexportPath =
|
|
|
|
reinterpret_cast<const char *>(c) + read32le(&c->dylib.name);
|
2020-12-10 14:29:28 +08:00
|
|
|
loadReexport(reexportPath, umbrella);
|
2020-04-22 04:37:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-23 02:03:02 +08:00
|
|
|
DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
|
|
|
|
bool isBundleLoader)
|
|
|
|
: InputFile(DylibKind, interface), refState(RefState::Unreferenced),
|
|
|
|
isBundleLoader(isBundleLoader) {
|
|
|
|
// FIXME: Add test for the missing TBD code path.
|
|
|
|
|
2020-06-06 02:18:33 +08:00
|
|
|
if (umbrella == nullptr)
|
|
|
|
umbrella = this;
|
|
|
|
|
2021-02-24 10:42:00 +08:00
|
|
|
if (!interface.getArchitectures().has(config->arch)) {
|
|
|
|
error(toString(this) + " is incompatible with " +
|
|
|
|
getArchitectureName(config->arch));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-08-13 10:50:12 +08:00
|
|
|
dylibName = saver.save(interface.getInstallName());
|
2020-12-16 04:25:15 +08:00
|
|
|
compatibilityVersion = interface.getCompatibilityVersion().rawValue();
|
|
|
|
currentVersion = interface.getCurrentVersion().rawValue();
|
2020-12-10 07:08:05 +08:00
|
|
|
DylibFile *exportingFile = isImplicitlyLinked(dylibName) ? this : umbrella;
|
2020-08-13 10:50:10 +08:00
|
|
|
auto addSymbol = [&](const Twine &name) -> void {
|
2020-12-10 07:08:05 +08:00
|
|
|
symbols.push_back(symtab->addDylib(saver.save(name), exportingFile,
|
2020-08-13 10:50:10 +08:00
|
|
|
/*isWeakDef=*/false,
|
|
|
|
/*isTlv=*/false));
|
|
|
|
};
|
2020-06-06 02:18:33 +08:00
|
|
|
// TODO(compnerd) filter out symbols based on the target platform
|
2020-08-13 10:50:09 +08:00
|
|
|
// TODO: handle weak defs, thread locals
|
2020-08-13 10:50:12 +08:00
|
|
|
for (const auto symbol : interface.symbols()) {
|
2020-08-13 10:50:10 +08:00
|
|
|
if (!symbol->getArchitectures().has(config->arch))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (symbol->getKind()) {
|
|
|
|
case SymbolKind::GlobalSymbol:
|
|
|
|
addSymbol(symbol->getName());
|
|
|
|
break;
|
|
|
|
case SymbolKind::ObjectiveCClass:
|
|
|
|
// XXX ld64 only creates these symbols when -ObjC is passed in. We may
|
|
|
|
// want to emulate that.
|
2020-08-19 05:37:04 +08:00
|
|
|
addSymbol(objc::klass + symbol->getName());
|
|
|
|
addSymbol(objc::metaclass + symbol->getName());
|
2020-08-13 10:50:10 +08:00
|
|
|
break;
|
|
|
|
case SymbolKind::ObjectiveCClassEHType:
|
2020-08-19 05:37:04 +08:00
|
|
|
addSymbol(objc::ehtype + symbol->getName());
|
2020-08-13 10:50:10 +08:00
|
|
|
break;
|
|
|
|
case SymbolKind::ObjectiveCInstanceVariable:
|
2020-08-19 05:37:04 +08:00
|
|
|
addSymbol(objc::ivar + symbol->getName());
|
2020-08-13 10:50:10 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-08-14 04:48:47 +08:00
|
|
|
|
|
|
|
bool isTopLevelTapi = false;
|
|
|
|
if (currentTopLevelTapi == nullptr) {
|
|
|
|
currentTopLevelTapi = &interface;
|
|
|
|
isTopLevelTapi = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (InterfaceFileRef intfRef : interface.reexportedLibraries())
|
2020-12-10 14:29:28 +08:00
|
|
|
loadReexport(intfRef.getInstallName(), umbrella);
|
2020-08-14 04:48:47 +08:00
|
|
|
|
|
|
|
if (isTopLevelTapi)
|
|
|
|
currentTopLevelTapi = nullptr;
|
2020-06-06 02:18:33 +08:00
|
|
|
}
|
|
|
|
|
2021-01-10 00:58:19 +08:00
|
|
|
ArchiveFile::ArchiveFile(std::unique_ptr<object::Archive> &&f)
|
2020-05-15 03:43:51 +08:00
|
|
|
: InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {
|
|
|
|
for (const object::Archive::Symbol &sym : file->symbols())
|
|
|
|
symtab->addLazy(sym.getName(), this, sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
|
|
|
|
object::Archive::Child c =
|
|
|
|
CHECK(sym.getMember(), toString(this) +
|
|
|
|
": could not get the member for symbol " +
|
2020-11-20 23:14:57 +08:00
|
|
|
toMachOString(sym));
|
2020-05-15 03:43:51 +08:00
|
|
|
|
|
|
|
if (!seen.insert(c.getChildOffset()).second)
|
|
|
|
return;
|
|
|
|
|
|
|
|
MemoryBufferRef mb =
|
|
|
|
CHECK(c.getMemoryBufferRef(),
|
|
|
|
toString(this) +
|
|
|
|
": could not get the buffer for the member defining symbol " +
|
2020-11-20 23:14:57 +08:00
|
|
|
toMachOString(sym));
|
2020-12-02 06:45:11 +08:00
|
|
|
|
2020-12-02 12:31:57 +08:00
|
|
|
if (tar && c.getParent()->isThin())
|
|
|
|
tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb.getBuffer());
|
|
|
|
|
2020-12-02 06:45:11 +08:00
|
|
|
uint32_t modTime = toTimeT(
|
|
|
|
CHECK(c.getLastModified(), toString(this) +
|
|
|
|
": could not get the modification time "
|
|
|
|
"for the member defining symbol " +
|
2020-11-20 23:14:57 +08:00
|
|
|
toMachOString(sym)));
|
2020-12-02 06:45:11 +08:00
|
|
|
|
2020-12-03 07:59:00 +08:00
|
|
|
// `sym` is owned by a LazySym, which will be replace<>() by make<ObjFile>
|
|
|
|
// and become invalid after that call. Copy it to the stack so we can refer
|
|
|
|
// to it later.
|
|
|
|
const object::Archive::Symbol sym_copy = sym;
|
|
|
|
|
2021-02-04 02:31:42 +08:00
|
|
|
if (Optional<InputFile *> file =
|
|
|
|
loadArchiveMember(mb, modTime, getName(), /*objCOnly=*/false)) {
|
|
|
|
inputFiles.insert(*file);
|
|
|
|
// ld64 doesn't demangle sym here even with -demangle. Match that, so
|
|
|
|
// intentionally no call to toMachOString() here.
|
|
|
|
printArchiveMemberLoad(sym_copy.getName(), *file);
|
2020-12-03 06:12:51 +08:00
|
|
|
}
|
2020-05-15 03:43:51 +08:00
|
|
|
}
|
|
|
|
|
[lld-macho] Basic support for linkage and visibility attributes in LTO
When parsing bitcode, convert LTO Symbols to LLD Symbols in order to perform
resolution. The "winning" symbol will then be marked as Prevailing at LTO
compilation time. This is similar to what the other LLD ports do.
This change allows us to handle `linkonce` symbols correctly, and to deal with
duplicate bitcode symbols gracefully. Previously, both scenarios would result in
an assertion failure inside the LTO code, complaining that multiple Prevailing
definitions are not allowed.
While at it, I also added basic logic around visibility. We don't do anything
useful with it yet, but we do check that its value is valid. LLD-ELF appears to
use it only to set FinalDefinitionInLinkageUnit for LTO, which I think is just a
performance optimization.
From my local experimentation, the linker itself doesn't seem to do anything
differently when encountering linkonce / linkonce_odr / weak / weak_odr. So I've
only written a test for one of them. LLD-ELF has more, but they seem to mostly
be testing the intermediate bitcode output of their LTO backend...? I'm far from
an expert here though, so I might very well be missing things.
Reviewed By: #lld-macho, MaskRay, smeenai
Differential Revision: https://reviews.llvm.org/D94342
2021-02-26 02:27:40 +08:00
|
|
|
static macho::Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &objSym,
|
|
|
|
BitcodeFile &file) {
|
|
|
|
StringRef name = saver.save(objSym.getName());
|
|
|
|
|
|
|
|
// TODO: support weak references
|
|
|
|
if (objSym.isUndefined())
|
|
|
|
return symtab->addUndefined(name, &file, /*isWeakRef=*/false);
|
|
|
|
|
|
|
|
assert(!objSym.isCommon() && "TODO: support common symbols in LTO");
|
|
|
|
|
|
|
|
// TODO: Write a test demonstrating why computing isPrivateExtern before
|
|
|
|
// LTO compilation is important.
|
|
|
|
bool isPrivateExtern = false;
|
|
|
|
switch (objSym.getVisibility()) {
|
|
|
|
case GlobalValue::HiddenVisibility:
|
|
|
|
isPrivateExtern = true;
|
|
|
|
break;
|
|
|
|
case GlobalValue::ProtectedVisibility:
|
|
|
|
error(name + " has protected visibility, which is not supported by Mach-O");
|
|
|
|
break;
|
|
|
|
case GlobalValue::DefaultVisibility:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
|
|
|
|
objSym.isWeak(), isPrivateExtern);
|
|
|
|
}
|
|
|
|
|
2020-10-27 10:18:29 +08:00
|
|
|
BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
|
|
|
|
: InputFile(BitcodeKind, mbref) {
|
|
|
|
obj = check(lto::InputFile::create(mbref));
|
[lld-macho] Basic support for linkage and visibility attributes in LTO
When parsing bitcode, convert LTO Symbols to LLD Symbols in order to perform
resolution. The "winning" symbol will then be marked as Prevailing at LTO
compilation time. This is similar to what the other LLD ports do.
This change allows us to handle `linkonce` symbols correctly, and to deal with
duplicate bitcode symbols gracefully. Previously, both scenarios would result in
an assertion failure inside the LTO code, complaining that multiple Prevailing
definitions are not allowed.
While at it, I also added basic logic around visibility. We don't do anything
useful with it yet, but we do check that its value is valid. LLD-ELF appears to
use it only to set FinalDefinitionInLinkageUnit for LTO, which I think is just a
performance optimization.
From my local experimentation, the linker itself doesn't seem to do anything
differently when encountering linkonce / linkonce_odr / weak / weak_odr. So I've
only written a test for one of them. LLD-ELF has more, but they seem to mostly
be testing the intermediate bitcode output of their LTO backend...? I'm far from
an expert here though, so I might very well be missing things.
Reviewed By: #lld-macho, MaskRay, smeenai
Differential Revision: https://reviews.llvm.org/D94342
2021-02-26 02:27:40 +08:00
|
|
|
|
|
|
|
// Convert LTO Symbols to LLD Symbols in order to perform resolution. The
|
|
|
|
// "winning" symbol will then be marked as Prevailing at LTO compilation
|
|
|
|
// time.
|
|
|
|
for (const lto::InputFile::Symbol &objSym : obj->symbols())
|
|
|
|
symbols.push_back(createBitcodeSymbol(objSym, *this));
|
2020-10-27 10:18:29 +08:00
|
|
|
}
|