6736bce6db
If we have two files with the same weak symbol like so: ``` ltmp0: _weak: <contents> ``` and ``` ltmp1: _weak: <contents> ``` Linking them together should leave only one copy of `<contents>`, not two. Previously, we would keep around both copies because of the private-label `ltmp<N>` symbols (i.e. symbols that start with `l`) -- we would not coalesce those, so we would treat them as retaining the contents. This matters for more than just size -- we are depending upon this behavior internally for emitting a certain file format. This file format's header is repeated in each object file, but we want it to appear just once in our output. Why can't we not emit those aliases to `_weak`, or reference the `ltmp<N>` symbols instead of `_weak`? Well, MC actually adds `ltmp<N>` symbols as part of the assembly-to-binary translation step. So any codegen at the clang level can't access them. All that said... this solution is actually kind of hacky. Here, we avoid creating the private-label symbols at parse time. This is acceptable since we never emit those symbols in our output. However, in ld64, any aliasing temporary symbols (ignored or otherwise) won't retain coalesced data. But implementing this is harder -- we would have to create those symbols first (so we can emit their names later), but we would have to ensure the linker correctly shuffles them around when their aliasees get coalesced. Additionally, ld64 treats these temporary symbols as functionally equivalent to the weak symbols themselves -- that is, it will emit weak binds when those non-weak temporary aliases are referenced. We have imitated this behavior for private-label symbols, but implementing it for local aliases in general seems substantially more difficult. I'm not sure if any programs actually depend on this behavior though, so maybe it's a moot point. Finally, ld64 does all this regardless of whether `.subsections_via_symbols` is specified. We don't. But again, given how rare the lack of that directive is (I've only seen it from hand-written assembly inputs), I don't think we need to worry about it. Reviewed By: #lld-macho, oontvoo Differential Revision: https://reviews.llvm.org/D139069
2253 lines
90 KiB
C++
2253 lines
90 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 <optional>
|
|
#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.
|
|
std::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 std::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->dedupLiterals)
|
|
return {};
|
|
|
|
if (name == section_names::cfString && segname == segment_names::data)
|
|
return target->wordSize == 8 ? 32 : 16;
|
|
|
|
if (config->icfLevel == ICFLevel::none)
|
|
return {};
|
|
|
|
if (name == section_names::objcClassRefs && segname == segment_names::data)
|
|
return target->wordSize;
|
|
|
|
if (name == section_names::objcSelrefs && 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,
|
|
/*dedupLiterals=*/name ==
|
|
section_names::objcMethname ||
|
|
config->dedupLiterals);
|
|
// 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::objCImageInfo &&
|
|
segname == segment_names::data) {
|
|
objCImageInfo = data;
|
|
} 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);
|
|
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;
|
|
}
|
|
|
|
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
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Symbols with `l` or `L` as a prefix are linker-private and never appear in
|
|
// the output.
|
|
static bool isPrivateLabel(StringRef name) {
|
|
return name.startswith("l") || name.startswith("L");
|
|
}
|
|
|
|
template <class NList>
|
|
static macho::Symbol *createDefined(const NList &sym, StringRef name,
|
|
InputSection *isec, uint64_t value,
|
|
uint64_t size, bool forceHidden) {
|
|
// 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) {
|
|
// -load_hidden makes us treat global symbols as linkage unit scoped.
|
|
// Duplicates are reported but the symbol does not go in the export trie.
|
|
bool isPrivateExtern = sym.n_type & N_PEXT || forceHidden;
|
|
|
|
// 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 = !isPrivateLabel(name) && !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, bool forceHidden) {
|
|
if (sym.n_type & N_EXT) {
|
|
bool isPrivateExtern = sym.n_type & N_PEXT || forceHidden;
|
|
return symtab->addDefined(
|
|
name, file, nullptr, sym.n_value, /*size=*/0,
|
|
/*isWeakDef=*/false, isPrivateExtern, 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,
|
|
const char *strtab) {
|
|
StringRef name = StringRef(strtab + sym.n_strx);
|
|
uint8_t type = sym.n_type & N_TYPE;
|
|
bool isPrivateExtern = sym.n_type & N_PEXT || forceHidden;
|
|
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),
|
|
isPrivateExtern);
|
|
case N_ABS:
|
|
return createAbsolute(sym, this, name, forceHidden);
|
|
case N_INDR: {
|
|
// Not much point in making local aliases -- relocs in the current file can
|
|
// just refer to the actual symbol itself. ld64 ignores these symbols too.
|
|
if (!(sym.n_type & N_EXT))
|
|
return nullptr;
|
|
StringRef aliasedName = StringRef(strtab + sym.n_value);
|
|
// isPrivateExtern is the only symbol flag that has an impact on the final
|
|
// aliased symbol.
|
|
auto alias = make<AliasSymbol>(this, name, aliasedName, isPrivateExtern);
|
|
aliases.push_back(alias);
|
|
return alias;
|
|
}
|
|
case N_PBUD:
|
|
error("TODO: support symbols of type N_PBUD");
|
|
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;
|
|
|
|
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, strtab);
|
|
}
|
|
}
|
|
|
|
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) {
|
|
const 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(), forceHidden);
|
|
}
|
|
continue;
|
|
}
|
|
sections[i]->doneSplitting = true;
|
|
|
|
auto getSymName = [strtab](const NList& sym) -> StringRef {
|
|
return StringRef(strtab + sym.n_strx);
|
|
};
|
|
|
|
// 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) {
|
|
// Put private-label symbols after other symbols at the same address.
|
|
if (nList[lhs].n_value == nList[rhs].n_value)
|
|
return !isPrivateLabel(getSymName(nList[lhs])) &&
|
|
isPrivateLabel(getSymName(nList[rhs]));
|
|
return nList[lhs].n_value < nList[rhs].n_value;
|
|
});
|
|
for (size_t j = 0; j < symbolIndices.size(); ++j) {
|
|
const uint32_t symIndex = symbolIndices[j];
|
|
const NList &sym = nList[symIndex];
|
|
StringRef name = getSymName(sym);
|
|
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)) {
|
|
isec->hasAltEntry = symbolOffset != 0;
|
|
// If we have an private-label symbol that's an alias, just reuse the
|
|
// aliased symbol. Our sorting step above ensures that any such symbols
|
|
// will appear after the non-private-label ones. See
|
|
// weak-def-alias-ignored.s for the motivation behind this.
|
|
if (symbolOffset == 0 && isPrivateLabel(name) && j != 0)
|
|
symbols[symIndex] = symbols[symbolIndices[j - 1]];
|
|
else
|
|
symbols[symIndex] = createDefined(sym, name, isec, symbolOffset,
|
|
symbolSize, forceHidden);
|
|
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, forceHidden);
|
|
// 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)
|
|
symbols[i] = parseNonSectionSymbol(nList[i], strtab);
|
|
}
|
|
|
|
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, bool forceHidden)
|
|
: InputFile(ObjKind, mb, lazy), modTime(modTime), forceHidden(forceHidden) {
|
|
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());
|
|
|
|
uint32_t cpuType;
|
|
std::tie(cpuType, std::ignore) = getCPUTypeFromArchitecture(config->arch());
|
|
if (hdr->cputype != cpuType) {
|
|
Architecture arch =
|
|
getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
|
|
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]);
|
|
|
|
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 (const auto &[i, sym] : llvm::enumerate(nList)) {
|
|
if ((sym.n_type & N_EXT) && !isUndef(sym)) {
|
|
// TODO: Bound checking
|
|
StringRef name = strtab + sym.n_strx;
|
|
symbols[i] = 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)};
|
|
}
|
|
|
|
ArrayRef<uint8_t> ObjFile::getOptimizationHints() const {
|
|
const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
|
|
if (auto *cmd =
|
|
findCommand<linkedit_data_command>(buf, LC_LINKER_OPTIMIZATION_HINT))
|
|
return {buf + cmd->dataoff, cmd->datasize};
|
|
return {};
|
|
}
|
|
|
|
// 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!! Each compact unwind entry (CUE) has its UNSIGNED relocations embed
|
|
// their addends in its data. Thus if ICF operated naively and compared the
|
|
// entire contents of each CUE, entries with identical unwind info but e.g.
|
|
// belonging to different functions would never be considered equivalent. To
|
|
// work around this problem, we remove some parts of the data containing the
|
|
// embedded addends. In particular, we remove the function address and LSDA
|
|
// pointers. Since these locations are at the start and end of the entry,
|
|
// we can do this using a simple, efficient slice rather than performing a
|
|
// copy. We are not losing any information here because the embedded
|
|
// addends have already been parsed in the corresponding Reloc structs.
|
|
//
|
|
// Removing these pointers would not be safe if they were pointers to
|
|
// absolute symbols. In that case, there would be no corresponding
|
|
// relocation. However, (AFAIK) MC cannot emit references to absolute
|
|
// symbols for either the function address or the LSDA. However, it *can* do
|
|
// so for the personality pointer, so we are not slicing that field away.
|
|
//
|
|
// Note that we do not adjust the offsets of the corresponding relocations;
|
|
// instead, we rely on `relocateCompactUnwind()` to correctly handle these
|
|
// truncated input sections.
|
|
isec->data = isec->data.slice(target->wordSize, 8 + 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 & static_cast<uint32_t>(UNWIND_MODE_MASK)) ==
|
|
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;
|
|
// Now that the symbol points to the unwind entry, we can remove the reloc
|
|
// that points from the unwind entry back to the symbol.
|
|
//
|
|
// First, the symbol keeps the unwind entry alive (and not vice versa), so
|
|
// this keeps dead-stripping simple.
|
|
//
|
|
// Moreover, it reduces the work that ICF needs to do to figure out if
|
|
// functions with unwind info are foldable.
|
|
//
|
|
// However, this does make it possible for ICF to fold CUEs that point to
|
|
// distinct functions (if the CUEs are otherwise identical).
|
|
// UnwindInfoSection takes care of this by re-duplicating the CUEs so that
|
|
// each one can hold a distinct functionAddress value.
|
|
//
|
|
// 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 erase() is typically an O(1) operation.
|
|
it = isec->relocs.erase(it);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct CIE {
|
|
macho::Symbol *personalitySymbol = nullptr;
|
|
bool fdesHaveAug = false;
|
|
uint8_t lsdaPtrSize = 0; // 0 => no LSDA
|
|
uint8_t funcPtrSize = 0;
|
|
};
|
|
|
|
static uint8_t pointerEncodingToSize(uint8_t enc) {
|
|
switch (enc & 0xf) {
|
|
case dwarf::DW_EH_PE_absptr:
|
|
return target->wordSize;
|
|
case dwarf::DW_EH_PE_sdata4:
|
|
return 4;
|
|
case dwarf::DW_EH_PE_sdata8:
|
|
// ld64 doesn't actually support sdata8, but this seems simple enough...
|
|
return 8;
|
|
default:
|
|
return 0;
|
|
};
|
|
}
|
|
|
|
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;
|
|
|
|
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': {
|
|
uint8_t lsdaEnc = reader.readByte(&off);
|
|
cie.lsdaPtrSize = pointerEncodingToSize(lsdaEnc);
|
|
if (cie.lsdaPtrSize == 0)
|
|
reader.failOn(off, "unexpected LSDA encoding 0x" +
|
|
Twine::utohexstr(lsdaEnc));
|
|
break;
|
|
}
|
|
case 'R': {
|
|
uint8_t pointerEnc = reader.readByte(&off);
|
|
cie.funcPtrSize = pointerEncodingToSize(pointerEnc);
|
|
if (cie.funcPtrSize == 0 || !(pointerEnc & dwarf::DW_EH_PE_pcrel))
|
|
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);
|
|
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;
|
|
}
|
|
|
|
assert(cieMap.count(cieIsec));
|
|
const CIE &cie = cieMap[cieIsec];
|
|
// Offset of the function address within the EH frame.
|
|
const size_t funcAddrOff = dataOff;
|
|
uint64_t funcAddr = reader.readPointer(&dataOff, cie.funcPtrSize) +
|
|
ehFrameSection.addr + isecOff + funcAddrOff;
|
|
uint32_t funcLength = reader.readPointer(&dataOff, cie.funcPtrSize);
|
|
size_t lsdaAddrOff = 0; // Offset of the LSDA address within the EH frame.
|
|
std::optional<uint64_t> lsdaAddrOpt;
|
|
if (cie.fdesHaveAug) {
|
|
reader.skipLeb128(&dataOff);
|
|
lsdaAddrOff = dataOff;
|
|
if (cie.lsdaPtrSize != 0) {
|
|
uint64_t lsdaOff = reader.readPointer(&dataOff, cie.lsdaPtrSize);
|
|
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);
|
|
// Canonicalize the symbol. If there are multiple symbols at the same
|
|
// address, we want both `registerEhFrame` and `registerCompactUnwind`
|
|
// to register the unwind entry under same symbol.
|
|
// This is not particularly efficient, but we should run into this case
|
|
// infrequently (only when handling the output of `ld -r`).
|
|
if (funcSym->isec)
|
|
funcSym = findSymbolAtOffset(cast<ConcatInputSection>(funcSym->isec),
|
|
funcSym->value);
|
|
} 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();
|
|
}
|
|
|
|
// __eh_frame is marked as S_ATTR_LIVE_SUPPORT in input files, because FDEs
|
|
// are normally required to be kept alive if they reference a live symbol.
|
|
// However, we've explicitly created a dependency from a symbol to its FDE, so
|
|
// dead-stripping will just work as usual, and S_ATTR_LIVE_SUPPORT will only
|
|
// serve to incorrectly prevent us from dead-stripping duplicate FDEs for a
|
|
// live symbol (e.g. if there were multiple weak copies). Remove this flag to
|
|
// let dead-stripping proceed correctly.
|
|
ehFrameSection.flags &= ~S_ATTR_LIVE_SUPPORT;
|
|
}
|
|
|
|
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) {
|
|
std::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 (std::optional<StringRef> dylibPath =
|
|
resolveDylibPath(candidate.str()))
|
|
return loadDylib(*dylibPath, umbrella);
|
|
}
|
|
} else if (std::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 (std::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 (std::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 (std::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));
|
|
}
|
|
|
|
static bool isArchABICompatible(ArchitectureSet archSet,
|
|
Architecture targetArch) {
|
|
uint32_t cpuType;
|
|
uint32_t targetCpuType;
|
|
std::tie(targetCpuType, std::ignore) = getCPUTypeFromArchitecture(targetArch);
|
|
|
|
return llvm::any_of(archSet, [&](const auto &p) {
|
|
std::tie(cpuType, std::ignore) = getCPUTypeFromArchitecture(p);
|
|
return cpuType == targetCpuType;
|
|
});
|
|
}
|
|
|
|
static bool isTargetPlatformArchCompatible(
|
|
InterfaceFile::const_target_range interfaceTargets, Target target) {
|
|
if (is_contained(interfaceTargets, target))
|
|
return true;
|
|
|
|
if (config->forceExactCpuSubtypeMatch)
|
|
return false;
|
|
|
|
ArchitectureSet archSet;
|
|
for (const auto &p : interfaceTargets)
|
|
if (p.Platform == target.Platform)
|
|
archSet.set(p.Arch);
|
|
if (archSet.empty())
|
|
return false;
|
|
|
|
return isArchABICompatible(archSet, target.Arch);
|
|
}
|
|
|
|
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) &&
|
|
!isTargetPlatformArchCompatible(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 llvm::MachO::Symbol &symbol,
|
|
const Twine &name) -> void {
|
|
StringRef savedName = saver().save(name);
|
|
if (exportingFile->hiddenSymbols.contains(CachedHashStringRef(savedName)))
|
|
return;
|
|
|
|
symbols.push_back(symtab->addDylib(savedName, exportingFile,
|
|
symbol.isWeakDefined(),
|
|
symbol.isThreadLocalValue()));
|
|
};
|
|
|
|
std::vector<const llvm::MachO::Symbol *> normalSymbols;
|
|
normalSymbols.reserve(interface.symbolsCount());
|
|
for (const auto *symbol : interface.symbols()) {
|
|
if (!isArchABICompatible(symbol->getArchitectures(), config->arch()))
|
|
continue;
|
|
if (handleLDSymbol(symbol->getName()))
|
|
continue;
|
|
|
|
switch (symbol->getKind()) {
|
|
case SymbolKind::GlobalSymbol:
|
|
case SymbolKind::ObjectiveCClass:
|
|
case SymbolKind::ObjectiveCClassEHType:
|
|
case SymbolKind::ObjectiveCInstanceVariable:
|
|
normalSymbols.push_back(symbol);
|
|
}
|
|
}
|
|
|
|
// TODO(compnerd) filter out symbols based on the target platform
|
|
for (const auto *symbol : normalSymbols) {
|
|
switch (symbol->getKind()) {
|
|
case SymbolKind::GlobalSymbol:
|
|
addSymbol(*symbol, symbol->getName());
|
|
break;
|
|
case SymbolKind::ObjectiveCClass:
|
|
// XXX ld64 only creates these symbols when -ObjC is passed in. We may
|
|
// want to emulate that.
|
|
addSymbol(*symbol, objc::klass + symbol->getName());
|
|
addSymbol(*symbol, objc::metaclass + symbol->getName());
|
|
break;
|
|
case SymbolKind::ObjectiveCClassEHType:
|
|
addSymbol(*symbol, objc::ehtype + symbol->getName());
|
|
break;
|
|
case SymbolKind::ObjectiveCInstanceVariable:
|
|
addSymbol(*symbol, objc::ivar + symbol->getName());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
DylibFile::DylibFile(DylibFile *umbrella)
|
|
: InputFile(DylibKind, MemoryBufferRef{}), refState(RefState::Unreferenced),
|
|
explicitlyLinked(false), isBundleLoader(false) {
|
|
if (umbrella == nullptr)
|
|
umbrella = this;
|
|
this->umbrella = umbrella;
|
|
}
|
|
|
|
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()) ||
|
|
isTargetPlatformArchCompatible(targets, config->platformInfo.target))
|
|
loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
|
|
}
|
|
}
|
|
|
|
bool DylibFile::isExplicitlyLinked() const {
|
|
if (!explicitlyLinked)
|
|
return false;
|
|
|
|
// If this dylib was explicitly linked, but at least one of the symbols
|
|
// of the synthetic dylibs it created via $ld$previous symbols is
|
|
// referenced, then that synthetic dylib fulfils the explicit linkedness
|
|
// and we can deadstrip this dylib if it's unreferenced.
|
|
for (const auto *dylib : extraDylibs)
|
|
if (dylib->isReferenced())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
DylibFile *DylibFile::getSyntheticDylib(StringRef installName,
|
|
uint32_t currentVersion,
|
|
uint32_t compatVersion) {
|
|
for (DylibFile *dylib : extraDylibs)
|
|
if (dylib->installName == installName) {
|
|
// FIXME: Check what to do if different $ld$previous symbols
|
|
// request the same dylib, but with different versions.
|
|
return dylib;
|
|
}
|
|
|
|
auto *dylib = make<DylibFile>(umbrella == this ? nullptr : umbrella);
|
|
dylib->installName = saver().save(installName);
|
|
dylib->currentVersion = currentVersion;
|
|
dylib->compatibilityVersion = compatVersion;
|
|
extraDylibs.push_back(dylib);
|
|
return dylib;
|
|
}
|
|
|
|
// $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.rsplit('$');
|
|
|
|
// FIXME: Does this do the right thing for zippered files?
|
|
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;
|
|
|
|
// Initialized to compatibilityVersion for the symbolName branch below.
|
|
uint32_t newCompatibilityVersion = compatibilityVersion;
|
|
uint32_t newCurrentVersionForSymbol = currentVersion;
|
|
if (!compatVersion.empty()) {
|
|
VersionTuple cVersion;
|
|
if (cVersion.tryParse(compatVersion)) {
|
|
warn("failed to parse compatibility version, symbol '" + originalName +
|
|
"' ignored");
|
|
return;
|
|
}
|
|
newCompatibilityVersion = encodeVersion(cVersion);
|
|
newCurrentVersionForSymbol = newCompatibilityVersion;
|
|
}
|
|
|
|
if (!symbolName.empty()) {
|
|
// A $ld$previous$ symbol with symbol name adds a symbol with that name to
|
|
// a dylib with given name and version.
|
|
auto *dylib = getSyntheticDylib(installName, newCurrentVersionForSymbol,
|
|
newCompatibilityVersion);
|
|
|
|
// The tbd file usually contains the $ld$previous symbol for an old version,
|
|
// and then the symbol itself later, for newer deployment targets, like so:
|
|
// symbols: [
|
|
// '$ld$previous$/Another$$1$3.0$14.0$_zzz$',
|
|
// _zzz,
|
|
// ]
|
|
// Since the symbols are sorted, adding them to the symtab in the given
|
|
// order means the $ld$previous version of _zzz will prevail, as desired.
|
|
dylib->symbols.push_back(symtab->addDylib(
|
|
saver().save(symbolName), dylib, /*isWeakDef=*/false, /*isTlv=*/false));
|
|
return;
|
|
}
|
|
|
|
// A $ld$previous$ symbol without symbol name modifies the dylib it's in.
|
|
this->installName = saver().save(installName);
|
|
this->compatibilityVersion = newCompatibilityVersion;
|
|
}
|
|
|
|
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, bool forceHidden)
|
|
: InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)),
|
|
forceHidden(forceHidden) {}
|
|
|
|
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, bool forceHidden) {
|
|
if (config->zeroModTime)
|
|
modTime = 0;
|
|
|
|
switch (identify_magic(mb.getBuffer())) {
|
|
case file_magic::macho_object:
|
|
return make<ObjFile>(mb, modTime, archiveName, /*lazy=*/false, forceHidden);
|
|
case file_magic::bitcode:
|
|
return make<BitcodeFile>(mb, archiveName, offsetInArchive, /*lazy=*/false,
|
|
forceHidden);
|
|
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(), forceHidden);
|
|
|
|
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() ||
|
|
file.forceHidden;
|
|
|
|
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, bool forceHidden)
|
|
: InputFile(BitcodeKind, mb, lazy), forceHidden(forceHidden) {
|
|
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 (const auto &[i, objSym] : llvm::enumerate(obj->symbols())) {
|
|
if (!objSym.isUndefined()) {
|
|
symbols[i] = symtab->addLazyObject(saver().save(objSym.getName()), *this);
|
|
if (!lazy)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void macho::extract(InputFile &file, StringRef reason) {
|
|
printArchiveMemberLoad(reason, &file);
|
|
assert(file.lazy);
|
|
file.lazy = false;
|
|
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>();
|