403d61aedd
This just removes the code that gates the logic. The main issue here is
perf impact: without {D122258}, LLD takes a significant perf hit because
it now has to do a lot more work in the input parsing phase. But with
that change to eliminate unnecessary EH frames from input object files,
the perf overhead here is minimal. Concretely, here are the numbers for
some builds as measured on my 16-core Mac Pro:
**chromium_framework**
This is without the use of `-femit-dwarf-unwind=no-compact-unwind`:
base diff difference (95% CI)
sys_time 1.826 ± 0.019 1.962 ± 0.034 [ +6.5% .. +8.4%]
user_time 9.306 ± 0.054 9.926 ± 0.082 [ +6.2% .. +7.1%]
wall_time 8.225 ± 0.068 8.947 ± 0.128 [ +8.0% .. +9.6%]
samples 15 22
With that flag enabled, the regression mostly disappears, as hoped:
base diff difference (95% CI)
sys_time 1.839 ± 0.062 1.866 ± 0.068 [ -0.9% .. +3.8%]
user_time 9.452 ± 0.068 9.490 ± 0.067 [ -0.1% .. +0.9%]
wall_time 8.383 ± 0.127 8.452 ± 0.114 [ -0.1% .. +1.8%]
samples 17 21
**Unnamed internal app**
Without `-femit-dwarf-unwind`, this is the perf hit:
base diff difference (95% CI)
sys_time 1.372 ± 0.029 1.317 ± 0.024 [ -4.6% .. -3.5%]
user_time 2.835 ± 0.028 2.980 ± 0.027 [ +4.8% .. +5.4%]
wall_time 3.205 ± 0.079 3.383 ± 0.066 [ +4.9% .. +6.2%]
samples 102 83
With `-femit-dwarf-unwind`, the perf hit almost disappears:
base diff difference (95% CI)
sys_time 1.274 ± 0.026 1.270 ± 0.025 [ -0.9% .. +0.3%]
user_time 2.812 ± 0.023 2.822 ± 0.035 [ +0.1% .. +0.7%]
wall_time 3.166 ± 0.047 3.174 ± 0.059 [ -0.2% .. +0.7%]
samples 95 97
Just for fun, I measured the impact of `-femit-dwarf-unwind` on ld64
(`base` has the extra DWARF unwind info in the input object files,
`diff` doesn't):
base diff difference (95% CI)
sys_time 1.128 ± 0.010 1.124 ± 0.023 [ -1.3% .. +0.6%]
user_time 7.176 ± 0.030 7.106 ± 0.094 [ -1.5% .. -0.4%]
wall_time 7.874 ± 0.041 7.795 ± 0.121 [ -1.7% .. -0.3%]
samples 16 25
And for LLD:
base diff difference (95% CI)
sys_time 1.315 ± 0.019 1.280 ± 0.019 [ -3.2% .. -2.0%]
user_time 2.980 ± 0.022 2.822 ± 0.016 [ -5.5% .. -5.0%]
wall_time 3.369 ± 0.038 3.175 ± 0.033 [ -6.2% .. -5.3%]
samples 47 47
So parsing the extra EH frames is a lot more expensive for us than for
ld64. But given that we are quite a lot faster than ld64 to begin with,
I guess this isn't entirely unexpected...
Reviewed By: #lld-macho, oontvoo
Differential Revision: https://reviews.llvm.org/D129540
2193 lines
86 KiB
C++
2193 lines
86 KiB
C++
//===- 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"
|
|
#include "Config.h"
|
|
#include "Driver.h"
|
|
#include "Dwarf.h"
|
|
#include "EhFrame.h"
|
|
#include "ExportTrie.h"
|
|
#include "InputSection.h"
|
|
#include "MachOStructs.h"
|
|
#include "ObjC.h"
|
|
#include "OutputSection.h"
|
|
#include "OutputSegment.h"
|
|
#include "SymbolTable.h"
|
|
#include "Symbols.h"
|
|
#include "SyntheticSections.h"
|
|
#include "Target.h"
|
|
|
|
#include "lld/Common/CommonLinkerContext.h"
|
|
#include "lld/Common/DWARF.h"
|
|
#include "lld/Common/Reproduce.h"
|
|
#include "llvm/ADT/iterator.h"
|
|
#include "llvm/BinaryFormat/MachO.h"
|
|
#include "llvm/LTO/LTO.h"
|
|
#include "llvm/Support/BinaryStreamReader.h"
|
|
#include "llvm/Support/Endian.h"
|
|
#include "llvm/Support/LEB128.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/TarWriter.h"
|
|
#include "llvm/Support/TimeProfiler.h"
|
|
#include "llvm/TextAPI/Architecture.h"
|
|
#include "llvm/TextAPI/InterfaceFile.h"
|
|
|
|
#include <type_traits>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::MachO;
|
|
using namespace llvm::support::endian;
|
|
using namespace llvm::sys;
|
|
using namespace lld;
|
|
using namespace lld::macho;
|
|
|
|
// Returns "<internal>", "foo.a(bar.o)", or "baz.o".
|
|
std::string lld::toString(const InputFile *f) {
|
|
if (!f)
|
|
return "<internal>";
|
|
|
|
// Multiple dylibs can be defined in one .tbd file.
|
|
if (auto dylibFile = dyn_cast<DylibFile>(f))
|
|
if (f->getName().endswith(".tbd"))
|
|
return (f->getName() + "(" + dylibFile->installName + ")").str();
|
|
|
|
if (f->archiveName.empty())
|
|
return std::string(f->getName());
|
|
return (f->archiveName + "(" + path::filename(f->getName()) + ")").str();
|
|
}
|
|
|
|
std::string lld::toString(const Section &sec) {
|
|
return (toString(sec.file) + ":(" + sec.name + ")").str();
|
|
}
|
|
|
|
SetVector<InputFile *> macho::inputFiles;
|
|
std::unique_ptr<TarWriter> macho::tar;
|
|
int InputFile::idCount = 0;
|
|
|
|
static VersionTuple decodeVersion(uint32_t version) {
|
|
unsigned major = version >> 16;
|
|
unsigned minor = (version >> 8) & 0xffu;
|
|
unsigned subMinor = version & 0xffu;
|
|
return VersionTuple(major, minor, subMinor);
|
|
}
|
|
|
|
static std::vector<PlatformInfo> getPlatformInfos(const InputFile *input) {
|
|
if (!isa<ObjFile>(input) && !isa<DylibFile>(input))
|
|
return {};
|
|
|
|
const char *hdr = input->mb.getBufferStart();
|
|
|
|
// "Zippered" object files can have multiple LC_BUILD_VERSION load commands.
|
|
std::vector<PlatformInfo> platformInfos;
|
|
for (auto *cmd : findCommands<build_version_command>(hdr, LC_BUILD_VERSION)) {
|
|
PlatformInfo info;
|
|
info.target.Platform = static_cast<PlatformType>(cmd->platform);
|
|
info.minimum = decodeVersion(cmd->minos);
|
|
platformInfos.emplace_back(std::move(info));
|
|
}
|
|
for (auto *cmd : findCommands<version_min_command>(
|
|
hdr, LC_VERSION_MIN_MACOSX, LC_VERSION_MIN_IPHONEOS,
|
|
LC_VERSION_MIN_TVOS, LC_VERSION_MIN_WATCHOS)) {
|
|
PlatformInfo info;
|
|
switch (cmd->cmd) {
|
|
case LC_VERSION_MIN_MACOSX:
|
|
info.target.Platform = PLATFORM_MACOS;
|
|
break;
|
|
case LC_VERSION_MIN_IPHONEOS:
|
|
info.target.Platform = PLATFORM_IOS;
|
|
break;
|
|
case LC_VERSION_MIN_TVOS:
|
|
info.target.Platform = PLATFORM_TVOS;
|
|
break;
|
|
case LC_VERSION_MIN_WATCHOS:
|
|
info.target.Platform = PLATFORM_WATCHOS;
|
|
break;
|
|
}
|
|
info.minimum = decodeVersion(cmd->version);
|
|
platformInfos.emplace_back(std::move(info));
|
|
}
|
|
|
|
return platformInfos;
|
|
}
|
|
|
|
static bool checkCompatibility(const InputFile *input) {
|
|
std::vector<PlatformInfo> platformInfos = getPlatformInfos(input);
|
|
if (platformInfos.empty())
|
|
return true;
|
|
|
|
auto it = find_if(platformInfos, [&](const PlatformInfo &info) {
|
|
return removeSimulator(info.target.Platform) ==
|
|
removeSimulator(config->platform());
|
|
});
|
|
if (it == platformInfos.end()) {
|
|
std::string platformNames;
|
|
raw_string_ostream os(platformNames);
|
|
interleave(
|
|
platformInfos, os,
|
|
[&](const PlatformInfo &info) {
|
|
os << getPlatformName(info.target.Platform);
|
|
},
|
|
"/");
|
|
error(toString(input) + " has platform " + platformNames +
|
|
Twine(", which is different from target platform ") +
|
|
getPlatformName(config->platform()));
|
|
return false;
|
|
}
|
|
|
|
if (it->minimum > config->platformInfo.minimum)
|
|
warn(toString(input) + " has version " + it->minimum.getAsString() +
|
|
", which is newer than target minimum of " +
|
|
config->platformInfo.minimum.getAsString());
|
|
|
|
return true;
|
|
}
|
|
|
|
// This cache mostly exists to store system libraries (and .tbds) as they're
|
|
// loaded, rather than the input archives, which are already cached at a higher
|
|
// level, and other files like the filelist that are only read once.
|
|
// Theoretically this caching could be more efficient by hoisting it, but that
|
|
// would require altering many callers to track the state.
|
|
DenseMap<CachedHashStringRef, MemoryBufferRef> macho::cachedReads;
|
|
// Open a given file path and return it as a memory-mapped file.
|
|
Optional<MemoryBufferRef> macho::readFile(StringRef path) {
|
|
CachedHashStringRef key(path);
|
|
auto entry = cachedReads.find(key);
|
|
if (entry != cachedReads.end())
|
|
return entry->second;
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
|
|
if (std::error_code 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
|
|
|
|
// If this is a regular non-fat file, return it.
|
|
const char *buf = mbref.getBufferStart();
|
|
const auto *hdr = reinterpret_cast<const fat_header *>(buf);
|
|
if (mbref.getBufferSize() < sizeof(uint32_t) ||
|
|
read32be(&hdr->magic) != FAT_MAGIC) {
|
|
if (tar)
|
|
tar->append(relativeToRoot(path), mbref.getBuffer());
|
|
return cachedReads[key] = mbref;
|
|
}
|
|
|
|
llvm::BumpPtrAllocator &bAlloc = lld::bAlloc();
|
|
|
|
// Object files and archive files may be fat files, which contain 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.
|
|
const auto *arch = reinterpret_cast<const 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) != static_cast<uint32_t>(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");
|
|
if (tar)
|
|
tar->append(relativeToRoot(path), mbref.getBuffer());
|
|
return cachedReads[key] = MemoryBufferRef(StringRef(buf + offset, size),
|
|
path.copy(bAlloc));
|
|
}
|
|
|
|
error("unable to find matching architecture in " + path);
|
|
return None;
|
|
}
|
|
|
|
InputFile::InputFile(Kind kind, const InterfaceFile &interface)
|
|
: id(idCount++), fileKind(kind), name(saver().save(interface.getPath())) {}
|
|
|
|
// Some sections comprise of fixed-size records, so instead of splitting them at
|
|
// symbol boundaries, we split them based on size. Records are distinct from
|
|
// literals in that they may contain references to other sections, instead of
|
|
// being leaf nodes in the InputSection graph.
|
|
//
|
|
// Note that "record" is a term I came up with. In contrast, "literal" is a term
|
|
// used by the Mach-O format.
|
|
static Optional<size_t> getRecordSize(StringRef segname, StringRef name) {
|
|
if (name == section_names::compactUnwind) {
|
|
if (segname == segment_names::ld)
|
|
return target->wordSize == 8 ? 32 : 20;
|
|
}
|
|
if (config->icfLevel == ICFLevel::none)
|
|
return {};
|
|
|
|
if (name == section_names::cfString && segname == segment_names::data)
|
|
return target->wordSize == 8 ? 32 : 16;
|
|
if (name == section_names::objcClassRefs && segname == segment_names::data)
|
|
return target->wordSize;
|
|
return {};
|
|
}
|
|
|
|
static Error parseCallGraph(ArrayRef<uint8_t> data,
|
|
std::vector<CallGraphEntry> &callGraph) {
|
|
TimeTraceScope timeScope("Parsing call graph section");
|
|
BinaryStreamReader reader(data, support::little);
|
|
while (!reader.empty()) {
|
|
uint32_t fromIndex, toIndex;
|
|
uint64_t count;
|
|
if (Error err = reader.readInteger(fromIndex))
|
|
return err;
|
|
if (Error err = reader.readInteger(toIndex))
|
|
return err;
|
|
if (Error err = reader.readInteger(count))
|
|
return err;
|
|
callGraph.emplace_back(fromIndex, toIndex, count);
|
|
}
|
|
return Error::success();
|
|
}
|
|
|
|
// Parse the sequence of sections within a single LC_SEGMENT(_64).
|
|
// Split each section into subsections.
|
|
template <class SectionHeader>
|
|
void ObjFile::parseSections(ArrayRef<SectionHeader> sectionHeaders) {
|
|
sections.reserve(sectionHeaders.size());
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
|
|
for (const SectionHeader &sec : sectionHeaders) {
|
|
StringRef name =
|
|
StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
|
|
StringRef segname =
|
|
StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
|
|
sections.push_back(make<Section>(this, segname, name, sec.flags, sec.addr));
|
|
if (sec.align >= 32) {
|
|
error("alignment " + std::to_string(sec.align) + " of section " + name +
|
|
" is too large");
|
|
continue;
|
|
}
|
|
Section §ion = *sections.back();
|
|
uint32_t align = 1 << sec.align;
|
|
ArrayRef<uint8_t> data = {isZeroFill(sec.flags) ? nullptr
|
|
: buf + sec.offset,
|
|
static_cast<size_t>(sec.size)};
|
|
|
|
auto splitRecords = [&](int recordSize) -> void {
|
|
if (data.empty())
|
|
return;
|
|
Subsections &subsections = section.subsections;
|
|
subsections.reserve(data.size() / recordSize);
|
|
for (uint64_t off = 0; off < data.size(); off += recordSize) {
|
|
auto *isec = make<ConcatInputSection>(
|
|
section, data.slice(off, recordSize), align);
|
|
subsections.push_back({off, isec});
|
|
}
|
|
section.doneSplitting = true;
|
|
};
|
|
|
|
if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
|
|
(config->dedupLiterals && isWordLiteralSection(sec.flags))) {
|
|
if (sec.nreloc && config->dedupLiterals)
|
|
fatal(toString(this) + " contains relocations in " + sec.segname + "," +
|
|
sec.sectname +
|
|
", so LLD cannot deduplicate literals. Try re-running without "
|
|
"--deduplicate-literals.");
|
|
|
|
InputSection *isec;
|
|
if (sectionType(sec.flags) == S_CSTRING_LITERALS) {
|
|
isec = make<CStringInputSection>(section, data, align);
|
|
// FIXME: parallelize this?
|
|
cast<CStringInputSection>(isec)->splitIntoPieces();
|
|
} else {
|
|
isec = make<WordLiteralInputSection>(section, data, align);
|
|
}
|
|
section.subsections.push_back({0, isec});
|
|
} else if (auto recordSize = getRecordSize(segname, name)) {
|
|
splitRecords(*recordSize);
|
|
} else if (name == section_names::ehFrame &&
|
|
segname == segment_names::text) {
|
|
splitEhFrames(data, *sections.back());
|
|
} else if (segname == segment_names::llvm) {
|
|
if (config->callGraphProfileSort && name == section_names::cgProfile)
|
|
checkError(parseCallGraph(data, callGraph));
|
|
// ld64 does not appear to emit contents from sections within the __LLVM
|
|
// segment. Symbols within those sections point to bitcode metadata
|
|
// instead of actual symbols. Global symbols within those sections could
|
|
// have the same name without causing duplicate symbol errors. To avoid
|
|
// spurious duplicate symbol errors, we do not parse these sections.
|
|
// TODO: Evaluate whether the bitcode metadata is needed.
|
|
} else {
|
|
if (name == section_names::addrSig)
|
|
addrSigSection = sections.back();
|
|
|
|
auto *isec = make<ConcatInputSection>(section, data, align);
|
|
if (isDebugSection(isec->getFlags()) &&
|
|
isec->getSegName() == segment_names::dwarf) {
|
|
// 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.
|
|
debugSections.push_back(isec);
|
|
} else {
|
|
section.subsections.push_back({0, isec});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ObjFile::splitEhFrames(ArrayRef<uint8_t> data, Section &ehFrameSection) {
|
|
EhReader reader(this, data, /*dataOff=*/0, target->wordSize);
|
|
size_t off = 0;
|
|
while (off < reader.size()) {
|
|
uint64_t frameOff = off;
|
|
uint64_t length = reader.readLength(&off);
|
|
if (length == 0)
|
|
break;
|
|
uint64_t fullLength = length + (off - frameOff);
|
|
off += length;
|
|
// We hard-code an alignment of 1 here because we don't actually want our
|
|
// EH frames to be aligned to the section alignment. EH frame decoders don't
|
|
// expect this alignment. Moreover, each EH frame must start where the
|
|
// previous one ends, and where it ends is indicated by the length field.
|
|
// Unless we update the length field (troublesome), we should keep the
|
|
// alignment to 1.
|
|
// Note that we still want to preserve the alignment of the overall section,
|
|
// just not of the individual EH frames.
|
|
ehFrameSection.subsections.push_back(
|
|
{frameOff, make<ConcatInputSection>(ehFrameSection,
|
|
data.slice(frameOff, fullLength),
|
|
/*align=*/1)});
|
|
}
|
|
ehFrameSection.doneSplitting = true;
|
|
}
|
|
|
|
template <class T>
|
|
static Section *findContainingSection(const std::vector<Section *> §ions,
|
|
T *offset) {
|
|
static_assert(std::is_same<uint64_t, T>::value ||
|
|
std::is_same<uint32_t, T>::value,
|
|
"unexpected type for offset");
|
|
auto it = std::prev(llvm::upper_bound(
|
|
sections, *offset,
|
|
[](uint64_t value, const Section *sec) { return value < sec->addr; }));
|
|
*offset -= (*it)->addr;
|
|
return *it;
|
|
}
|
|
|
|
// 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.
|
|
template <class T>
|
|
static InputSection *findContainingSubsection(const Section §ion,
|
|
T *offset) {
|
|
static_assert(std::is_same<uint64_t, T>::value ||
|
|
std::is_same<uint32_t, T>::value,
|
|
"unexpected type for offset");
|
|
auto it = std::prev(llvm::upper_bound(
|
|
section.subsections, *offset,
|
|
[](uint64_t value, Subsection subsec) { return value < subsec.offset; }));
|
|
*offset -= it->offset;
|
|
return it->isec;
|
|
}
|
|
|
|
// Find a symbol at offset `off` within `isec`.
|
|
static Defined *findSymbolAtOffset(const ConcatInputSection *isec,
|
|
uint64_t off) {
|
|
auto it = llvm::lower_bound(isec->symbols, off, [](Defined *d, uint64_t off) {
|
|
return d->value < off;
|
|
});
|
|
// The offset should point at the exact address of a symbol (with no addend.)
|
|
if (it == isec->symbols.end() || (*it)->value != off) {
|
|
assert(isec->wasCoalesced);
|
|
return nullptr;
|
|
}
|
|
return *it;
|
|
}
|
|
|
|
// Linker optimization hints mark a sequence of instructions used for
|
|
// synthesizing an address which that be transformed into a faster sequence. The
|
|
// transformations depend on conditions that are determined at link time, like
|
|
// the distance to the referenced symbol or its alignment.
|
|
//
|
|
// Each hint has a type and refers to 2 or 3 instructions. Each of those
|
|
// instructions must have a corresponding relocation. After addresses have been
|
|
// finalized and relocations have been performed, we check if the requirements
|
|
// hold, and perform the optimizations if they do.
|
|
//
|
|
// Similar linker relaxations exist for ELF as well, with the difference being
|
|
// that the explicit marking allows for the relaxation of non-consecutive
|
|
// relocations too.
|
|
//
|
|
// The specific types of hints are documented in Arch/ARM64.cpp
|
|
void ObjFile::parseOptimizationHints(ArrayRef<uint8_t> data) {
|
|
auto expectedArgCount = [](uint8_t type) {
|
|
switch (type) {
|
|
case LOH_ARM64_ADRP_ADRP:
|
|
case LOH_ARM64_ADRP_LDR:
|
|
case LOH_ARM64_ADRP_ADD:
|
|
case LOH_ARM64_ADRP_LDR_GOT:
|
|
return 2;
|
|
case LOH_ARM64_ADRP_ADD_LDR:
|
|
case LOH_ARM64_ADRP_ADD_STR:
|
|
case LOH_ARM64_ADRP_LDR_GOT_LDR:
|
|
case LOH_ARM64_ADRP_LDR_GOT_STR:
|
|
return 3;
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
// Each hint contains at least 4 ULEB128-encoded fields, so in the worst case,
|
|
// there are data.size() / 4 LOHs. It's a huge overestimation though, as
|
|
// offsets are unlikely to fall in the 0-127 byte range, so we pre-allocate
|
|
// half as much.
|
|
optimizationHints.reserve(data.size() / 8);
|
|
|
|
for (const uint8_t *p = data.begin(); p < data.end();) {
|
|
const ptrdiff_t inputOffset = p - data.begin();
|
|
unsigned int n = 0;
|
|
uint8_t type = decodeULEB128(p, &n, data.end());
|
|
p += n;
|
|
|
|
// An entry of type 0 terminates the list.
|
|
if (type == 0)
|
|
break;
|
|
|
|
int expectedCount = expectedArgCount(type);
|
|
if (LLVM_UNLIKELY(expectedCount == -1)) {
|
|
error("Linker optimization hint at offset " + Twine(inputOffset) +
|
|
" has unknown type " + Twine(type));
|
|
return;
|
|
}
|
|
|
|
uint8_t argCount = decodeULEB128(p, &n, data.end());
|
|
p += n;
|
|
|
|
if (LLVM_UNLIKELY(argCount != expectedCount)) {
|
|
error("Linker optimization hint at offset " + Twine(inputOffset) +
|
|
" has " + Twine(argCount) + " arguments instead of the expected " +
|
|
Twine(expectedCount));
|
|
return;
|
|
}
|
|
|
|
uint64_t offset0 = decodeULEB128(p, &n, data.end());
|
|
p += n;
|
|
|
|
int16_t delta[2];
|
|
for (int i = 0; i < argCount - 1; ++i) {
|
|
uint64_t address = decodeULEB128(p, &n, data.end());
|
|
p += n;
|
|
int64_t d = address - offset0;
|
|
if (LLVM_UNLIKELY(d > std::numeric_limits<int16_t>::max() ||
|
|
d < std::numeric_limits<int16_t>::min())) {
|
|
error("Linker optimization hint at offset " + Twine(inputOffset) +
|
|
" has addresses too far apart");
|
|
return;
|
|
}
|
|
delta[i] = d;
|
|
}
|
|
|
|
optimizationHints.push_back({offset0, {delta[0], delta[1]}, type});
|
|
}
|
|
|
|
// We sort the per-object vector of optimization hints so each section only
|
|
// needs to hold an ArrayRef to a contiguous range of hints.
|
|
llvm::sort(optimizationHints,
|
|
[](const OptimizationHint &a, const OptimizationHint &b) {
|
|
return a.offset0 < b.offset0;
|
|
});
|
|
|
|
auto section = sections.begin();
|
|
auto subsection = (*section)->subsections.begin();
|
|
uint64_t subsectionBase = 0;
|
|
uint64_t subsectionEnd = 0;
|
|
|
|
auto updateAddr = [&]() {
|
|
subsectionBase = (*section)->addr + subsection->offset;
|
|
subsectionEnd = subsectionBase + subsection->isec->getSize();
|
|
};
|
|
|
|
auto advanceSubsection = [&]() {
|
|
if (section == sections.end())
|
|
return;
|
|
++subsection;
|
|
if (subsection == (*section)->subsections.end()) {
|
|
++section;
|
|
if (section == sections.end())
|
|
return;
|
|
subsection = (*section)->subsections.begin();
|
|
}
|
|
};
|
|
|
|
updateAddr();
|
|
auto hintStart = optimizationHints.begin();
|
|
for (auto hintEnd = hintStart, end = optimizationHints.end(); hintEnd != end;
|
|
++hintEnd) {
|
|
if (hintEnd->offset0 >= subsectionEnd) {
|
|
subsection->isec->optimizationHints =
|
|
ArrayRef<OptimizationHint>(&*hintStart, hintEnd - hintStart);
|
|
|
|
hintStart = hintEnd;
|
|
while (hintStart->offset0 >= subsectionEnd) {
|
|
advanceSubsection();
|
|
if (section == sections.end())
|
|
break;
|
|
updateAddr();
|
|
}
|
|
}
|
|
|
|
hintEnd->offset0 -= subsectionBase;
|
|
for (int i = 0, count = expectedArgCount(hintEnd->type); i < count - 1;
|
|
++i) {
|
|
if (LLVM_UNLIKELY(
|
|
hintEnd->delta[i] < -static_cast<int64_t>(hintEnd->offset0) ||
|
|
hintEnd->delta[i] >=
|
|
static_cast<int64_t>(subsectionEnd - hintEnd->offset0))) {
|
|
error("Linker optimization hint spans multiple sections");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (section != sections.end())
|
|
subsection->isec->optimizationHints = ArrayRef<OptimizationHint>(
|
|
&*hintStart, optimizationHints.end() - hintStart);
|
|
}
|
|
|
|
template <class SectionHeader>
|
|
static bool validateRelocationInfo(InputFile *file, const SectionHeader &sec,
|
|
relocation_info rel) {
|
|
const RelocAttrs &relocAttrs = target->getRelocAttrs(rel.r_type);
|
|
bool valid = true;
|
|
auto message = [relocAttrs, file, sec, rel, &valid](const Twine &diagnostic) {
|
|
valid = false;
|
|
return (relocAttrs.name + " relocation " + diagnostic + " at offset " +
|
|
std::to_string(rel.r_address) + " of " + sec.segname + "," +
|
|
sec.sectname + " in " + toString(file))
|
|
.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) &&
|
|
!relocAttrs.hasAttr(RelocAttrBits::UNSIGNED))
|
|
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))) {
|
|
static SmallVector<StringRef, 4> widths{"0", "4", "8", "4 or 8"};
|
|
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;
|
|
}
|
|
|
|
template <class SectionHeader>
|
|
void ObjFile::parseRelocations(ArrayRef<SectionHeader> sectionHeaders,
|
|
const SectionHeader &sec, Section §ion) {
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
ArrayRef<relocation_info> relInfos(
|
|
reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
|
|
|
|
Subsections &subsections = section.subsections;
|
|
auto subsecIt = subsections.rbegin();
|
|
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
|
|
// datum for each is a symbolic address. The result is the offset
|
|
// between two addresses.
|
|
//
|
|
// 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.
|
|
|
|
relocation_info relInfo = relInfos[i];
|
|
bool isSubtrahend =
|
|
target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND);
|
|
int64_t pairedAddend = 0;
|
|
if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
|
|
pairedAddend = SignExtend64<24>(relInfo.r_symbolnum);
|
|
relInfo = relInfos[++i];
|
|
}
|
|
assert(i < relInfos.size());
|
|
if (!validateRelocationInfo(this, sec, relInfo))
|
|
continue;
|
|
if (relInfo.r_address & R_SCATTERED)
|
|
fatal("TODO: Scattered relocations not supported");
|
|
|
|
int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
|
|
assert(!(embeddedAddend && pairedAddend));
|
|
int64_t totalAddend = pairedAddend + embeddedAddend;
|
|
Reloc r;
|
|
r.type = relInfo.r_type;
|
|
r.pcrel = relInfo.r_pcrel;
|
|
r.length = relInfo.r_length;
|
|
r.offset = relInfo.r_address;
|
|
if (relInfo.r_extern) {
|
|
r.referent = symbols[relInfo.r_symbolnum];
|
|
r.addend = isSubtrahend ? 0 : totalAddend;
|
|
} else {
|
|
assert(!isSubtrahend);
|
|
const SectionHeader &referentSecHead =
|
|
sectionHeaders[relInfo.r_symbolnum - 1];
|
|
uint64_t referentOffset;
|
|
if (relInfo.r_pcrel) {
|
|
// 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
|
|
// that it describes the offset from the start of the referent section.
|
|
// FIXME This logic was written around x86_64 behavior -- ARM64 doesn't
|
|
// have pcrel section relocations. We may want to factor this out into
|
|
// the arch-specific .cpp file.
|
|
assert(target->hasAttr(r.type, RelocAttrBits::BYTE4));
|
|
referentOffset = sec.addr + relInfo.r_address + 4 + totalAddend -
|
|
referentSecHead.addr;
|
|
} else {
|
|
// The addend for a non-pcrel relocation is its absolute address.
|
|
referentOffset = totalAddend - referentSecHead.addr;
|
|
}
|
|
r.referent = findContainingSubsection(*sections[relInfo.r_symbolnum - 1],
|
|
&referentOffset);
|
|
r.addend = referentOffset;
|
|
}
|
|
|
|
// Find the subsection that this relocation belongs to.
|
|
// Though not required by the Mach-O format, clang and gcc seem to emit
|
|
// relocations in order, so let's take advantage of it. However, ld64 emits
|
|
// unsorted relocations (in `-r` mode), so we have a fallback for that
|
|
// uncommon case.
|
|
InputSection *subsec;
|
|
while (subsecIt != subsections.rend() && subsecIt->offset > r.offset)
|
|
++subsecIt;
|
|
if (subsecIt == subsections.rend() ||
|
|
subsecIt->offset + subsecIt->isec->getSize() <= r.offset) {
|
|
subsec = findContainingSubsection(section, &r.offset);
|
|
// Now that we know the relocs are unsorted, avoid trying the 'fast path'
|
|
// for the other relocations.
|
|
subsecIt = subsections.rend();
|
|
} else {
|
|
subsec = subsecIt->isec;
|
|
r.offset -= subsecIt->offset;
|
|
}
|
|
subsec->relocs.push_back(r);
|
|
|
|
if (isSubtrahend) {
|
|
relocation_info minuendInfo = relInfos[++i];
|
|
// SUBTRACTOR relocations should always be followed by an UNSIGNED one
|
|
// attached to the same address.
|
|
assert(target->hasAttr(minuendInfo.r_type, RelocAttrBits::UNSIGNED) &&
|
|
relInfo.r_address == minuendInfo.r_address);
|
|
Reloc p;
|
|
p.type = minuendInfo.r_type;
|
|
if (minuendInfo.r_extern) {
|
|
p.referent = symbols[minuendInfo.r_symbolnum];
|
|
p.addend = totalAddend;
|
|
} else {
|
|
uint64_t referentOffset =
|
|
totalAddend - sectionHeaders[minuendInfo.r_symbolnum - 1].addr;
|
|
p.referent = findContainingSubsection(
|
|
*sections[minuendInfo.r_symbolnum - 1], &referentOffset);
|
|
p.addend = referentOffset;
|
|
}
|
|
subsec->relocs.push_back(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <class NList>
|
|
static macho::Symbol *createDefined(const NList &sym, StringRef name,
|
|
InputSection *isec, uint64_t value,
|
|
uint64_t size) {
|
|
// Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
|
|
// N_EXT: Global symbols. These go in the symbol table during the link,
|
|
// and also in the export table of the output so that the dynamic
|
|
// linker sees them.
|
|
// N_EXT | N_PEXT: Linkage unit (think: dylib) scoped. These go in the
|
|
// symbol table during the link so that duplicates are
|
|
// either reported (for non-weak symbols) or merged
|
|
// (for weak symbols), but they do not go in the export
|
|
// table of the output.
|
|
// N_PEXT: llvm-mc does not emit these, but `ld -r` (wherein ld64 emits
|
|
// object files) may produce them. LLD does not yet support -r.
|
|
// These are translation-unit scoped, identical to the `0` case.
|
|
// 0: Translation-unit scoped. These are not in the symbol table during
|
|
// link, and not in the export table of the output either.
|
|
bool isWeakDefCanBeHidden =
|
|
(sym.n_desc & (N_WEAK_DEF | N_WEAK_REF)) == (N_WEAK_DEF | N_WEAK_REF);
|
|
|
|
if (sym.n_type & N_EXT) {
|
|
bool isPrivateExtern = sym.n_type & N_PEXT;
|
|
// lld's behavior for merging symbols is slightly different from ld64:
|
|
// ld64 picks the winning symbol based on several criteria (see
|
|
// pickBetweenRegularAtoms() in ld64's SymbolTable.cpp), while lld
|
|
// just merges metadata and keeps the contents of the first symbol
|
|
// with that name (see SymbolTable::addDefined). For:
|
|
// * inline function F in a TU built with -fvisibility-inlines-hidden
|
|
// * and inline function F in another TU built without that flag
|
|
// ld64 will pick the one from the file built without
|
|
// -fvisibility-inlines-hidden.
|
|
// lld will instead pick the one listed first on the link command line and
|
|
// give it visibility as if the function was built without
|
|
// -fvisibility-inlines-hidden.
|
|
// If both functions have the same contents, this will have the same
|
|
// behavior. If not, it won't, but the input had an ODR violation in
|
|
// that case.
|
|
//
|
|
// Similarly, merging a symbol
|
|
// that's isPrivateExtern and not isWeakDefCanBeHidden with one
|
|
// that's not isPrivateExtern but isWeakDefCanBeHidden technically
|
|
// should produce one
|
|
// that's not isPrivateExtern but isWeakDefCanBeHidden. That matters
|
|
// with ld64's semantics, because it means the non-private-extern
|
|
// definition will continue to take priority if more private extern
|
|
// definitions are encountered. With lld's semantics there's no observable
|
|
// difference between a symbol that's isWeakDefCanBeHidden(autohide) or one
|
|
// that's privateExtern -- neither makes it into the dynamic symbol table,
|
|
// unless the autohide symbol is explicitly exported.
|
|
// But if a symbol is both privateExtern and autohide then it can't
|
|
// be exported.
|
|
// So we nullify the autohide flag when privateExtern is present
|
|
// and promote the symbol to privateExtern when it is not already.
|
|
if (isWeakDefCanBeHidden && isPrivateExtern)
|
|
isWeakDefCanBeHidden = false;
|
|
else if (isWeakDefCanBeHidden)
|
|
isPrivateExtern = true;
|
|
return symtab->addDefined(
|
|
name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
|
|
isPrivateExtern, sym.n_desc & N_ARM_THUMB_DEF,
|
|
sym.n_desc & REFERENCED_DYNAMICALLY, sym.n_desc & N_NO_DEAD_STRIP,
|
|
isWeakDefCanBeHidden);
|
|
}
|
|
assert(!isWeakDefCanBeHidden &&
|
|
"weak_def_can_be_hidden on already-hidden symbol?");
|
|
bool includeInSymtab =
|
|
!name.startswith("l") && !name.startswith("L") && !isEhFrameSection(isec);
|
|
return make<Defined>(
|
|
name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
|
|
/*isExternal=*/false, /*isPrivateExtern=*/false, includeInSymtab,
|
|
sym.n_desc & N_ARM_THUMB_DEF, sym.n_desc & REFERENCED_DYNAMICALLY,
|
|
sym.n_desc & N_NO_DEAD_STRIP);
|
|
}
|
|
|
|
// Absolute symbols are defined symbols that do not have an associated
|
|
// InputSection. They cannot be weak.
|
|
template <class NList>
|
|
static macho::Symbol *createAbsolute(const NList &sym, InputFile *file,
|
|
StringRef name) {
|
|
if (sym.n_type & N_EXT) {
|
|
return symtab->addDefined(
|
|
name, file, nullptr, sym.n_value, /*size=*/0,
|
|
/*isWeakDef=*/false, sym.n_type & N_PEXT, sym.n_desc & N_ARM_THUMB_DEF,
|
|
/*isReferencedDynamically=*/false, sym.n_desc & N_NO_DEAD_STRIP,
|
|
/*isWeakDefCanBeHidden=*/false);
|
|
}
|
|
return make<Defined>(name, file, nullptr, sym.n_value, /*size=*/0,
|
|
/*isWeakDef=*/false,
|
|
/*isExternal=*/false, /*isPrivateExtern=*/false,
|
|
/*includeInSymtab=*/true, sym.n_desc & N_ARM_THUMB_DEF,
|
|
/*isReferencedDynamically=*/false,
|
|
sym.n_desc & N_NO_DEAD_STRIP);
|
|
}
|
|
|
|
template <class NList>
|
|
macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
|
|
StringRef name) {
|
|
uint8_t type = sym.n_type & N_TYPE;
|
|
switch (type) {
|
|
case N_UNDF:
|
|
return sym.n_value == 0
|
|
? symtab->addUndefined(name, this, sym.n_desc & N_WEAK_REF)
|
|
: symtab->addCommon(name, this, sym.n_value,
|
|
1 << GET_COMM_ALIGN(sym.n_desc),
|
|
sym.n_type & N_PEXT);
|
|
case N_ABS:
|
|
return createAbsolute(sym, this, name);
|
|
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");
|
|
}
|
|
}
|
|
|
|
template <class NList> static bool isUndef(const NList &sym) {
|
|
return (sym.n_type & N_TYPE) == N_UNDF && sym.n_value == 0;
|
|
}
|
|
|
|
template <class LP>
|
|
void ObjFile::parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
|
|
ArrayRef<typename LP::nlist> nList,
|
|
const char *strtab, bool subsectionsViaSymbols) {
|
|
using NList = typename LP::nlist;
|
|
|
|
// Groups indices of the symbols by the sections that contain them.
|
|
std::vector<std::vector<uint32_t>> symbolsBySection(sections.size());
|
|
symbols.resize(nList.size());
|
|
SmallVector<unsigned, 32> undefineds;
|
|
for (uint32_t i = 0; i < nList.size(); ++i) {
|
|
const NList &sym = nList[i];
|
|
|
|
// Ignore debug symbols for now.
|
|
// FIXME: may need special handling.
|
|
if (sym.n_type & N_STAB)
|
|
continue;
|
|
|
|
StringRef name = strtab + sym.n_strx;
|
|
if ((sym.n_type & N_TYPE) == N_SECT) {
|
|
Subsections &subsections = sections[sym.n_sect - 1]->subsections;
|
|
// parseSections() may have chosen not to parse this section.
|
|
if (subsections.empty())
|
|
continue;
|
|
symbolsBySection[sym.n_sect - 1].push_back(i);
|
|
} else if (isUndef(sym)) {
|
|
undefineds.push_back(i);
|
|
} else {
|
|
symbols[i] = parseNonSectionSymbol(sym, name);
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < sections.size(); ++i) {
|
|
Subsections &subsections = sections[i]->subsections;
|
|
if (subsections.empty())
|
|
continue;
|
|
std::vector<uint32_t> &symbolIndices = symbolsBySection[i];
|
|
uint64_t sectionAddr = sectionHeaders[i].addr;
|
|
uint32_t sectionAlign = 1u << sectionHeaders[i].align;
|
|
|
|
// Some sections have already been split into subsections during
|
|
// parseSections(), so we simply need to match Symbols to the corresponding
|
|
// subsection here.
|
|
if (sections[i]->doneSplitting) {
|
|
for (size_t j = 0; j < symbolIndices.size(); ++j) {
|
|
uint32_t symIndex = symbolIndices[j];
|
|
const NList &sym = nList[symIndex];
|
|
StringRef name = strtab + sym.n_strx;
|
|
uint64_t symbolOffset = sym.n_value - sectionAddr;
|
|
InputSection *isec =
|
|
findContainingSubsection(*sections[i], &symbolOffset);
|
|
if (symbolOffset != 0) {
|
|
error(toString(*sections[i]) + ": symbol " + name +
|
|
" at misaligned offset");
|
|
continue;
|
|
}
|
|
symbols[symIndex] = createDefined(sym, name, isec, 0, isec->getSize());
|
|
}
|
|
continue;
|
|
}
|
|
sections[i]->doneSplitting = true;
|
|
|
|
// Calculate symbol sizes and create subsections by splitting the sections
|
|
// along symbol boundaries.
|
|
// We populate subsections by repeatedly splitting the last (highest
|
|
// address) subsection.
|
|
llvm::stable_sort(symbolIndices, [&](uint32_t lhs, uint32_t rhs) {
|
|
return nList[lhs].n_value < nList[rhs].n_value;
|
|
});
|
|
for (size_t j = 0; j < symbolIndices.size(); ++j) {
|
|
uint32_t symIndex = symbolIndices[j];
|
|
const NList &sym = nList[symIndex];
|
|
StringRef name = strtab + sym.n_strx;
|
|
Subsection &subsec = subsections.back();
|
|
InputSection *isec = subsec.isec;
|
|
|
|
uint64_t subsecAddr = sectionAddr + subsec.offset;
|
|
size_t symbolOffset = sym.n_value - subsecAddr;
|
|
uint64_t symbolSize =
|
|
j + 1 < symbolIndices.size()
|
|
? nList[symbolIndices[j + 1]].n_value - sym.n_value
|
|
: isec->data.size() - symbolOffset;
|
|
// There are 4 cases where we do not need to create a new subsection:
|
|
// 1. If the input file does not use subsections-via-symbols.
|
|
// 2. Multiple symbols at the same address only induce one subsection.
|
|
// (The symbolOffset == 0 check covers both this case as well as
|
|
// the first loop iteration.)
|
|
// 3. Alternative entry points do not induce new subsections.
|
|
// 4. If we have a literal section (e.g. __cstring and __literal4).
|
|
if (!subsectionsViaSymbols || symbolOffset == 0 ||
|
|
sym.n_desc & N_ALT_ENTRY || !isa<ConcatInputSection>(isec)) {
|
|
symbols[symIndex] =
|
|
createDefined(sym, name, isec, symbolOffset, symbolSize);
|
|
continue;
|
|
}
|
|
auto *concatIsec = cast<ConcatInputSection>(isec);
|
|
|
|
auto *nextIsec = make<ConcatInputSection>(*concatIsec);
|
|
nextIsec->wasCoalesced = false;
|
|
if (isZeroFill(isec->getFlags())) {
|
|
// Zero-fill sections have NULL data.data() non-zero data.size()
|
|
nextIsec->data = {nullptr, isec->data.size() - symbolOffset};
|
|
isec->data = {nullptr, symbolOffset};
|
|
} else {
|
|
nextIsec->data = isec->data.slice(symbolOffset);
|
|
isec->data = isec->data.slice(0, symbolOffset);
|
|
}
|
|
|
|
// By construction, the symbol will be at offset zero in the new
|
|
// subsection.
|
|
symbols[symIndex] =
|
|
createDefined(sym, name, nextIsec, /*value=*/0, symbolSize);
|
|
// 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.
|
|
nextIsec->align = MinAlign(sectionAlign, sym.n_value);
|
|
subsections.push_back({sym.n_value - sectionAddr, nextIsec});
|
|
}
|
|
}
|
|
|
|
// Undefined symbols can trigger recursive fetch from Archives due to
|
|
// LazySymbols. Process defined symbols first so that the relative order
|
|
// between a defined symbol and an undefined symbol does not change the
|
|
// symbol resolution behavior. In addition, a set of interconnected symbols
|
|
// will all be resolved to the same file, instead of being resolved to
|
|
// different files.
|
|
for (unsigned i : undefineds) {
|
|
const NList &sym = nList[i];
|
|
StringRef name = strtab + sym.n_strx;
|
|
symbols[i] = parseNonSectionSymbol(sym, name);
|
|
}
|
|
}
|
|
|
|
OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
|
|
StringRef sectName)
|
|
: InputFile(OpaqueKind, mb) {
|
|
const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
ArrayRef<uint8_t> data = {buf, mb.getBufferSize()};
|
|
sections.push_back(make<Section>(/*file=*/this, segName.take_front(16),
|
|
sectName.take_front(16),
|
|
/*flags=*/0, /*addr=*/0));
|
|
Section §ion = *sections.back();
|
|
ConcatInputSection *isec = make<ConcatInputSection>(section, data);
|
|
isec->live = true;
|
|
section.subsections.push_back({0, isec});
|
|
}
|
|
|
|
ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName,
|
|
bool lazy)
|
|
: InputFile(ObjKind, mb, lazy), modTime(modTime) {
|
|
this->archiveName = std::string(archiveName);
|
|
if (lazy) {
|
|
if (target->wordSize == 8)
|
|
parseLazy<LP64>();
|
|
else
|
|
parseLazy<ILP32>();
|
|
} else {
|
|
if (target->wordSize == 8)
|
|
parse<LP64>();
|
|
else
|
|
parse<ILP32>();
|
|
}
|
|
}
|
|
|
|
template <class LP> void ObjFile::parse() {
|
|
using Header = typename LP::mach_header;
|
|
using SegmentCommand = typename LP::segment_command;
|
|
using SectionHeader = typename LP::section;
|
|
using NList = typename LP::nlist;
|
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
|
|
|
|
Architecture arch = getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
|
|
if (arch != config->arch()) {
|
|
auto msg = config->errorForArchMismatch
|
|
? static_cast<void (*)(const Twine &)>(error)
|
|
: warn;
|
|
msg(toString(this) + " has architecture " + getArchitectureName(arch) +
|
|
" which is incompatible with target architecture " +
|
|
getArchitectureName(config->arch()));
|
|
return;
|
|
}
|
|
|
|
if (!checkCompatibility(this))
|
|
return;
|
|
|
|
for (auto *cmd : findCommands<linker_option_command>(hdr, LC_LINKER_OPTION)) {
|
|
StringRef data{reinterpret_cast<const char *>(cmd + 1),
|
|
cmd->cmdsize - sizeof(linker_option_command)};
|
|
parseLCLinkerOption(this, cmd->count, data);
|
|
}
|
|
|
|
ArrayRef<SectionHeader> sectionHeaders;
|
|
if (const load_command *cmd = findCommand(hdr, LP::segmentLCType)) {
|
|
auto *c = reinterpret_cast<const SegmentCommand *>(cmd);
|
|
sectionHeaders = ArrayRef<SectionHeader>{
|
|
reinterpret_cast<const SectionHeader *>(c + 1), c->nsects};
|
|
parseSections(sectionHeaders);
|
|
}
|
|
|
|
// TODO: Error on missing LC_SYMTAB?
|
|
if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
|
|
auto *c = reinterpret_cast<const symtab_command *>(cmd);
|
|
ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
|
|
c->nsyms);
|
|
const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
|
|
bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
|
|
parseSymbols<LP>(sectionHeaders, nList, strtab, subsectionsViaSymbols);
|
|
}
|
|
|
|
// The relocations may refer to the symbols, so we parse them after we have
|
|
// parsed all the symbols.
|
|
for (size_t i = 0, n = sections.size(); i < n; ++i)
|
|
if (!sections[i]->subsections.empty())
|
|
parseRelocations(sectionHeaders, sectionHeaders[i], *sections[i]);
|
|
|
|
if (!config->ignoreOptimizationHints)
|
|
if (auto *cmd = findCommand<linkedit_data_command>(
|
|
hdr, LC_LINKER_OPTIMIZATION_HINT))
|
|
parseOptimizationHints({buf + cmd->dataoff, cmd->datasize});
|
|
|
|
parseDebugInfo();
|
|
|
|
Section *ehFrameSection = nullptr;
|
|
Section *compactUnwindSection = nullptr;
|
|
for (Section *sec : sections) {
|
|
Section **s = StringSwitch<Section **>(sec->name)
|
|
.Case(section_names::compactUnwind, &compactUnwindSection)
|
|
.Case(section_names::ehFrame, &ehFrameSection)
|
|
.Default(nullptr);
|
|
if (s)
|
|
*s = sec;
|
|
}
|
|
if (compactUnwindSection)
|
|
registerCompactUnwind(*compactUnwindSection);
|
|
if (ehFrameSection)
|
|
registerEhFrames(*ehFrameSection);
|
|
}
|
|
|
|
template <class LP> void ObjFile::parseLazy() {
|
|
using Header = typename LP::mach_header;
|
|
using NList = typename LP::nlist;
|
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
|
|
const load_command *cmd = findCommand(hdr, LC_SYMTAB);
|
|
if (!cmd)
|
|
return;
|
|
auto *c = reinterpret_cast<const symtab_command *>(cmd);
|
|
ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
|
|
c->nsyms);
|
|
const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
|
|
symbols.resize(nList.size());
|
|
for (auto it : llvm::enumerate(nList)) {
|
|
const NList &sym = it.value();
|
|
if ((sym.n_type & N_EXT) && !isUndef(sym)) {
|
|
// TODO: Bound checking
|
|
StringRef name = strtab + sym.n_strx;
|
|
symbols[it.index()] = symtab->addLazyObject(name, *this);
|
|
if (!lazy)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ObjFile::parseDebugInfo() {
|
|
std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
|
|
if (!dObj)
|
|
return;
|
|
|
|
// We do not re-use the context from getDwarf() here as that function
|
|
// constructs an expensive DWARFCache object.
|
|
auto *ctx = make<DWARFContext>(
|
|
std::move(dObj), "",
|
|
[&](Error err) {
|
|
warn(toString(this) + ": " + toString(std::move(err)));
|
|
},
|
|
[&](Error warning) {
|
|
warn(toString(this) + ": " + toString(std::move(warning)));
|
|
});
|
|
|
|
// 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();
|
|
// FIXME: There can be more than one compile unit per object file. See
|
|
// PR48637.
|
|
auto it = units.begin();
|
|
compileUnit = it != units.end() ? it->get() : nullptr;
|
|
}
|
|
|
|
ArrayRef<data_in_code_entry> ObjFile::getDataInCode() const {
|
|
const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
const load_command *cmd = findCommand(buf, LC_DATA_IN_CODE);
|
|
if (!cmd)
|
|
return {};
|
|
const auto *c = reinterpret_cast<const linkedit_data_command *>(cmd);
|
|
return {reinterpret_cast<const data_in_code_entry *>(buf + c->dataoff),
|
|
c->datasize / sizeof(data_in_code_entry)};
|
|
}
|
|
|
|
// Create pointers from symbols to their associated compact unwind entries.
|
|
void ObjFile::registerCompactUnwind(Section &compactUnwindSection) {
|
|
for (const Subsection &subsection : compactUnwindSection.subsections) {
|
|
ConcatInputSection *isec = cast<ConcatInputSection>(subsection.isec);
|
|
// Hack!! Since each CUE contains a different function address, if ICF
|
|
// operated naively and compared the entire contents of each CUE, entries
|
|
// with identical unwind info but belonging to different functions would
|
|
// never be considered equivalent. To work around this problem, we slice
|
|
// away the function address here. (Note that we do not adjust the offsets
|
|
// of the corresponding relocations.) We rely on `relocateCompactUnwind()`
|
|
// to correctly handle these truncated input sections.
|
|
isec->data = isec->data.slice(target->wordSize);
|
|
uint32_t encoding = read32le(isec->data.data() + sizeof(uint32_t));
|
|
// llvm-mc omits CU entries for functions that need DWARF encoding, but
|
|
// `ld -r` doesn't. We can ignore them because we will re-synthesize these
|
|
// CU entries from the DWARF info during the output phase.
|
|
if ((encoding & target->modeDwarfEncoding) == target->modeDwarfEncoding)
|
|
continue;
|
|
|
|
ConcatInputSection *referentIsec;
|
|
for (auto it = isec->relocs.begin(); it != isec->relocs.end();) {
|
|
Reloc &r = *it;
|
|
// CUE::functionAddress is at offset 0. Skip personality & LSDA relocs.
|
|
if (r.offset != 0) {
|
|
++it;
|
|
continue;
|
|
}
|
|
uint64_t add = r.addend;
|
|
if (auto *sym = cast_or_null<Defined>(r.referent.dyn_cast<Symbol *>())) {
|
|
// Check whether the symbol defined in this file is the prevailing one.
|
|
// Skip if it is e.g. a weak def that didn't prevail.
|
|
if (sym->getFile() != this) {
|
|
++it;
|
|
continue;
|
|
}
|
|
add += sym->value;
|
|
referentIsec = cast<ConcatInputSection>(sym->isec);
|
|
} else {
|
|
referentIsec =
|
|
cast<ConcatInputSection>(r.referent.dyn_cast<InputSection *>());
|
|
}
|
|
// Unwind info lives in __DATA, and finalization of __TEXT will occur
|
|
// before finalization of __DATA. Moreover, the finalization of unwind
|
|
// info depends on the exact addresses that it references. So it is safe
|
|
// for compact unwind to reference addresses in __TEXT, but not addresses
|
|
// in any other segment.
|
|
if (referentIsec->getSegName() != segment_names::text)
|
|
error(isec->getLocation(r.offset) + " references section " +
|
|
referentIsec->getName() + " which is not in segment __TEXT");
|
|
// The functionAddress relocations are typically section relocations.
|
|
// However, unwind info operates on a per-symbol basis, so we search for
|
|
// the function symbol here.
|
|
Defined *d = findSymbolAtOffset(referentIsec, add);
|
|
if (!d) {
|
|
++it;
|
|
continue;
|
|
}
|
|
d->unwindEntry = isec;
|
|
// Since we've sliced away the functionAddress, we should remove the
|
|
// corresponding relocation too. Given that clang emits relocations in
|
|
// reverse order of address, this relocation should be at the end of the
|
|
// vector for most of our input object files, so this is typically an O(1)
|
|
// operation.
|
|
it = isec->relocs.erase(it);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct CIE {
|
|
macho::Symbol *personalitySymbol = nullptr;
|
|
bool fdesHaveLsda = false;
|
|
bool fdesHaveAug = false;
|
|
};
|
|
|
|
static CIE parseCIE(const InputSection *isec, const EhReader &reader,
|
|
size_t off) {
|
|
// Handling the full generality of possible DWARF encodings would be a major
|
|
// pain. We instead take advantage of our knowledge of how llvm-mc encodes
|
|
// DWARF and handle just that.
|
|
constexpr uint8_t expectedPersonalityEnc =
|
|
dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_sdata4;
|
|
constexpr uint8_t expectedPointerEnc =
|
|
dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_absptr;
|
|
|
|
CIE cie;
|
|
uint8_t version = reader.readByte(&off);
|
|
if (version != 1 && version != 3)
|
|
fatal("Expected CIE version of 1 or 3, got " + Twine(version));
|
|
StringRef aug = reader.readString(&off);
|
|
reader.skipLeb128(&off); // skip code alignment
|
|
reader.skipLeb128(&off); // skip data alignment
|
|
reader.skipLeb128(&off); // skip return address register
|
|
reader.skipLeb128(&off); // skip aug data length
|
|
uint64_t personalityAddrOff = 0;
|
|
for (char c : aug) {
|
|
switch (c) {
|
|
case 'z':
|
|
cie.fdesHaveAug = true;
|
|
break;
|
|
case 'P': {
|
|
uint8_t personalityEnc = reader.readByte(&off);
|
|
if (personalityEnc != expectedPersonalityEnc)
|
|
reader.failOn(off, "unexpected personality encoding 0x" +
|
|
Twine::utohexstr(personalityEnc));
|
|
personalityAddrOff = off;
|
|
off += 4;
|
|
break;
|
|
}
|
|
case 'L': {
|
|
cie.fdesHaveLsda = true;
|
|
uint8_t lsdaEnc = reader.readByte(&off);
|
|
if (lsdaEnc != expectedPointerEnc)
|
|
reader.failOn(off, "unexpected LSDA encoding 0x" +
|
|
Twine::utohexstr(lsdaEnc));
|
|
break;
|
|
}
|
|
case 'R': {
|
|
uint8_t pointerEnc = reader.readByte(&off);
|
|
if (pointerEnc != expectedPointerEnc)
|
|
reader.failOn(off, "unexpected pointer encoding 0x" +
|
|
Twine::utohexstr(pointerEnc));
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (personalityAddrOff != 0) {
|
|
auto personalityRelocIt =
|
|
llvm::find_if(isec->relocs, [=](const macho::Reloc &r) {
|
|
return r.offset == personalityAddrOff;
|
|
});
|
|
if (personalityRelocIt == isec->relocs.end())
|
|
reader.failOn(off, "Failed to locate relocation for personality symbol");
|
|
cie.personalitySymbol = personalityRelocIt->referent.get<macho::Symbol *>();
|
|
}
|
|
return cie;
|
|
}
|
|
|
|
// EH frame target addresses may be encoded as pcrel offsets. However, instead
|
|
// of using an actual pcrel reloc, ld64 emits subtractor relocations instead.
|
|
// This function recovers the target address from the subtractors, essentially
|
|
// performing the inverse operation of EhRelocator.
|
|
//
|
|
// Concretely, we expect our relocations to write the value of `PC -
|
|
// target_addr` to `PC`. `PC` itself is denoted by a minuend relocation that
|
|
// points to a symbol plus an addend.
|
|
//
|
|
// It is important that the minuend relocation point to a symbol within the
|
|
// same section as the fixup value, since sections may get moved around.
|
|
//
|
|
// For example, for arm64, llvm-mc emits relocations for the target function
|
|
// address like so:
|
|
//
|
|
// ltmp:
|
|
// <CIE start>
|
|
// ...
|
|
// <CIE end>
|
|
// ... multiple FDEs ...
|
|
// <FDE start>
|
|
// <target function address - (ltmp + pcrel offset)>
|
|
// ...
|
|
//
|
|
// If any of the FDEs in `multiple FDEs` get dead-stripped, then `FDE start`
|
|
// will move to an earlier address, and `ltmp + pcrel offset` will no longer
|
|
// reflect an accurate pcrel value. To avoid this problem, we "canonicalize"
|
|
// our relocation by adding an `EH_Frame` symbol at `FDE start`, and updating
|
|
// the reloc to be `target function address - (EH_Frame + new pcrel offset)`.
|
|
//
|
|
// If `Invert` is set, then we instead expect `target_addr - PC` to be written
|
|
// to `PC`.
|
|
template <bool Invert = false>
|
|
Defined *
|
|
targetSymFromCanonicalSubtractor(const InputSection *isec,
|
|
std::vector<macho::Reloc>::iterator relocIt) {
|
|
macho::Reloc &subtrahend = *relocIt;
|
|
macho::Reloc &minuend = *std::next(relocIt);
|
|
assert(target->hasAttr(subtrahend.type, RelocAttrBits::SUBTRAHEND));
|
|
assert(target->hasAttr(minuend.type, RelocAttrBits::UNSIGNED));
|
|
// Note: pcSym may *not* be exactly at the PC; there's usually a non-zero
|
|
// addend.
|
|
auto *pcSym = cast<Defined>(subtrahend.referent.get<macho::Symbol *>());
|
|
Defined *target =
|
|
cast_or_null<Defined>(minuend.referent.dyn_cast<macho::Symbol *>());
|
|
if (!pcSym) {
|
|
auto *targetIsec =
|
|
cast<ConcatInputSection>(minuend.referent.get<InputSection *>());
|
|
target = findSymbolAtOffset(targetIsec, minuend.addend);
|
|
}
|
|
if (Invert)
|
|
std::swap(pcSym, target);
|
|
if (pcSym->isec == isec) {
|
|
if (pcSym->value - (Invert ? -1 : 1) * minuend.addend != subtrahend.offset)
|
|
fatal("invalid FDE relocation in __eh_frame");
|
|
} else {
|
|
// Ensure the pcReloc points to a symbol within the current EH frame.
|
|
// HACK: we should really verify that the original relocation's semantics
|
|
// are preserved. In particular, we should have
|
|
// `oldSym->value + oldOffset == newSym + newOffset`. However, we don't
|
|
// have an easy way to access the offsets from this point in the code; some
|
|
// refactoring is needed for that.
|
|
macho::Reloc &pcReloc = Invert ? minuend : subtrahend;
|
|
pcReloc.referent = isec->symbols[0];
|
|
assert(isec->symbols[0]->value == 0);
|
|
minuend.addend = pcReloc.offset * (Invert ? 1LL : -1LL);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
Defined *findSymbolAtAddress(const std::vector<Section *> §ions,
|
|
uint64_t addr) {
|
|
Section *sec = findContainingSection(sections, &addr);
|
|
auto *isec = cast<ConcatInputSection>(findContainingSubsection(*sec, &addr));
|
|
return findSymbolAtOffset(isec, addr);
|
|
}
|
|
|
|
// For symbols that don't have compact unwind info, associate them with the more
|
|
// general-purpose (and verbose) DWARF unwind info found in __eh_frame.
|
|
//
|
|
// This requires us to parse the contents of __eh_frame. See EhFrame.h for a
|
|
// description of its format.
|
|
//
|
|
// While parsing, we also look for what MC calls "abs-ified" relocations -- they
|
|
// are relocations which are implicitly encoded as offsets in the section data.
|
|
// We convert them into explicit Reloc structs so that the EH frames can be
|
|
// handled just like a regular ConcatInputSection later in our output phase.
|
|
//
|
|
// We also need to handle the case where our input object file has explicit
|
|
// relocations. This is the case when e.g. it's the output of `ld -r`. We only
|
|
// look for the "abs-ified" relocation if an explicit relocation is absent.
|
|
void ObjFile::registerEhFrames(Section &ehFrameSection) {
|
|
DenseMap<const InputSection *, CIE> cieMap;
|
|
for (const Subsection &subsec : ehFrameSection.subsections) {
|
|
auto *isec = cast<ConcatInputSection>(subsec.isec);
|
|
uint64_t isecOff = subsec.offset;
|
|
|
|
// Subtractor relocs require the subtrahend to be a symbol reloc. Ensure
|
|
// that all EH frames have an associated symbol so that we can generate
|
|
// subtractor relocs that reference them.
|
|
if (isec->symbols.size() == 0)
|
|
isec->symbols.push_back(make<Defined>(
|
|
"EH_Frame", isec->getFile(), isec, /*value=*/0, /*size=*/0,
|
|
/*isWeakDef=*/false, /*isExternal=*/false, /*isPrivateExtern=*/false,
|
|
/*includeInSymtab=*/false, /*isThumb=*/false,
|
|
/*isReferencedDynamically=*/false, /*noDeadStrip=*/false));
|
|
else if (isec->symbols[0]->value != 0)
|
|
fatal("found symbol at unexpected offset in __eh_frame");
|
|
|
|
EhReader reader(this, isec->data, subsec.offset, target->wordSize);
|
|
size_t dataOff = 0; // Offset from the start of the EH frame.
|
|
reader.skipValidLength(&dataOff); // readLength() already validated this.
|
|
// cieOffOff is the offset from the start of the EH frame to the cieOff
|
|
// value, which is itself an offset from the current PC to a CIE.
|
|
const size_t cieOffOff = dataOff;
|
|
|
|
EhRelocator ehRelocator(isec);
|
|
auto cieOffRelocIt = llvm::find_if(
|
|
isec->relocs, [=](const Reloc &r) { return r.offset == cieOffOff; });
|
|
InputSection *cieIsec = nullptr;
|
|
if (cieOffRelocIt != isec->relocs.end()) {
|
|
// We already have an explicit relocation for the CIE offset.
|
|
cieIsec =
|
|
targetSymFromCanonicalSubtractor</*Invert=*/true>(isec, cieOffRelocIt)
|
|
->isec;
|
|
dataOff += sizeof(uint32_t);
|
|
} else {
|
|
// If we haven't found a relocation, then the CIE offset is most likely
|
|
// embedded in the section data (AKA an "abs-ified" reloc.). Parse that
|
|
// and generate a Reloc struct.
|
|
uint32_t cieMinuend = reader.readU32(&dataOff);
|
|
if (cieMinuend == 0)
|
|
cieIsec = isec;
|
|
else {
|
|
uint32_t cieOff = isecOff + dataOff - cieMinuend;
|
|
cieIsec = findContainingSubsection(ehFrameSection, &cieOff);
|
|
if (cieIsec == nullptr)
|
|
fatal("failed to find CIE");
|
|
}
|
|
if (cieIsec != isec)
|
|
ehRelocator.makeNegativePcRel(cieOffOff, cieIsec->symbols[0],
|
|
/*length=*/2);
|
|
}
|
|
if (cieIsec == isec) {
|
|
cieMap[cieIsec] = parseCIE(isec, reader, dataOff);
|
|
continue;
|
|
}
|
|
|
|
// Offset of the function address within the EH frame.
|
|
const size_t funcAddrOff = dataOff;
|
|
uint64_t funcAddr = reader.readPointer(&dataOff) + ehFrameSection.addr +
|
|
isecOff + funcAddrOff;
|
|
uint32_t funcLength = reader.readPointer(&dataOff);
|
|
size_t lsdaAddrOff = 0; // Offset of the LSDA address within the EH frame.
|
|
assert(cieMap.count(cieIsec));
|
|
const CIE &cie = cieMap[cieIsec];
|
|
Optional<uint64_t> lsdaAddrOpt;
|
|
if (cie.fdesHaveAug) {
|
|
reader.skipLeb128(&dataOff);
|
|
lsdaAddrOff = dataOff;
|
|
if (cie.fdesHaveLsda) {
|
|
uint64_t lsdaOff = reader.readPointer(&dataOff);
|
|
if (lsdaOff != 0) // FIXME possible to test this?
|
|
lsdaAddrOpt = ehFrameSection.addr + isecOff + lsdaAddrOff + lsdaOff;
|
|
}
|
|
}
|
|
|
|
auto funcAddrRelocIt = isec->relocs.end();
|
|
auto lsdaAddrRelocIt = isec->relocs.end();
|
|
for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
|
|
if (it->offset == funcAddrOff)
|
|
funcAddrRelocIt = it++; // Found subtrahend; skip over minuend reloc
|
|
else if (lsdaAddrOpt && it->offset == lsdaAddrOff)
|
|
lsdaAddrRelocIt = it++; // Found subtrahend; skip over minuend reloc
|
|
}
|
|
|
|
Defined *funcSym;
|
|
if (funcAddrRelocIt != isec->relocs.end()) {
|
|
funcSym = targetSymFromCanonicalSubtractor(isec, funcAddrRelocIt);
|
|
} else {
|
|
funcSym = findSymbolAtAddress(sections, funcAddr);
|
|
ehRelocator.makePcRel(funcAddrOff, funcSym, target->p2WordSize);
|
|
}
|
|
// The symbol has been coalesced, or already has a compact unwind entry.
|
|
if (!funcSym || funcSym->getFile() != this || funcSym->unwindEntry) {
|
|
// We must prune unused FDEs for correctness, so we cannot rely on
|
|
// -dead_strip being enabled.
|
|
isec->live = false;
|
|
continue;
|
|
}
|
|
|
|
InputSection *lsdaIsec = nullptr;
|
|
if (lsdaAddrRelocIt != isec->relocs.end()) {
|
|
lsdaIsec = targetSymFromCanonicalSubtractor(isec, lsdaAddrRelocIt)->isec;
|
|
} else if (lsdaAddrOpt) {
|
|
uint64_t lsdaAddr = *lsdaAddrOpt;
|
|
Section *sec = findContainingSection(sections, &lsdaAddr);
|
|
lsdaIsec =
|
|
cast<ConcatInputSection>(findContainingSubsection(*sec, &lsdaAddr));
|
|
ehRelocator.makePcRel(lsdaAddrOff, lsdaIsec, target->p2WordSize);
|
|
}
|
|
|
|
fdes[isec] = {funcLength, cie.personalitySymbol, lsdaIsec};
|
|
funcSym->unwindEntry = isec;
|
|
ehRelocator.commit();
|
|
}
|
|
}
|
|
|
|
std::string ObjFile::sourceFile() const {
|
|
SmallString<261> dir(compileUnit->getCompilationDir());
|
|
StringRef sep = sys::path::get_separator();
|
|
// We don't use `path::append` here because we want an empty `dir` to result
|
|
// in an absolute path. `append` would give us a relative path for that case.
|
|
if (!dir.endswith(sep))
|
|
dir += sep;
|
|
return (dir + compileUnit->getUnitDIE().getShortName()).str();
|
|
}
|
|
|
|
lld::DWARFCache *ObjFile::getDwarf() {
|
|
llvm::call_once(initDwarf, [this]() {
|
|
auto dwObj = DwarfObject::create(this);
|
|
if (!dwObj)
|
|
return;
|
|
dwarfCache = std::make_unique<DWARFCache>(std::make_unique<DWARFContext>(
|
|
std::move(dwObj), "",
|
|
[&](Error err) { warn(getName() + ": " + toString(std::move(err))); },
|
|
[&](Error warning) {
|
|
warn(getName() + ": " + toString(std::move(warning)));
|
|
}));
|
|
});
|
|
|
|
return dwarfCache.get();
|
|
}
|
|
// The path can point to either a dylib or a .tbd file.
|
|
static DylibFile *loadDylib(StringRef path, DylibFile *umbrella) {
|
|
Optional<MemoryBufferRef> mbref = readFile(path);
|
|
if (!mbref) {
|
|
error("could not read dylib file at " + path);
|
|
return nullptr;
|
|
}
|
|
return loadDylib(*mbref, umbrella);
|
|
}
|
|
|
|
// 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 in
|
|
// currentTopLevelTapi. 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.
|
|
//
|
|
// Re-exports can either refer to on-disk files, or to documents within .tbd
|
|
// files.
|
|
static DylibFile *findDylib(StringRef path, DylibFile *umbrella,
|
|
const InterfaceFile *currentTopLevelTapi) {
|
|
// Search order:
|
|
// 1. Install name basename in -F / -L directories.
|
|
{
|
|
StringRef stem = path::stem(path);
|
|
SmallString<128> frameworkName;
|
|
path::append(frameworkName, path::Style::posix, stem + ".framework", stem);
|
|
bool isFramework = path.endswith(frameworkName);
|
|
if (isFramework) {
|
|
for (StringRef dir : config->frameworkSearchPaths) {
|
|
SmallString<128> candidate = dir;
|
|
path::append(candidate, frameworkName);
|
|
if (Optional<StringRef> dylibPath = resolveDylibPath(candidate.str()))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
}
|
|
} else if (Optional<StringRef> dylibPath = findPathCombination(
|
|
stem, config->librarySearchPaths, {".tbd", ".dylib"}))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
}
|
|
|
|
// 2. As absolute path.
|
|
if (path::is_absolute(path, path::Style::posix))
|
|
for (StringRef root : config->systemLibraryRoots)
|
|
if (Optional<StringRef> dylibPath = resolveDylibPath((root + path).str()))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
|
|
// 3. As relative path.
|
|
|
|
// TODO: Handle -dylib_file
|
|
|
|
// Replace @executable_path, @loader_path, @rpath prefixes in install name.
|
|
SmallString<128> newPath;
|
|
if (config->outputType == MH_EXECUTE &&
|
|
path.consume_front("@executable_path/")) {
|
|
// ld64 allows overriding this with the undocumented flag -executable_path.
|
|
// lld doesn't currently implement that flag.
|
|
// FIXME: Consider using finalOutput instead of outputFile.
|
|
path::append(newPath, path::parent_path(config->outputFile), path);
|
|
path = newPath;
|
|
} else if (path.consume_front("@loader_path/")) {
|
|
fs::real_path(umbrella->getName(), newPath);
|
|
path::remove_filename(newPath);
|
|
path::append(newPath, path);
|
|
path = newPath;
|
|
} else if (path.startswith("@rpath/")) {
|
|
for (StringRef rpath : umbrella->rpaths) {
|
|
newPath.clear();
|
|
if (rpath.consume_front("@loader_path/")) {
|
|
fs::real_path(umbrella->getName(), newPath);
|
|
path::remove_filename(newPath);
|
|
}
|
|
path::append(newPath, rpath, path.drop_front(strlen("@rpath/")));
|
|
if (Optional<StringRef> dylibPath = resolveDylibPath(newPath.str()))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
}
|
|
}
|
|
|
|
// FIXME: Should this be further up?
|
|
if (currentTopLevelTapi) {
|
|
for (InterfaceFile &child :
|
|
make_pointee_range(currentTopLevelTapi->documents())) {
|
|
assert(child.documents().empty());
|
|
if (path == child.getInstallName()) {
|
|
auto file = make<DylibFile>(child, umbrella, /*isBundleLoader=*/false,
|
|
/*explicitlyLinked=*/false);
|
|
file->parseReexports(child);
|
|
return file;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Optional<StringRef> dylibPath = resolveDylibPath(path))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// 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;
|
|
|
|
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;
|
|
}
|
|
|
|
static void loadReexport(StringRef path, DylibFile *umbrella,
|
|
const InterfaceFile *currentTopLevelTapi) {
|
|
DylibFile *reexport = findDylib(path, umbrella, currentTopLevelTapi);
|
|
if (!reexport)
|
|
error("unable to locate re-export with install name " + path);
|
|
}
|
|
|
|
DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
|
|
bool isBundleLoader, bool explicitlyLinked)
|
|
: InputFile(DylibKind, mb), refState(RefState::Unreferenced),
|
|
explicitlyLinked(explicitlyLinked), isBundleLoader(isBundleLoader) {
|
|
assert(!isBundleLoader || !umbrella);
|
|
if (umbrella == nullptr)
|
|
umbrella = this;
|
|
this->umbrella = umbrella;
|
|
|
|
auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
|
|
|
|
// Initialize installName.
|
|
if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
|
|
auto *c = reinterpret_cast<const dylib_command *>(cmd);
|
|
currentVersion = read32le(&c->dylib.current_version);
|
|
compatibilityVersion = read32le(&c->dylib.compatibility_version);
|
|
installName =
|
|
reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
|
|
} else if (!isBundleLoader) {
|
|
// macho_executable and macho_bundle don't have LC_ID_DYLIB,
|
|
// so it's OK.
|
|
error("dylib " + toString(this) + " missing LC_ID_DYLIB load command");
|
|
return;
|
|
}
|
|
|
|
if (config->printEachFile)
|
|
message(toString(this));
|
|
inputFiles.insert(this);
|
|
|
|
deadStrippable = hdr->flags & MH_DEAD_STRIPPABLE_DYLIB;
|
|
|
|
if (!checkCompatibility(this))
|
|
return;
|
|
|
|
checkAppExtensionSafety(hdr->flags & MH_APP_EXTENSION_SAFE);
|
|
|
|
for (auto *cmd : findCommands<rpath_command>(hdr, LC_RPATH)) {
|
|
StringRef rpath{reinterpret_cast<const char *>(cmd) + cmd->path};
|
|
rpaths.push_back(rpath);
|
|
}
|
|
|
|
// Initialize symbols.
|
|
exportingFile = isImplicitlyLinked(installName) ? this : this->umbrella;
|
|
|
|
const auto *dyldInfo = findCommand<dyld_info_command>(hdr, LC_DYLD_INFO_ONLY);
|
|
const auto *exportsTrie =
|
|
findCommand<linkedit_data_command>(hdr, LC_DYLD_EXPORTS_TRIE);
|
|
if (dyldInfo && exportsTrie) {
|
|
// It's unclear what should happen in this case. Maybe we should only error
|
|
// out if the two load commands refer to different data?
|
|
error("dylib " + toString(this) +
|
|
" has both LC_DYLD_INFO_ONLY and LC_DYLD_EXPORTS_TRIE");
|
|
return;
|
|
} else if (dyldInfo) {
|
|
parseExportedSymbols(dyldInfo->export_off, dyldInfo->export_size);
|
|
} else if (exportsTrie) {
|
|
parseExportedSymbols(exportsTrie->dataoff, exportsTrie->datasize);
|
|
} else {
|
|
error("No LC_DYLD_INFO_ONLY or LC_DYLD_EXPORTS_TRIE found in " +
|
|
toString(this));
|
|
return;
|
|
}
|
|
}
|
|
|
|
void DylibFile::parseExportedSymbols(uint32_t offset, uint32_t size) {
|
|
struct TrieEntry {
|
|
StringRef name;
|
|
uint64_t flags;
|
|
};
|
|
|
|
auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
std::vector<TrieEntry> entries;
|
|
// Find all the $ld$* symbols to process first.
|
|
parseTrie(buf + offset, size, [&](const Twine &name, uint64_t flags) {
|
|
StringRef savedName = saver().save(name);
|
|
if (handleLDSymbol(savedName))
|
|
return;
|
|
entries.push_back({savedName, flags});
|
|
});
|
|
|
|
// Process the "normal" symbols.
|
|
for (TrieEntry &entry : entries) {
|
|
if (exportingFile->hiddenSymbols.contains(CachedHashStringRef(entry.name)))
|
|
continue;
|
|
|
|
bool isWeakDef = entry.flags & EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
|
|
bool isTlv = entry.flags & EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL;
|
|
|
|
symbols.push_back(
|
|
symtab->addDylib(entry.name, exportingFile, isWeakDef, isTlv));
|
|
}
|
|
}
|
|
|
|
void DylibFile::parseLoadCommands(MemoryBufferRef mb) {
|
|
auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
|
|
const uint8_t *p = reinterpret_cast<const uint8_t *>(mb.getBufferStart()) +
|
|
target->headerSize;
|
|
for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
|
|
auto *cmd = reinterpret_cast<const load_command *>(p);
|
|
p += cmd->cmdsize;
|
|
|
|
if (!(hdr->flags & MH_NO_REEXPORTED_DYLIBS) &&
|
|
cmd->cmd == LC_REEXPORT_DYLIB) {
|
|
const auto *c = reinterpret_cast<const dylib_command *>(cmd);
|
|
StringRef reexportPath =
|
|
reinterpret_cast<const char *>(c) + read32le(&c->dylib.name);
|
|
loadReexport(reexportPath, exportingFile, nullptr);
|
|
}
|
|
|
|
// FIXME: What about LC_LOAD_UPWARD_DYLIB, LC_LAZY_LOAD_DYLIB,
|
|
// LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB (..are reexports from dylibs with
|
|
// MH_NO_REEXPORTED_DYLIBS loaded for -flat_namespace)?
|
|
if (config->namespaceKind == NamespaceKind::flat &&
|
|
cmd->cmd == LC_LOAD_DYLIB) {
|
|
const auto *c = reinterpret_cast<const dylib_command *>(cmd);
|
|
StringRef dylibPath =
|
|
reinterpret_cast<const char *>(c) + read32le(&c->dylib.name);
|
|
DylibFile *dylib = findDylib(dylibPath, umbrella, nullptr);
|
|
if (!dylib)
|
|
error(Twine("unable to locate library '") + dylibPath +
|
|
"' loaded from '" + toString(this) + "' for -flat_namespace");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Some versions of Xcode ship with .tbd files that don't have the right
|
|
// platform settings.
|
|
constexpr std::array<StringRef, 3> skipPlatformChecks{
|
|
"/usr/lib/system/libsystem_kernel.dylib",
|
|
"/usr/lib/system/libsystem_platform.dylib",
|
|
"/usr/lib/system/libsystem_pthread.dylib"};
|
|
|
|
static bool skipPlatformCheckForCatalyst(const InterfaceFile &interface,
|
|
bool explicitlyLinked) {
|
|
// Catalyst outputs can link against implicitly linked macOS-only libraries.
|
|
if (config->platform() != PLATFORM_MACCATALYST || explicitlyLinked)
|
|
return false;
|
|
return is_contained(interface.targets(),
|
|
MachO::Target(config->arch(), PLATFORM_MACOS));
|
|
}
|
|
|
|
DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
|
|
bool isBundleLoader, bool explicitlyLinked)
|
|
: InputFile(DylibKind, interface), refState(RefState::Unreferenced),
|
|
explicitlyLinked(explicitlyLinked), isBundleLoader(isBundleLoader) {
|
|
// FIXME: Add test for the missing TBD code path.
|
|
|
|
if (umbrella == nullptr)
|
|
umbrella = this;
|
|
this->umbrella = umbrella;
|
|
|
|
installName = saver().save(interface.getInstallName());
|
|
compatibilityVersion = interface.getCompatibilityVersion().rawValue();
|
|
currentVersion = interface.getCurrentVersion().rawValue();
|
|
|
|
if (config->printEachFile)
|
|
message(toString(this));
|
|
inputFiles.insert(this);
|
|
|
|
if (!is_contained(skipPlatformChecks, installName) &&
|
|
!is_contained(interface.targets(), config->platformInfo.target) &&
|
|
!skipPlatformCheckForCatalyst(interface, explicitlyLinked)) {
|
|
error(toString(this) + " is incompatible with " +
|
|
std::string(config->platformInfo.target));
|
|
return;
|
|
}
|
|
|
|
checkAppExtensionSafety(interface.isApplicationExtensionSafe());
|
|
|
|
exportingFile = isImplicitlyLinked(installName) ? this : umbrella;
|
|
auto addSymbol = [&](const Twine &name) -> void {
|
|
StringRef savedName = saver().save(name);
|
|
if (exportingFile->hiddenSymbols.contains(CachedHashStringRef(savedName)))
|
|
return;
|
|
|
|
symbols.push_back(symtab->addDylib(savedName, exportingFile,
|
|
/*isWeakDef=*/false,
|
|
/*isTlv=*/false));
|
|
};
|
|
|
|
std::vector<const llvm::MachO::Symbol *> normalSymbols;
|
|
normalSymbols.reserve(interface.symbolsCount());
|
|
for (const auto *symbol : interface.symbols()) {
|
|
if (!symbol->getArchitectures().has(config->arch()))
|
|
continue;
|
|
if (handleLDSymbol(symbol->getName()))
|
|
continue;
|
|
|
|
switch (symbol->getKind()) {
|
|
case SymbolKind::GlobalSymbol: // Fallthrough
|
|
case SymbolKind::ObjectiveCClass: // Fallthrough
|
|
case SymbolKind::ObjectiveCClassEHType: // Fallthrough
|
|
case SymbolKind::ObjectiveCInstanceVariable: // Fallthrough
|
|
normalSymbols.push_back(symbol);
|
|
}
|
|
}
|
|
|
|
// TODO(compnerd) filter out symbols based on the target platform
|
|
// TODO: handle weak defs, thread locals
|
|
for (const auto *symbol : normalSymbols) {
|
|
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.
|
|
addSymbol(objc::klass + symbol->getName());
|
|
addSymbol(objc::metaclass + symbol->getName());
|
|
break;
|
|
case SymbolKind::ObjectiveCClassEHType:
|
|
addSymbol(objc::ehtype + symbol->getName());
|
|
break;
|
|
case SymbolKind::ObjectiveCInstanceVariable:
|
|
addSymbol(objc::ivar + symbol->getName());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DylibFile::parseReexports(const InterfaceFile &interface) {
|
|
const InterfaceFile *topLevel =
|
|
interface.getParent() == nullptr ? &interface : interface.getParent();
|
|
for (const InterfaceFileRef &intfRef : interface.reexportedLibraries()) {
|
|
InterfaceFile::const_target_range targets = intfRef.targets();
|
|
if (is_contained(skipPlatformChecks, intfRef.getInstallName()) ||
|
|
is_contained(targets, config->platformInfo.target))
|
|
loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
|
|
}
|
|
}
|
|
|
|
// $ld$ symbols modify the properties/behavior of the library (e.g. its install
|
|
// name, compatibility version or hide/add symbols) for specific target
|
|
// versions.
|
|
bool DylibFile::handleLDSymbol(StringRef originalName) {
|
|
if (!originalName.startswith("$ld$"))
|
|
return false;
|
|
|
|
StringRef action;
|
|
StringRef name;
|
|
std::tie(action, name) = originalName.drop_front(strlen("$ld$")).split('$');
|
|
if (action == "previous")
|
|
handleLDPreviousSymbol(name, originalName);
|
|
else if (action == "install_name")
|
|
handleLDInstallNameSymbol(name, originalName);
|
|
else if (action == "hide")
|
|
handleLDHideSymbol(name, originalName);
|
|
return true;
|
|
}
|
|
|
|
void DylibFile::handleLDPreviousSymbol(StringRef name, StringRef originalName) {
|
|
// originalName: $ld$ previous $ <installname> $ <compatversion> $
|
|
// <platformstr> $ <startversion> $ <endversion> $ <symbol-name> $
|
|
StringRef installName;
|
|
StringRef compatVersion;
|
|
StringRef platformStr;
|
|
StringRef startVersion;
|
|
StringRef endVersion;
|
|
StringRef symbolName;
|
|
StringRef rest;
|
|
|
|
std::tie(installName, name) = name.split('$');
|
|
std::tie(compatVersion, name) = name.split('$');
|
|
std::tie(platformStr, name) = name.split('$');
|
|
std::tie(startVersion, name) = name.split('$');
|
|
std::tie(endVersion, name) = name.split('$');
|
|
std::tie(symbolName, rest) = name.split('$');
|
|
// TODO: ld64 contains some logic for non-empty symbolName as well.
|
|
if (!symbolName.empty())
|
|
return;
|
|
unsigned platform;
|
|
if (platformStr.getAsInteger(10, platform) ||
|
|
platform != static_cast<unsigned>(config->platform()))
|
|
return;
|
|
|
|
VersionTuple start;
|
|
if (start.tryParse(startVersion)) {
|
|
warn("failed to parse start version, symbol '" + originalName +
|
|
"' ignored");
|
|
return;
|
|
}
|
|
VersionTuple end;
|
|
if (end.tryParse(endVersion)) {
|
|
warn("failed to parse end version, symbol '" + originalName + "' ignored");
|
|
return;
|
|
}
|
|
if (config->platformInfo.minimum < start ||
|
|
config->platformInfo.minimum >= end)
|
|
return;
|
|
|
|
this->installName = saver().save(installName);
|
|
|
|
if (!compatVersion.empty()) {
|
|
VersionTuple cVersion;
|
|
if (cVersion.tryParse(compatVersion)) {
|
|
warn("failed to parse compatibility version, symbol '" + originalName +
|
|
"' ignored");
|
|
return;
|
|
}
|
|
compatibilityVersion = encodeVersion(cVersion);
|
|
}
|
|
}
|
|
|
|
void DylibFile::handleLDInstallNameSymbol(StringRef name,
|
|
StringRef originalName) {
|
|
// originalName: $ld$ install_name $ os<version> $ install_name
|
|
StringRef condition, installName;
|
|
std::tie(condition, installName) = name.split('$');
|
|
VersionTuple version;
|
|
if (!condition.consume_front("os") || version.tryParse(condition))
|
|
warn("failed to parse os version, symbol '" + originalName + "' ignored");
|
|
else if (version == config->platformInfo.minimum)
|
|
this->installName = saver().save(installName);
|
|
}
|
|
|
|
void DylibFile::handleLDHideSymbol(StringRef name, StringRef originalName) {
|
|
StringRef symbolName;
|
|
bool shouldHide = true;
|
|
if (name.startswith("os")) {
|
|
// If it's hidden based on versions.
|
|
name = name.drop_front(2);
|
|
StringRef minVersion;
|
|
std::tie(minVersion, symbolName) = name.split('$');
|
|
VersionTuple versionTup;
|
|
if (versionTup.tryParse(minVersion)) {
|
|
warn("Failed to parse hidden version, symbol `" + originalName +
|
|
"` ignored.");
|
|
return;
|
|
}
|
|
shouldHide = versionTup == config->platformInfo.minimum;
|
|
} else {
|
|
symbolName = name;
|
|
}
|
|
|
|
if (shouldHide)
|
|
exportingFile->hiddenSymbols.insert(CachedHashStringRef(symbolName));
|
|
}
|
|
|
|
void DylibFile::checkAppExtensionSafety(bool dylibIsAppExtensionSafe) const {
|
|
if (config->applicationExtension && !dylibIsAppExtensionSafe)
|
|
warn("using '-application_extension' with unsafe dylib: " + toString(this));
|
|
}
|
|
|
|
ArchiveFile::ArchiveFile(std::unique_ptr<object::Archive> &&f)
|
|
: InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {}
|
|
|
|
void ArchiveFile::addLazySymbols() {
|
|
for (const object::Archive::Symbol &sym : file->symbols())
|
|
symtab->addLazyArchive(sym.getName(), this, sym);
|
|
}
|
|
|
|
static Expected<InputFile *> loadArchiveMember(MemoryBufferRef mb,
|
|
uint32_t modTime,
|
|
StringRef archiveName,
|
|
uint64_t offsetInArchive) {
|
|
if (config->zeroModTime)
|
|
modTime = 0;
|
|
|
|
switch (identify_magic(mb.getBuffer())) {
|
|
case file_magic::macho_object:
|
|
return make<ObjFile>(mb, modTime, archiveName);
|
|
case file_magic::bitcode:
|
|
return make<BitcodeFile>(mb, archiveName, offsetInArchive);
|
|
default:
|
|
return createStringError(inconvertibleErrorCode(),
|
|
mb.getBufferIdentifier() +
|
|
" has unhandled file type");
|
|
}
|
|
}
|
|
|
|
Error ArchiveFile::fetch(const object::Archive::Child &c, StringRef reason) {
|
|
if (!seen.insert(c.getChildOffset()).second)
|
|
return Error::success();
|
|
|
|
Expected<MemoryBufferRef> mb = c.getMemoryBufferRef();
|
|
if (!mb)
|
|
return mb.takeError();
|
|
|
|
// Thin archives refer to .o files, so --reproduce needs the .o files too.
|
|
if (tar && c.getParent()->isThin())
|
|
tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb->getBuffer());
|
|
|
|
Expected<TimePoint<std::chrono::seconds>> modTime = c.getLastModified();
|
|
if (!modTime)
|
|
return modTime.takeError();
|
|
|
|
Expected<InputFile *> file =
|
|
loadArchiveMember(*mb, toTimeT(*modTime), getName(), c.getChildOffset());
|
|
|
|
if (!file)
|
|
return file.takeError();
|
|
|
|
inputFiles.insert(*file);
|
|
printArchiveMemberLoad(reason, *file);
|
|
return Error::success();
|
|
}
|
|
|
|
void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
|
|
object::Archive::Child c =
|
|
CHECK(sym.getMember(), toString(this) +
|
|
": could not get the member defining symbol " +
|
|
toMachOString(sym));
|
|
|
|
// `sym` is owned by a LazySym, which will be replace<>()d 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 symCopy = sym;
|
|
|
|
// ld64 doesn't demangle sym here even with -demangle.
|
|
// Match that: intentionally don't call toMachOString().
|
|
if (Error e = fetch(c, symCopy.getName()))
|
|
error(toString(this) + ": could not get the member defining symbol " +
|
|
toMachOString(symCopy) + ": " + toString(std::move(e)));
|
|
}
|
|
|
|
static macho::Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &objSym,
|
|
BitcodeFile &file) {
|
|
StringRef name = saver().save(objSym.getName());
|
|
|
|
if (objSym.isUndefined())
|
|
return symtab->addUndefined(name, &file, /*isWeakRef=*/objSym.isWeak());
|
|
|
|
// 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;
|
|
}
|
|
isPrivateExtern = isPrivateExtern || objSym.canBeOmittedFromSymbolTable();
|
|
|
|
if (objSym.isCommon())
|
|
return symtab->addCommon(name, &file, objSym.getCommonSize(),
|
|
objSym.getCommonAlignment(), isPrivateExtern);
|
|
|
|
return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
|
|
/*size=*/0, objSym.isWeak(), isPrivateExtern,
|
|
/*isThumb=*/false,
|
|
/*isReferencedDynamically=*/false,
|
|
/*noDeadStrip=*/false,
|
|
/*isWeakDefCanBeHidden=*/false);
|
|
}
|
|
|
|
BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
|
|
uint64_t offsetInArchive, bool lazy)
|
|
: InputFile(BitcodeKind, mb, lazy) {
|
|
this->archiveName = std::string(archiveName);
|
|
std::string path = mb.getBufferIdentifier().str();
|
|
// ThinLTO assumes that all MemoryBufferRefs given to it have a unique
|
|
// name. If two members with the same name are provided, this causes a
|
|
// collision and ThinLTO can't proceed.
|
|
// So, we append the archive name to disambiguate two members with the same
|
|
// name from multiple different archives, and offset within the archive to
|
|
// disambiguate two members of the same name from a single archive.
|
|
MemoryBufferRef mbref(mb.getBuffer(),
|
|
saver().save(archiveName.empty()
|
|
? path
|
|
: archiveName +
|
|
sys::path::filename(path) +
|
|
utostr(offsetInArchive)));
|
|
|
|
obj = check(lto::InputFile::create(mbref));
|
|
if (lazy)
|
|
parseLazy();
|
|
else
|
|
parse();
|
|
}
|
|
|
|
void BitcodeFile::parse() {
|
|
// Convert LTO Symbols to LLD Symbols in order to perform resolution. The
|
|
// "winning" symbol will then be marked as Prevailing at LTO compilation
|
|
// time.
|
|
symbols.clear();
|
|
for (const lto::InputFile::Symbol &objSym : obj->symbols())
|
|
symbols.push_back(createBitcodeSymbol(objSym, *this));
|
|
}
|
|
|
|
void BitcodeFile::parseLazy() {
|
|
symbols.resize(obj->symbols().size());
|
|
for (auto it : llvm::enumerate(obj->symbols())) {
|
|
const lto::InputFile::Symbol &objSym = it.value();
|
|
if (!objSym.isUndefined()) {
|
|
symbols[it.index()] =
|
|
symtab->addLazyObject(saver().save(objSym.getName()), *this);
|
|
if (!lazy)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void macho::extract(InputFile &file, StringRef reason) {
|
|
assert(file.lazy);
|
|
file.lazy = false;
|
|
printArchiveMemberLoad(reason, &file);
|
|
if (auto *bitcode = dyn_cast<BitcodeFile>(&file)) {
|
|
bitcode->parse();
|
|
} else {
|
|
auto &f = cast<ObjFile>(file);
|
|
if (target->wordSize == 8)
|
|
f.parse<LP64>();
|
|
else
|
|
f.parse<ILP32>();
|
|
}
|
|
}
|
|
|
|
template void ObjFile::parse<LP64>();
|