CbC/CbC_llvm: lld/MachO/InputFiles.cpp comparison

comparison lld/MachO/InputFiles.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 //
 //===----------------------------------------------------------------------===//
 #include "InputFiles.h"
 #include "Config.h"
+#include "Driver.h"
+#include "Dwarf.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 "Target.h"
+#include "lld/Common/DWARF.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
+#include "lld/Common/Reproduce.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/LTO/LTO.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/TarWriter.h"
+#include "llvm/TextAPI/Architecture.h"
+#include "llvm/TextAPI/InterfaceFile.h"
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::macho;
-std::vector<InputFile *> macho::inputFiles;
+// 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();
+}
+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();
+std::vector<PlatformInfo> platformInfos;
+for (auto *cmd : findCommands<build_version_command>(hdr, LC_BUILD_VERSION)) {
+PlatformInfo info;
+info.target.Platform = static_cast<PlatformKind>(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 = PlatformKind::macOS;
+break;
+case LC_VERSION_MIN_IPHONEOS:
+info.target.Platform = PlatformKind::iOS;
+break;
+case LC_VERSION_MIN_TVOS:
+info.target.Platform = PlatformKind::tvOS;
+break;
+case LC_VERSION_MIN_WATCHOS:
+info.target.Platform = PlatformKind::watchOS;
+break;
+}
+info.minimum = decodeVersion(cmd->version);
+platformInfos.emplace_back(std::move(info));
+}
+return platformInfos;
+}
+static PlatformKind removeSimulator(PlatformKind platform) {
+// Mapping of platform to simulator and vice-versa.
+static const std::map<PlatformKind, PlatformKind> platformMap = {
+{PlatformKind::iOSSimulator, PlatformKind::iOS},
+{PlatformKind::tvOSSimulator, PlatformKind::tvOS},
+{PlatformKind::watchOSSimulator, PlatformKind::watchOS}};
+auto iter = platformMap.find(platform);
+if (iter == platformMap.end())
+return platform;
+return iter->second;
+}
+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)
+return true;
+error(toString(input) + " has version " + it->minimum.getAsString() +
+", which is newer than target minimum of " +
+config->platformInfo.minimum.getAsString());
+return false;
+}
 // Open a given file path and return it as a memory-mapped file.
 Optional<MemoryBufferRef> macho::readFile(StringRef path) {
-// Open a file.
+ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = MemoryBuffer::getFile(path);
-auto mbOrErr = MemoryBuffer::getFile(path);
+if (std::error_code ec = mbOrErr.getError()) {
-if (auto ec = mbOrErr.getError()) {
 error("cannot open " + path + ": " + ec.message());
 return None;
 }
 std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
 MemoryBufferRef mbref = mb->getMemBufferRef();
 make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
 // If this is a regular non-fat file, return it.
 const char *buf = mbref.getBufferStart();
-auto *hdr = reinterpret_cast<const MachO::fat_header *>(buf);
+const auto *hdr = reinterpret_cast<const fat_header *>(buf);
-if (read32be(&hdr->magic) != MachO::FAT_MAGIC)
+if (mbref.getBufferSize() < sizeof(uint32_t) ||
+read32be(&hdr->magic) != FAT_MAGIC) {
+if (tar)
+tar->append(relativeToRoot(path), mbref.getBuffer());
 return mbref;
+}
-// Object files and archive files may be fat files, which contains
-// multiple real files for different CPU ISAs. Here, we search for a
+// Object files and archive files may be fat files, which contain multiple
-// file that matches with the current link target and returns it as
+// real files for different CPU ISAs. Here, we search for a file that matches
-// a MemoryBufferRef.
+// with the current link target and returns it as a MemoryBufferRef.
-auto *arch = reinterpret_cast<const MachO::fat_arch *>(buf + sizeof(*hdr));
+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) != target->cpuType ||
+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 MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
 }
 error("unable to find matching architecture in " + path);
 return None;
 }
-static const load_command *findCommand(const mach_header_64 *hdr,
+InputFile::InputFile(Kind kind, const InterfaceFile &interface)
-uint32_t type) {
+: id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
-const uint8_t *p =
-reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
+template <class Section>
+void ObjFile::parseSections(ArrayRef<Section> sections) {
-for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
-auto *cmd = reinterpret_cast<const load_command *>(p);
-if (cmd->cmd == type)
-return cmd;
-p += cmd->cmdsize;
-}
-return nullptr;
-}
-void InputFile::parseSections(ArrayRef<section_64> sections) {
 subsections.reserve(sections.size());
 auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-for (const section_64 &sec : sections) {
+for (const Section &sec : sections) {
 InputSection *isec = make<InputSection>();
 isec->file = this;
-isec->name = StringRef(sec.sectname, strnlen(sec.sectname, 16));
+isec->name =
-isec->segname = StringRef(sec.segname, strnlen(sec.segname, 16));
+StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
-isec->data = {buf + sec.offset, static_cast<size_t>(sec.size)};
+isec->segname =
+StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
+isec->data = {isZeroFill(sec.flags) ? nullptr : buf + sec.offset,
+static_cast<size_t>(sec.size)};
 if (sec.align >= 32)
 error("alignment " + std::to_string(sec.align) + " of section " +
 isec->name + " is too large");
 else
 isec->align = 1 << sec.align;
 isec->flags = sec.flags;
-subsections.push_back({{0, isec}});
+if (!(isDebugSection(isec->flags) &&
+isec->segname == segment_names::dwarf)) {
+subsections.push_back({{0, isec}});
+} else {
+// Instead of emitting DWARF sections, we emit STABS symbols to the
+// object files that contain them. We filter them out early to avoid
+// parsing their relocations unnecessarily. But we must still push an
+// empty map to ensure the indices line up for the remaining sections.
+subsections.push_back({});
+debugSections.push_back(isec);
+}
 }
 }
 // Find the subsection corresponding to the greatest section offset that is <=
 // that of the given offset.
 // offset: an offset relative to the start of the original InputSection (before
 // any subsection splitting has occurred). It will be updated to represent the
 // same location as an offset relative to the start of the containing
 // subsection.
 static InputSection *findContainingSubsection(SubsectionMap &map,
-uint32_t *offset) {
+uint64_t *offset) {
-auto it = std::prev(map.upper_bound(*offset));
+auto it = std::prev(llvm::upper_bound(
-*offset -= it->first;
+map, *offset, [](uint64_t value, SubsectionEntry subsecEntry) {
-return it->second;
+return value < subsecEntry.offset;
-}
+}));
+*offset -= it->offset;
-void InputFile::parseRelocations(const section_64 &sec,
+return it->isec;
-SubsectionMap &subsecMap) {
+}
+template <class Section>
+static bool validateRelocationInfo(InputFile *file, const Section &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 Section>
+void ObjFile::parseRelocations(ArrayRef<Section> sectionHeaders,
+const Section &sec, SubsectionMap &subsecMap) {
 auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-ArrayRef<any_relocation_info> relInfos(
+ArrayRef<relocation_info> relInfos(
-reinterpret_cast<const any_relocation_info *>(buf + sec.reloff),
+reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
-sec.nreloc);
+for (size_t i = 0; i < relInfos.size(); i++) {
-for (const any_relocation_info &anyRel : relInfos) {
+// Paired relocations serve as Mach-O's method for attaching a
-if (anyRel.r_word0 & R_SCATTERED)
+// supplemental datum to a primary relocation record. ELF does not
+// need them because the *_RELOC_RELA records contain the extra
+// addend field, vs. *_RELOC_REL which omit the addend.
+//
+// The {X86_64,ARM64}_RELOC_SUBTRACTOR record holds the subtrahend,
+// and the paired *_RELOC_UNSIGNED record holds the minuend. The
+// datum for each is a symbolic address. The result is the offset
+// between two addresses.
+//
+// The ARM64_RELOC_ADDEND record holds the addend, and the paired
+// ARM64_RELOC_BRANCH26 or ARM64_RELOC_PAGE21/PAGEOFF12 holds the
+// base symbolic address.
+//
+// Note: X86 does not use *_RELOC_ADDEND because it can embed an
+// addend into the instruction stream. On X86, a relocatable address
+// field always occupies an entire contiguous sequence of byte(s),
+// so there is no need to merge opcode bits with address
+// bits. Therefore, it's easy and convenient to store addends in the
+// instruction-stream bytes that would otherwise contain zeroes. By
+// contrast, RISC ISAs such as ARM64 mix opcode bits with with
+// address bits so that bitwise arithmetic is necessary to extract
+// and insert them. Storing addends in the instruction stream is
+// possible, but inconvenient and more costly at link time.
+int64_t pairedAddend = 0;
+relocation_info relInfo = relInfos[i];
+if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
+pairedAddend = SignExtend64<24>(relInfo.r_symbolnum);
+relInfo = relInfos[++i];
+}
+assert(i < relInfos.size());
+if (!validateRelocationInfo(this, sec, relInfo))
+continue;
+if (relInfo.r_address & R_SCATTERED)
 fatal("TODO: Scattered relocations not supported");
-auto rel = reinterpret_cast<const relocation_info &>(anyRel);
+bool isSubtrahend =
+target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND);
+int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
+assert(!(embeddedAddend && pairedAddend));
+int64_t totalAddend = pairedAddend + embeddedAddend;
 Reloc r;
-r.type = rel.r_type;
+r.type = relInfo.r_type;
-r.pcrel = rel.r_pcrel;
+r.pcrel = relInfo.r_pcrel;
-uint32_t secRelOffset = rel.r_address;
+r.length = relInfo.r_length;
-uint64_t rawAddend =
+r.offset = relInfo.r_address;
-target->getImplicitAddend(buf + sec.offset + secRelOffset, r.type);
+if (relInfo.r_extern) {
+r.referent = symbols[relInfo.r_symbolnum];
-if (rel.r_extern) {
+r.addend = isSubtrahend ? 0 : totalAddend;
-r.target = symbols[rel.r_symbolnum];
-r.addend = rawAddend;
 } else {
-if (!rel.r_pcrel)
+assert(!isSubtrahend);
-fatal("TODO: Only pcrel section relocations are supported");
+const Section &referentSec = sectionHeaders[relInfo.r_symbolnum - 1];
+uint64_t referentOffset;
-if (rel.r_symbolnum == 0 || rel.r_symbolnum > subsections.size())
+if (relInfo.r_pcrel) {
-fatal("invalid section index in relocation for offset " +
+// The implicit addend for pcrel section relocations is the pcrel offset
-std::to_string(r.offset) + " in section " + sec.sectname +
+// in terms of the addresses in the input file. Here we adjust it so
-" of " + getName());
+// that it describes the offset from the start of the referent section.
+// FIXME This logic was written around x86_64 behavior -- ARM64 doesn't
-SubsectionMap &targetSubsecMap = subsections[rel.r_symbolnum - 1];
+// have pcrel section relocations. We may want to factor this out into
-const section_64 &targetSec = sectionHeaders[rel.r_symbolnum - 1];
+// the arch-specific .cpp file.
-// The implicit addend for pcrel section relocations is the pcrel offset
+assert(target->hasAttr(r.type, RelocAttrBits::BYTE4));
-// in terms of the addresses in the input file. Here we adjust it so that
+referentOffset =
-// it describes the offset from the start of the target section.
+sec.addr + relInfo.r_address + 4 + totalAddend - referentSec.addr;
-// TODO: Figure out what to do for non-pcrel section relocations.
+} else {
-// TODO: The offset of 4 is probably not right for ARM64, nor for
+// The addend for a non-pcrel relocation is its absolute address.
-//       relocations with r_length != 2.
+referentOffset = totalAddend - referentSec.addr;
-uint32_t targetOffset =
+}
-sec.addr + secRelOffset + 4 + rawAddend - targetSec.addr;
+SubsectionMap &referentSubsecMap = subsections[relInfo.r_symbolnum - 1];
-r.target = findContainingSubsection(targetSubsecMap, &targetOffset);
+r.referent = findContainingSubsection(referentSubsecMap, &referentOffset);
-r.addend = targetOffset;
+r.addend = referentOffset;
 }
-InputSection *subsec = findContainingSubsection(subsecMap, &secRelOffset);
+InputSection *subsec = findContainingSubsection(subsecMap, &r.offset);
-r.offset = secRelOffset;
 subsec->relocs.push_back(r);
-}
-}
+if (isSubtrahend) {
+relocation_info minuendInfo = relInfos[++i];
-void InputFile::parseSymbols(ArrayRef<nlist_64> nList, const char *strtab,
+// SUBTRACTOR relocations should always be followed by an UNSIGNED one
-bool subsectionsViaSymbols) {
+// attached to the same address.
-// resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
+assert(target->hasAttr(minuendInfo.r_type, RelocAttrBits::UNSIGNED) &&
-// out-of-sequence.
+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;
+SubsectionMap &referentSubsecMap =
+subsections[minuendInfo.r_symbolnum - 1];
+p.referent =
+findContainingSubsection(referentSubsecMap, &referentOffset);
+p.addend = referentOffset;
+}
+subsec->relocs.push_back(p);
+}
+}
+}
+template <class NList>
+static macho::Symbol *createDefined(const NList &sym, StringRef name,
+InputSection *isec, uint64_t value,
+uint64_t size) {
+// Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
+// N_EXT: Global symbols. These go in the symbol table during the link,
+//        and also in the export table of the output so that the dynamic
+//        linker sees them.
+// N_EXT | N_PEXT: Linkage unit (think: dylib) scoped. These go in the
+//                 symbol table during the link so that duplicates are
+//                 either reported (for non-weak symbols) or merged
+//                 (for weak symbols), but they do not go in the export
+//                 table of the output.
+// N_PEXT: Does not occur in input files in practice,
+//         a private extern must be external.
+// 0: Translation-unit scoped. These are not in the symbol table 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 | N_PEXT)) {
+assert((sym.n_type & N_EXT) && "invalid input");
+bool isPrivateExtern = sym.n_type & N_PEXT;
+// lld's behavior for merging symbols is slightly different from ld64:
+// ld64 picks the winning symbol based on several criteria (see
+// pickBetweenRegularAtoms() in ld64's SymbolTable.cpp), while lld
+// just merges metadata and keeps the contents of the first symbol
+// with that name (see SymbolTable::addDefined). For:
+// * inline function F in a TU built with -fvisibility-inlines-hidden
+// * and inline function F in another TU built without that flag
+// ld64 will pick the one from the file built without
+// -fvisibility-inlines-hidden.
+// lld will instead pick the one listed first on the link command line and
+// give it visibility as if the function was built without
+// -fvisibility-inlines-hidden.
+// If both functions have the same contents, this will have the same
+// behavior. If not, it won't, but the input had an ODR violation in
+// that case.
+//
+// Similarly, merging a symbol
+// that's isPrivateExtern and not isWeakDefCanBeHidden with one
+// that's not isPrivateExtern but isWeakDefCanBeHidden technically
+// should produce one
+// that's not isPrivateExtern but isWeakDefCanBeHidden. That matters
+// with ld64's semantics, because it means the non-private-extern
+// definition will continue to take priority if more private extern
+// definitions are encountered. With lld's semantics there's no observable
+// difference between a symbol that's isWeakDefCanBeHidden or one that's
+// privateExtern -- neither makes it into the dynamic symbol table. So just
+// promote isWeakDefCanBeHidden to isPrivateExtern here.
+if (isWeakDefCanBeHidden)
+isPrivateExtern = true;
+return symtab->addDefined(
+name, isec->file, 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);
+}
+assert(!isWeakDefCanBeHidden &&
+"weak_def_can_be_hidden on already-hidden symbol?");
+return make<Defined>(
+name, isec->file, isec, value, size, sym.n_desc & N_WEAK_DEF,
+/*isExternal=*/false, /*isPrivateExtern=*/false,
+sym.n_desc & N_ARM_THUMB_DEF, sym.n_desc & REFERENCED_DYNAMICALLY,
+sym.n_desc & N_NO_DEAD_STRIP);
+}
+// Absolute symbols are defined symbols that do not have an associated
+// InputSection. They cannot be weak.
+template <class NList>
+static macho::Symbol *createAbsolute(const NList &sym, InputFile *file,
+StringRef name) {
+if (sym.n_type & (N_EXT | N_PEXT)) {
+assert((sym.n_type & N_EXT) && "invalid input");
+return symtab->addDefined(name, file, nullptr, sym.n_value, /*size=*/0,
+/*isWeakDef=*/false, sym.n_type & N_PEXT,
+sym.n_desc & N_ARM_THUMB_DEF,
+/*isReferencedDynamically=*/false,
+sym.n_desc & N_NO_DEAD_STRIP);
+}
+return make<Defined>(name, file, nullptr, sym.n_value, /*size=*/0,
+/*isWeakDef=*/false,
+/*isExternal=*/false, /*isPrivateExtern=*/false,
+sym.n_desc & N_ARM_THUMB_DEF,
+/*isReferencedDynamically=*/false,
+sym.n_desc & N_NO_DEAD_STRIP);
+}
+template <class NList>
+macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
+StringRef name) {
+uint8_t type = sym.n_type & N_TYPE;
+switch (type) {
+case N_UNDF:
+return sym.n_value == 0
+? symtab->addUndefined(name, this, sym.n_desc & N_WEAK_REF)
+: symtab->addCommon(name, this, sym.n_value,
+1 << GET_COMM_ALIGN(sym.n_desc),
+sym.n_type & N_PEXT);
+case N_ABS:
+return createAbsolute(sym, this, name);
+case N_PBUD:
+case N_INDR:
+error("TODO: support symbols of type " + std::to_string(type));
+return nullptr;
+case N_SECT:
+llvm_unreachable(
+"N_SECT symbols should not be passed to parseNonSectionSymbol");
+default:
+llvm_unreachable("invalid symbol type");
+}
+}
+template <class 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(subsections.size());
 symbols.resize(nList.size());
-std::vector<size_t> altEntrySymIdxs;
+for (uint32_t i = 0; i < nList.size(); ++i) {
+const NList &sym = nList[i];
-auto createDefined = [&](const nlist_64 &sym, InputSection *isec,
-uint32_t value) -> Symbol * {
 StringRef name = strtab + sym.n_strx;
-if (sym.n_type & N_EXT)
+if ((sym.n_type & N_TYPE) == N_SECT) {
-// Global defined symbol
+SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
-return symtab->addDefined(name, isec, value);
+// parseSections() may have chosen not to parse this section.
-else
+if (subsecMap.empty())
-// Local defined symbol
+continue;
-return make<Defined>(name, isec, value);
+symbolsBySection[sym.n_sect - 1].push_back(i);
-};
+} else {
+symbols[i] = parseNonSectionSymbol(sym, name);
-for (size_t i = 0, n = nList.size(); i < n; ++i) {
+}
-const nlist_64 &sym = nList[i];
+}
-// Undefined symbol
+// Calculate symbol sizes and create subsections by splitting the sections
-if (!sym.n_sect) {
+// along symbol boundaries.
+for (size_t i = 0; i < subsections.size(); ++i) {
+SubsectionMap &subsecMap = subsections[i];
+if (subsecMap.empty())
+continue;
+std::vector<uint32_t> &symbolIndices = symbolsBySection[i];
+llvm::sort(symbolIndices, [&](uint32_t lhs, uint32_t rhs) {
+return nList[lhs].n_value < nList[rhs].n_value;
+});
+uint64_t sectionAddr = sectionHeaders[i].addr;
+uint32_t sectionAlign = 1u << sectionHeaders[i].align;
+// We populate subsecMap by repeatedly splitting the last (highest address)
+// subsection.
+SubsectionEntry subsecEntry = subsecMap.back();
+for (size_t j = 0; j < symbolIndices.size(); ++j) {
+uint32_t symIndex = symbolIndices[j];
+const NList &sym = nList[symIndex];
 StringRef name = strtab + sym.n_strx;
-symbols[i] = symtab->addUndefined(name);
+InputSection *isec = subsecEntry.isec;
-continue;
-}
+uint64_t subsecAddr = sectionAddr + subsecEntry.offset;
+uint64_t symbolOffset = sym.n_value - subsecAddr;
-const section_64 &sec = sectionHeaders[sym.n_sect - 1];
+uint64_t symbolSize =
-SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
+j + 1 < symbolIndices.size()
-uint64_t offset = sym.n_value - sec.addr;
+? nList[symbolIndices[j + 1]].n_value - sym.n_value
+: isec->data.size() - symbolOffset;
-// If the input file does not use subsections-via-symbols, all symbols can
+// There are 3 cases where we do not need to create a new subsection:
-// use the same subsection. Otherwise, we must split the sections along
+//   1. If the input file does not use subsections-via-symbols.
-// symbol boundaries.
+//   2. Multiple symbols at the same address only induce one subsection.
-if (!subsectionsViaSymbols) {
+//      (The symbolOffset == 0 check covers both this case as well as
-symbols[i] = createDefined(sym, subsecMap[0], offset);
+//      the first loop iteration.)
-continue;
+//   3. Alternative entry points do not induce new subsections.
-}
+if (!subsectionsViaSymbols || symbolOffset == 0 ||
+sym.n_desc & N_ALT_ENTRY) {
-// nList entries aren't necessarily arranged in address order. Therefore,
+symbols[symIndex] =
-// we can't create alt-entry symbols at this point because a later symbol
+createDefined(sym, name, isec, symbolOffset, symbolSize);
-// may split its section, which may affect which subsection the alt-entry
+continue;
-// symbol is assigned to. So we need to handle them in a second pass below.
+}
-if (sym.n_desc & N_ALT_ENTRY) {
-altEntrySymIdxs.push_back(i);
+auto *nextIsec = make<InputSection>(*isec);
-continue;
+nextIsec->data = isec->data.slice(symbolOffset);
-}
+nextIsec->numRefs = 0;
+nextIsec->wasCoalesced = false;
-// Find the subsection corresponding to the greatest section offset that is
+isec->data = isec->data.slice(0, symbolOffset);
-// <= that of the current symbol. The subsection that we find either needs
-// to be used directly or split in two.
+// By construction, the symbol will be at offset zero in the new
-uint32_t firstSize = offset;
+// subsection.
-InputSection *firstIsec = findContainingSubsection(subsecMap, &firstSize);
+symbols[symIndex] =
+createDefined(sym, name, nextIsec, /*value=*/0, symbolSize);
-if (firstSize == 0) {
+// TODO: ld64 appears to preserve the original alignment as well as each
-// Alias of an existing symbol, or the first symbol in the section. These
+// subsection's offset from the last aligned address. We should consider
-// are handled by reusing the existing section.
+// emulating that behavior.
-symbols[i] = createDefined(sym, firstIsec, 0);
+nextIsec->align = MinAlign(sectionAlign, sym.n_value);
-continue;
+subsecMap.push_back({sym.n_value - sectionAddr, nextIsec});
-}
+subsecEntry = subsecMap.back();
+}
-// We saw a symbol definition at a new offset. Split the section into two
+}
-// subsections. The new symbol uses the second subsection.
+}
-auto *secondIsec = make<InputSection>(*firstIsec);
-secondIsec->data = firstIsec->data.slice(firstSize);
+OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
-firstIsec->data = firstIsec->data.slice(0, firstSize);
+StringRef sectName)
-// TODO: ld64 appears to preserve the original alignment as well as each
+: InputFile(OpaqueKind, mb) {
-// subsection's offset from the last aligned address. We should consider
+InputSection *isec = make<InputSection>();
-// emulating that behavior.
+isec->file = this;
-secondIsec->align = MinAlign(firstIsec->align, offset);
+isec->name = sectName.take_front(16);
+isec->segname = segName.take_front(16);
-subsecMap[offset] = secondIsec;
+const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-// By construction, the symbol will be at offset zero in the new section.
+isec->data = {buf, mb.getBufferSize()};
-symbols[i] = createDefined(sym, secondIsec, 0);
+isec->live = true;
-}
+subsections.push_back({{0, isec}});
+}
-for (size_t idx : altEntrySymIdxs) {
-const nlist_64 &sym = nList[idx];
+ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
-SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
+: InputFile(ObjKind, mb), modTime(modTime) {
-uint32_t off = sym.n_value - sectionHeaders[sym.n_sect - 1].addr;
+this->archiveName = std::string(archiveName);
-InputSection *subsec = findContainingSubsection(subsecMap, &off);
+if (target->wordSize == 8)
-symbols[idx] = createDefined(sym, subsec, off);
+parse<LP64>();
-}
+else
-}
+parse<ILP32>();
+}
-ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
+template <class LP> void ObjFile::parse() {
+using Header = typename LP::mach_header;
+using SegmentCommand = typename LP::segment_command;
+using Section = typename LP::section;
+using NList = typename LP::nlist;
 auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
-if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
+Architecture arch = getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
-auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
+if (arch != config->arch()) {
-sectionHeaders = ArrayRef<section_64>{
+error(toString(this) + " has architecture " + getArchitectureName(arch) +
-reinterpret_cast<const section_64 *>(c + 1), c->nsects};
+" which is incompatible with target architecture " +
+getArchitectureName(config->arch()));
+return;
+}
+if (!checkCompatibility(this))
+return;
+if (const load_command *cmd = findCommand(hdr, LC_LINKER_OPTION)) {
+auto *c = reinterpret_cast<const linker_option_command *>(cmd);
+StringRef data{reinterpret_cast<const char *>(c + 1),
+c->cmdsize - sizeof(linker_option_command)};
+parseLCLinkerOption(this, c->count, data);
+}
+ArrayRef<Section> sectionHeaders;
+if (const load_command *cmd = findCommand(hdr, LP::segmentLCType)) {
+auto *c = reinterpret_cast<const SegmentCommand *>(cmd);
+sectionHeaders =
+ArrayRef<Section>{reinterpret_cast<const Section *>(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_64> nList(
+ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
-reinterpret_cast<const nlist_64 *>(buf + c->symoff), c->nsyms);
+c->nsyms);
 const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
 bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
-parseSymbols(nList, strtab, subsectionsViaSymbols);
+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 = subsections.size(); i < n; ++i)
-parseRelocations(sectionHeaders[i], subsections[i]);
+if (!subsections[i].empty())
-}
+parseRelocations(sectionHeaders, sectionHeaders[i], subsections[i]);
-DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella)
+parseDebugInfo();
-: InputFile(DylibKind, mb) {
+}
+void ObjFile::parseDebugInfo() {
+std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
+if (!dObj)
+return;
+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->get();
+}
+// The path can point to either a dylib or a .tbd file.
+static DylibFile *loadDylib(StringRef path, DylibFile *umbrella) {
+Optional<MemoryBufferRef> mbref = readFile(path);
+if (!mbref) {
+error("could not read dylib file at " + path);
+return nullptr;
+}
+return loadDylib(*mbref, umbrella);
+}
+// TBD files are parsed into a series of TAPI documents (InterfaceFiles), with
+// the first document storing child pointers to the rest of them. When we are
+// processing a given TBD file, we store that top-level document in
+// currentTopLevelTapi. When processing re-exports, we search its children for
+// potentially matching documents in the same TBD file. Note that the children
+// themselves don't point to further documents, i.e. this is a two-level tree.
+//
+// Re-exports can either refer to on-disk files, or to documents within .tbd
+// files.
+static DylibFile *findDylib(StringRef path, DylibFile *umbrella,
+const InterfaceFile *currentTopLevelTapi) {
+if (path::is_absolute(path, path::Style::posix))
+for (StringRef root : config->systemLibraryRoots)
+if (Optional<std::string> dylibPath =
+resolveDylibPath((root + path).str()))
+return loadDylib(*dylibPath, umbrella);
+// TODO: Handle -dylib_file
+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.
+path::append(newPath, sys::path::parent_path(config->outputFile), path);
+path = newPath;
+} else if (path.consume_front("@loader_path/")) {
+path::append(newPath, sys::path::parent_path(umbrella->getName()), path);
+path = newPath;
+} else if (path.startswith("@rpath/")) {
+for (StringRef rpath : umbrella->rpaths) {
+newPath.clear();
+if (rpath.consume_front("@loader_path/"))
+path::append(newPath, sys::path::parent_path(umbrella->getName()));
+path::append(newPath, rpath, path.drop_front(strlen("@rpath/")));
+if (Optional<std::string> dylibPath = resolveDylibPath(newPath))
+return loadDylib(*dylibPath, umbrella);
+}
+}
+if (currentTopLevelTapi) {
+for (InterfaceFile &child :
+make_pointee_range(currentTopLevelTapi->documents())) {
+assert(child.documents().empty());
+if (path == child.getInstallName()) {
+auto file = make<DylibFile>(child, umbrella);
+file->parseReexports(child);
+return file;
+}
+}
+}
+if (Optional<std::string> 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);
+else if (isImplicitlyLinked(path))
+inputFiles.insert(reexport);
+}
+DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
+bool isBundleLoader)
+: InputFile(DylibKind, mb), refState(RefState::Unreferenced),
+isBundleLoader(isBundleLoader) {
+assert(!isBundleLoader || !umbrella);
 if (umbrella == nullptr)
 umbrella = this;
+this->umbrella = umbrella;
 auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
-// Initialize dylibName.
+// Initialize installName.
 if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
 auto *c = reinterpret_cast<const dylib_command *>(cmd);
-dylibName = reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
+currentVersion = read32le(&c->dylib.current_version);
-} else {
+compatibilityVersion = read32le(&c->dylib.compatibility_version);
-error("dylib " + getName() + " missing LC_ID_DYLIB load command");
+installName =
-return;
+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));
+deadStrippable = hdr->flags & MH_DEAD_STRIPPABLE_DYLIB;
+if (!checkCompatibility(this))
+return;
+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;
 if (const load_command *cmd = findCommand(hdr, LC_DYLD_INFO_ONLY)) {
 auto *c = reinterpret_cast<const dyld_info_command *>(cmd);
 parseTrie(buf + c->export_off, c->export_size,
 [&](const Twine &name, uint64_t flags) {
-symbols.push_back(symtab->addDylib(saver.save(name), umbrella));
+StringRef savedName = saver.save(name);
+if (handleLDSymbol(savedName))
+return;
+bool isWeakDef = flags & EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
+bool isTlv = flags & EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL;
+symbols.push_back(symtab->addDylib(savedName, exportingFile,
+isWeakDef, isTlv));
 });
 } else {
-error("LC_DYLD_INFO_ONLY not found in " + getName());
+error("LC_DYLD_INFO_ONLY not found in " + toString(this));
 return;
 }
+}
-if (hdr->flags & MH_NO_REEXPORTED_DYLIBS)
-return;
+void DylibFile::parseLoadCommands(MemoryBufferRef mb) {
+auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
-const uint8_t *p =
+const uint8_t *p = reinterpret_cast<const uint8_t *>(mb.getBufferStart()) +
-reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
+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 (cmd->cmd != LC_REEXPORT_DYLIB)
+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.
+static constexpr std::array<StringRef, 3> skipPlatformChecks{
+"/usr/lib/system/libsystem_kernel.dylib",
+"/usr/lib/system/libsystem_platform.dylib",
+"/usr/lib/system/libsystem_pthread.dylib"};
+DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
+bool isBundleLoader)
+: InputFile(DylibKind, interface), refState(RefState::Unreferenced),
+isBundleLoader(isBundleLoader) {
+// FIXME: Add test for the missing TBD code path.
+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));
+if (!is_contained(skipPlatformChecks, installName) &&
+!is_contained(interface.targets(), config->platformInfo.target)) {
+error(toString(this) + " is incompatible with " +
+std::string(config->platformInfo.target));
+return;
+}
+exportingFile = isImplicitlyLinked(installName) ? this : umbrella;
+auto addSymbol = [&](const Twine &name) -> void {
+symbols.push_back(symtab->addDylib(saver.save(name), exportingFile,
+/*isWeakDef=*/false,
+/*isTlv=*/false));
+};
+// TODO(compnerd) filter out symbols based on the target platform
+// TODO: handle weak defs, thread locals
+for (const auto *symbol : interface.symbols()) {
+if (!symbol->getArchitectures().has(config->arch()))
 continue;
-auto *c = reinterpret_cast<const dylib_command *>(cmd);
+if (handleLDSymbol(symbol->getName()))
-StringRef reexportPath =
+continue;
-reinterpret_cast<const char *>(c) + read32le(&c->dylib.name);
-// TODO: Expand @loader_path, @executable_path etc in reexportPath
+switch (symbol->getKind()) {
-Optional<MemoryBufferRef> buffer = readFile(reexportPath);
+case SymbolKind::GlobalSymbol:
-if (!buffer) {
+addSymbol(symbol->getName());
-error("unable to read re-exported dylib at " + reexportPath);
+break;
+case SymbolKind::ObjectiveCClass:
+// XXX ld64 only creates these symbols when -ObjC is passed in. We may
+// want to emulate that.
+addSymbol(objc::klass + symbol->getName());
+addSymbol(objc::metaclass + symbol->getName());
+break;
+case SymbolKind::ObjectiveCClassEHType:
+addSymbol(objc::ehtype + symbol->getName());
+break;
+case SymbolKind::ObjectiveCInstanceVariable:
+addSymbol(objc::ivar + symbol->getName());
+break;
+}
+}
+}
+void DylibFile::parseReexports(const InterfaceFile &interface) {
+const InterfaceFile *topLevel =
+interface.getParent() == nullptr ? &interface : interface.getParent();
+for (InterfaceFileRef intfRef : interface.reexportedLibraries()) {
+InterfaceFile::const_target_range targets = intfRef.targets();
+if (is_contained(skipPlatformChecks, intfRef.getInstallName()) ||
+is_contained(targets, config->platformInfo.target))
+loadReexport(intfRef.getInstallName(), exportingFile, topLevel);
+}
+}
+// $ld$ symbols modify the properties/behavior of the library (e.g. its install
+// name, compatibility version or hide/add symbols) for specific target
+// versions.
+bool DylibFile::handleLDSymbol(StringRef originalName) {
+if (!originalName.startswith("$ld$"))
+return false;
+StringRef action;
+StringRef name;
+std::tie(action, name) = originalName.drop_front(strlen("$ld$")).split('$');
+if (action == "previous")
+handleLDPreviousSymbol(name, originalName);
+else if (action == "install_name")
+handleLDInstallNameSymbol(name, originalName);
+return true;
+}
+void DylibFile::handleLDPreviousSymbol(StringRef name, StringRef originalName) {
+// originalName: $ld$ previous $ <installname> $ <compatversion> $
+// <platformstr> $ <startversion> $ <endversion> $ <symbol-name> $
+StringRef installName;
+StringRef compatVersion;
+StringRef platformStr;
+StringRef startVersion;
+StringRef endVersion;
+StringRef symbolName;
+StringRef rest;
+std::tie(installName, name) = name.split('$');
+std::tie(compatVersion, name) = name.split('$');
+std::tie(platformStr, name) = name.split('$');
+std::tie(startVersion, name) = name.split('$');
+std::tie(endVersion, name) = name.split('$');
+std::tie(symbolName, rest) = name.split('$');
+// TODO: ld64 contains some logic for non-empty symbolName as well.
+if (!symbolName.empty())
+return;
+unsigned platform;
+if (platformStr.getAsInteger(10, platform) ||
+platform != static_cast<unsigned>(config->platform()))
+return;
+VersionTuple start;
+if (start.tryParse(startVersion)) {
+warn("failed to parse start version, symbol '" + originalName +
+"' ignored");
+return;
+}
+VersionTuple end;
+if (end.tryParse(endVersion)) {
+warn("failed to parse end version, symbol '" + originalName + "' ignored");
+return;
+}
+if (config->platformInfo.minimum < start ||
+config->platformInfo.minimum >= end)
+return;
+this->installName = saver.save(installName);
+if (!compatVersion.empty()) {
+VersionTuple cVersion;
+if (cVersion.tryParse(compatVersion)) {
+warn("failed to parse compatibility version, symbol '" + originalName +
+"' ignored");
 return;
 }
-reexported.push_back(make<DylibFile>(*buffer, umbrella));
+compatibilityVersion = encodeVersion(cVersion);
 }
 }
-DylibFile::DylibFile() : InputFile(DylibKind, MemoryBufferRef()) {}
+void DylibFile::handleLDInstallNameSymbol(StringRef name,
+StringRef originalName) {
-DylibFile *DylibFile::createLibSystemMock() {
+// originalName: $ld$ install_name $ os<version> $ install_name
-auto *file = make<DylibFile>();
+StringRef condition, installName;
-file->mb = MemoryBufferRef("", "/usr/lib/libSystem.B.dylib");
+std::tie(condition, installName) = name.split('$');
-file->dylibName = "/usr/lib/libSystem.B.dylib";
+VersionTuple version;
-file->symbols.push_back(symtab->addDylib("dyld_stub_binder", file));
+if (!condition.consume_front("os") || version.tryParse(condition))
-return file;
+warn("failed to parse os version, symbol '" + originalName + "' ignored");
-}
+else if (version == config->platformInfo.minimum)
+this->installName = saver.save(installName);
-ArchiveFile::ArchiveFile(std::unique_ptr<llvm::object::Archive> &&f)
+}
+ArchiveFile::ArchiveFile(std::unique_ptr<object::Archive> &&f)
 : InputFile(ArchiveKind, f->getMemoryBufferRef()), file(std::move(f)) {
 for (const object::Archive::Symbol &sym : file->symbols())
 symtab->addLazy(sym.getName(), this, sym);
 }
 void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
 object::Archive::Child c =
 CHECK(sym.getMember(), toString(this) +
 ": could not get the member for symbol " +
-sym.getName());
+toMachOString(sym));
 if (!seen.insert(c.getChildOffset()).second)
 return;
 MemoryBufferRef mb =
 CHECK(c.getMemoryBufferRef(),
 toString(this) +
 ": could not get the buffer for the member defining symbol " +
-sym.getName());
+toMachOString(sym));
-auto file = make<ObjFile>(mb);
-symbols.insert(symbols.end(), file->symbols.begin(), file->symbols.end());
+if (tar && c.getParent()->isThin())
-subsections.insert(subsections.end(), file->subsections.begin(),
+tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb.getBuffer());
-file->subsections.end());
-}
+uint32_t modTime = toTimeT(
+CHECK(c.getLastModified(), toString(this) +
-// Returns "<internal>" or "baz.o".
+": could not get the modification time "
-std::string lld::toString(const InputFile *file) {
+"for the member defining symbol " +
-return file ? std::string(file->getName()) : "<internal>";
+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;
+if (Optional<InputFile *> file =
+loadArchiveMember(mb, modTime, getName(), /*objCOnly=*/false)) {
+inputFiles.insert(*file);
+// ld64 doesn't demangle sym here even with -demangle.
+// Match that: intentionally don't call toMachOString().
+printArchiveMemberLoad(symCopy.getName(), *file);
+}
+}
+static macho::Symbol *createBitcodeSymbol(const lto::InputFile::Symbol &objSym,
+BitcodeFile &file) {
+StringRef name = saver.save(objSym.getName());
+// TODO: support weak references
+if (objSym.isUndefined())
+return symtab->addUndefined(name, &file, /*isWeakRef=*/false);
+assert(!objSym.isCommon() && "TODO: support common symbols in LTO");
+// TODO: Write a test demonstrating why computing isPrivateExtern before
+// LTO compilation is important.
+bool isPrivateExtern = false;
+switch (objSym.getVisibility()) {
+case GlobalValue::HiddenVisibility:
+isPrivateExtern = true;
+break;
+case GlobalValue::ProtectedVisibility:
+error(name + " has protected visibility, which is not supported by Mach-O");
+break;
+case GlobalValue::DefaultVisibility:
+break;
+}
+return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
+/*size=*/0, objSym.isWeak(), isPrivateExtern,
+/*isThumb=*/false,
+/*isReferencedDynamically=*/false,
+/*noDeadStrip=*/false);
+}
+BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
+: InputFile(BitcodeKind, mbref) {
+obj = check(lto::InputFile::create(mbref));
+// Convert LTO Symbols to LLD Symbols in order to perform resolution. The
+// "winning" symbol will then be marked as Prevailing at LTO compilation
+// time.
+for (const lto::InputFile::Symbol &objSym : obj->symbols())
+symbols.push_back(createBitcodeSymbol(objSym, *this));
+}
+template void ObjFile::parse<LP64>();

Mercurial > hg > CbC > CbC_llvm

comparison lld/MachO/InputFiles.cpp @ 207:2e18cbf3894f