/build/source/lld/MachO/SyntheticSections.cpp

Bug Summary

File:	build/source/lld/MachO/SyntheticSections.cpp
Warning:	line 1887, column 42 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SyntheticSections.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D LLD_VENDOR="Debian" -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lld/MachO -I /build/source/lld/MachO -I /build/source/lld/include -I tools/lld/include -I include -I /build/source/llvm/include -I /build/source/llvm/../libunwind/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/lld/MachO/SyntheticSections.cpp
1//===- SyntheticSections.cpp ---------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "SyntheticSections.h"
10#include "ConcatOutputSection.h"
11#include "Config.h"
12#include "ExportTrie.h"
13#include "InputFiles.h"
14#include "MachOStructs.h"
15#include "OutputSegment.h"
16#include "SymbolTable.h"
17#include "Symbols.h"

19#include "lld/Common/CommonLinkerContext.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/Config/llvm-config.h"
22#include "llvm/Support/EndianStream.h"
23#include "llvm/Support/FileSystem.h"
24#include "llvm/Support/LEB128.h"
25#include "llvm/Support/Parallel.h"
26#include "llvm/Support/Path.h"
27#include "llvm/Support/xxhash.h"

29#if defined(__APPLE__)
30#include <sys/mman.h>

32#define COMMON_DIGEST_FOR_OPENSSL
33#include <CommonCrypto/CommonDigest.h>
34#else
35#include "llvm/Support/SHA256.h"
36#endif

38#ifdef LLVM_HAVE_LIBXAR
39#include <fcntl.h>
40extern "C" {
41#include <xar/xar.h>
42}
43#endif

45using namespace llvm;
46using namespace llvm::MachO;
47using namespace llvm::support;
48using namespace llvm::support::endian;
49using namespace lld;
50using namespace lld::macho;

52// Reads `len` bytes at data and writes the 32-byte SHA256 checksum to `output`.
53static void sha256(const uint8_t *data, size_t len, uint8_t *output) {
54#if defined(__APPLE__)
// FIXME: Make LLVM's SHA256 faster and use it unconditionally. See PR56121
// for some notes on this.
CC_SHA256(data, len, output);
58#else
ArrayRef<uint8_t> block(data, len);
std::array<uint8_t, 32> hash = SHA256::hash(block);
static_assert(hash.size() == CodeSignatureSection::hashSize);
memcpy(output, hash.data(), hash.size());
63#endif
64}

66InStruct macho::in;
67std::vector<SyntheticSection *> macho::syntheticSections;

69SyntheticSection::SyntheticSection(const char *segname, const char *name)
  : OutputSection(SyntheticKind, name) {
std::tie(this->segname, this->name) = maybeRenameSection({segname, name});
isec = makeSyntheticInputSection(segname, name);
isec->parent = this;
syntheticSections.push_back(this);
75}

77// dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
78// from the beginning of the file (i.e. the header).
79MachHeaderSection::MachHeaderSection()
  : SyntheticSection(segment_names::text, section_names::header) {
// XXX: This is a hack. (See D97007)
// Setting the index to 1 to pretend that this section is the text
// section.
index = 1;
isec->isFinal = true;
86}

88void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
loadCommands.push_back(lc);
sizeOfCmds += lc->getSize();
91}

93uint64_t MachHeaderSection::getSize() const {
uint64_t size = target->headerSize + sizeOfCmds + config->headerPad;
// If we are emitting an encryptable binary, our load commands must have a
// separate (non-encrypted) page to themselves.
if (config->emitEncryptionInfo)
  size = alignToPowerOf2(size, target->getPageSize());
return size;
100}

102static uint32_t cpuSubtype() {
uint32_t subtype = target->cpuSubtype;

if (config->outputType == MH_EXECUTE && !config->staticLink &&
    target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
    config->platform() == PLATFORM_MACOS &&
    config->platformInfo.target.MinDeployment >= VersionTuple(10, 5))
  subtype |= CPU_SUBTYPE_LIB64;

return subtype;
112}

114static bool hasWeakBinding() {
return config->emitChainedFixups ? in.chainedFixups->hasWeakBinding()
                                 : in.weakBinding->hasEntry();
117}

119static bool hasNonWeakDefinition() {
return config->emitChainedFixups ? in.chainedFixups->hasNonWeakDefinition()
                                 : in.weakBinding->hasNonWeakDefinition();
122}

124void MachHeaderSection::writeTo(uint8_t *buf) const {
auto *hdr = reinterpret_cast<mach_header *>(buf);
hdr->magic = target->magic;
hdr->cputype = target->cpuType;
hdr->cpusubtype = cpuSubtype();
hdr->filetype = config->outputType;
hdr->ncmds = loadCommands.size();
hdr->sizeofcmds = sizeOfCmds;
hdr->flags = MH_DYLDLINK;

if (config->namespaceKind == NamespaceKind::twolevel)
  hdr->flags |= MH_NOUNDEFS | MH_TWOLEVEL;

if (config->outputType == MH_DYLIB && !config->hasReexports)
  hdr->flags |= MH_NO_REEXPORTED_DYLIBS;

if (config->markDeadStrippableDylib)
  hdr->flags |= MH_DEAD_STRIPPABLE_DYLIB;

if (config->outputType == MH_EXECUTE && config->isPic)
  hdr->flags |= MH_PIE;

if (config->outputType == MH_DYLIB && config->applicationExtension)
  hdr->flags |= MH_APP_EXTENSION_SAFE;

if (in.exports->hasWeakSymbol || hasNonWeakDefinition())
  hdr->flags |= MH_WEAK_DEFINES;

if (in.exports->hasWeakSymbol || hasWeakBinding())
  hdr->flags |= MH_BINDS_TO_WEAK;

for (const OutputSegment *seg : outputSegments) {
  for (const OutputSection *osec : seg->getSections()) {
    if (isThreadLocalVariables(osec->flags)) {
      hdr->flags |= MH_HAS_TLV_DESCRIPTORS;
      break;
    }
  }
}

uint8_t *p = reinterpret_cast<uint8_t *>(hdr) + target->headerSize;
for (const LoadCommand *lc : loadCommands) {
  lc->writeTo(p);
  p += lc->getSize();
}
169}

171PageZeroSection::PageZeroSection()
  : SyntheticSection(segment_names::pageZero, section_names::pageZero) {}

174RebaseSection::RebaseSection()
  : LinkEditSection(segment_names::linkEdit, section_names::rebase) {}

177namespace {
178struct RebaseState {
uint64_t sequenceLength;
uint64_t skipLength;
181};
182} // namespace

184static void emitIncrement(uint64_t incr, raw_svector_ostream &os) {
assert(incr != 0)(static_cast <bool> (incr != 0) ? void (0) : __assert_fail
 ("incr != 0", "lld/MachO/SyntheticSections.cpp", 185, __extension__
 __PRETTY_FUNCTION__));

if ((incr >> target->p2WordSize) <= REBASE_IMMEDIATE_MASK &&
    (incr % target->wordSize) == 0) {
  os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_IMM_SCALED |
                             (incr >> target->p2WordSize));
} else {
  os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_ULEB);
  encodeULEB128(incr, os);
}
195}

197static void flushRebase(const RebaseState &state, raw_svector_ostream &os) {
assert(state.sequenceLength > 0)(static_cast <bool> (state.sequenceLength > 0) ? void
 (0) : __assert_fail ("state.sequenceLength > 0", "lld/MachO/SyntheticSections.cpp"
, 198, __extension__ __PRETTY_FUNCTION__));

if (state.skipLength == target->wordSize) {
  if (state.sequenceLength <= REBASE_IMMEDIATE_MASK) {
    os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_IMM_TIMES |
                               state.sequenceLength);
  } else {
    os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
    encodeULEB128(state.sequenceLength, os);
  }
} else if (state.sequenceLength == 1) {
  os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
  encodeULEB128(state.skipLength - target->wordSize, os);
} else {
  os << static_cast<uint8_t>(
      REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
  encodeULEB128(state.sequenceLength, os);
  encodeULEB128(state.skipLength - target->wordSize, os);
}
217}

219// Rebases are communicated to dyld using a bytecode, whose opcodes cause the
220// memory location at a specific address to be rebased and/or the address to be
221// incremented.
222//
223// Opcode REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB is the most generic
224// one, encoding a series of evenly spaced addresses. This algorithm works by
225// splitting up the sorted list of addresses into such chunks. If the locations
226// are consecutive or the sequence consists of a single location, flushRebase
227// will use a smaller, more specialized encoding.
228static void encodeRebases(const OutputSegment *seg,
                        MutableArrayRef<Location> locations,
                        raw_svector_ostream &os) {
// dyld operates on segments. Translate section offsets into segment offsets.
for (Location &loc : locations)
  loc.offset =
      loc.isec->parent->getSegmentOffset() + loc.isec->getOffset(loc.offset);
// The algorithm assumes that locations are unique.
Location *end =
    llvm::unique(locations, [](const Location &a, const Location &b) {
      return a.offset == b.offset;
    });
size_t count = end - locations.begin();

os << static_cast<uint8_t>(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                           seg->index);
assert(!locations.empty())(static_cast <bool> (!locations.empty()) ? void (0) : __assert_fail
 ("!locations.empty()", "lld/MachO/SyntheticSections.cpp", 244
, __extension__ __PRETTY_FUNCTION__));
uint64_t offset = locations[0].offset;
encodeULEB128(offset, os);

RebaseState state{1, target->wordSize};

for (size_t i = 1; i < count; ++i) {
  offset = locations[i].offset;

  uint64_t skip = offset - locations[i - 1].offset;
  assert(skip != 0 && "duplicate locations should have been weeded out")(static_cast <bool> (skip != 0 && "duplicate locations should have been weeded out"
) ? void (0) : __assert_fail ("skip != 0 && \"duplicate locations should have been weeded out\""
, "lld/MachO/SyntheticSections.cpp", 254, __extension__ __PRETTY_FUNCTION__
));

  if (skip == state.skipLength) {
    ++state.sequenceLength;
  } else if (state.sequenceLength == 1) {
    ++state.sequenceLength;
    state.skipLength = skip;
  } else if (skip < state.skipLength) {
    // The address is lower than what the rebase pointer would be if the last
    // location would be part of a sequence. We start a new sequence from the
    // previous location.
    --state.sequenceLength;
    flushRebase(state, os);

    state.sequenceLength = 2;
    state.skipLength = skip;
  } else {
    // The address is at some positive offset from the rebase pointer. We
    // start a new sequence which begins with the current location.
    flushRebase(state, os);
    emitIncrement(skip - state.skipLength, os);
    state.sequenceLength = 1;
    state.skipLength = target->wordSize;
  }
}
flushRebase(state, os);
280}

282void RebaseSection::finalizeContents() {
if (locations.empty())
  return;

raw_svector_ostream os{contents};
os << static_cast<uint8_t>(REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);

llvm::sort(locations, [](const Location &a, const Location &b) {
  return a.isec->getVA(a.offset) < b.isec->getVA(b.offset);
});

for (size_t i = 0, count = locations.size(); i < count;) {
  const OutputSegment *seg = locations[i].isec->parent->parent;
  size_t j = i + 1;
  while (j < count && locations[j].isec->parent->parent == seg)
    ++j;
  encodeRebases(seg, {locations.data() + i, locations.data() + j}, os);
  i = j;
}
os << static_cast<uint8_t>(REBASE_OPCODE_DONE);
302}

304void RebaseSection::writeTo(uint8_t *buf) const {
memcpy(buf, contents.data(), contents.size());
306}

308NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                   const char *name)
  : SyntheticSection(segname, name) {
align = target->wordSize;
312}

314void macho::addNonLazyBindingEntries(const Symbol *sym,
                                   const InputSection *isec, uint64_t offset,
                                   int64_t addend) {
if (config->emitChainedFixups) {
  if (needsBinding(sym))
    in.chainedFixups->addBinding(sym, isec, offset, addend);
  else if (isa<Defined>(sym))
    in.chainedFixups->addRebase(isec, offset);
  else
    llvm_unreachable("cannot bind to an undefined symbol")::llvm::llvm_unreachable_internal("cannot bind to an undefined symbol"
, "lld/MachO/SyntheticSections.cpp", 323);
  return;
}

if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
  in.binding->addEntry(dysym, isec, offset, addend);
  if (dysym->isWeakDef())
    in.weakBinding->addEntry(sym, isec, offset, addend);
} else if (const auto *defined = dyn_cast<Defined>(sym)) {
  in.rebase->addEntry(isec, offset);
  if (defined->isExternalWeakDef())
    in.weakBinding->addEntry(sym, isec, offset, addend);
  else if (defined->interposable)
    in.binding->addEntry(sym, isec, offset, addend);
} else {
  // Undefined symbols are filtered out in scanRelocations(); we should never
  // get here
  llvm_unreachable("cannot bind to an undefined symbol")::llvm::llvm_unreachable_internal("cannot bind to an undefined symbol"
, "lld/MachO/SyntheticSections.cpp", 340);
}
342}

344void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
if (entries.insert(sym)) {
  assert(!sym->isInGot())(static_cast <bool> (!sym->isInGot()) ? void (0) : __assert_fail
 ("!sym->isInGot()", "lld/MachO/SyntheticSections.cpp", 346
, __extension__ __PRETTY_FUNCTION__));
  sym->gotIndex = entries.size() - 1;

  addNonLazyBindingEntries(sym, isec, sym->gotIndex * target->wordSize);
}
351}

353void macho::writeChainedRebase(uint8_t *buf, uint64_t targetVA) {
assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
 (0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 354, __extension__ __PRETTY_FUNCTION__));
assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
 "Only 64-bit platforms are supported") ? void (0) : __assert_fail
 ("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 355, __extension__ __PRETTY_FUNCTION__
));
auto *rebase = reinterpret_cast<dyld_chained_ptr_64_rebase *>(buf);
rebase->target = targetVA & 0xf'ffff'ffff;
rebase->high8 = (targetVA >> 56);
rebase->reserved = 0;
rebase->next = 0;
rebase->bind = 0;

// The fixup format places a 64 GiB limit on the output's size.
// Should we handle this gracefully?
uint64_t encodedVA = rebase->target | ((uint64_t)rebase->high8 << 56);
if (encodedVA != targetVA)
  error("rebase target address 0x" + Twine::utohexstr(targetVA) +
        " does not fit into chained fixup. Re-link with -no_fixup_chains");
369}

371static void writeChainedBind(uint8_t *buf, const Symbol *sym, int64_t addend) {
assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
 (0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 372, __extension__ __PRETTY_FUNCTION__));
assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
 "Only 64-bit platforms are supported") ? void (0) : __assert_fail
 ("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 373, __extension__ __PRETTY_FUNCTION__
));
auto *bind = reinterpret_cast<dyld_chained_ptr_64_bind *>(buf);
auto [ordinal, inlineAddend] = in.chainedFixups->getBinding(sym, addend);
bind->ordinal = ordinal;
bind->addend = inlineAddend;
bind->reserved = 0;
bind->next = 0;
bind->bind = 1;
381}

383void macho::writeChainedFixup(uint8_t *buf, const Symbol *sym, int64_t addend) {
if (needsBinding(sym))
  writeChainedBind(buf, sym, addend);
else
  writeChainedRebase(buf, sym->getVA() + addend);
388}

390void NonLazyPointerSectionBase::writeTo(uint8_t *buf) const {
if (config->emitChainedFixups) {
  for (const auto &[i, entry] : llvm::enumerate(entries))
    writeChainedFixup(&buf[i * target->wordSize], entry, 0);
} else {
  for (const auto &[i, entry] : llvm::enumerate(entries))
    if (auto *defined = dyn_cast<Defined>(entry))
      write64le(&buf[i * target->wordSize], defined->getVA());
}
399}

401GotSection::GotSection()
  : NonLazyPointerSectionBase(segment_names::data, section_names::got) {
flags = S_NON_LAZY_SYMBOL_POINTERS;
404}

406TlvPointerSection::TlvPointerSection()
  : NonLazyPointerSectionBase(segment_names::data,
                              section_names::threadPtrs) {
flags = S_THREAD_LOCAL_VARIABLE_POINTERS;
410}

412BindingSection::BindingSection()
  : LinkEditSection(segment_names::linkEdit, section_names::binding) {}

415namespace {
416struct Binding {
OutputSegment *segment = nullptr;
uint64_t offset = 0;
int64_t addend = 0;
420};
421struct BindIR {
// Default value of 0xF0 is not valid opcode and should make the program
// scream instead of accidentally writing "valid" values.
uint8_t opcode = 0xF0;
uint64_t data = 0;
uint64_t consecutiveCount = 0;
427};
428} // namespace

430// Encode a sequence of opcodes that tell dyld to write the address of symbol +
431// addend at osec->addr + outSecOff.
432//
433// The bind opcode "interpreter" remembers the values of each binding field, so
434// we only need to encode the differences between bindings. Hence the use of
435// lastBinding.
436static void encodeBinding(const OutputSection *osec, uint64_t outSecOff,
                        int64_t addend, Binding &lastBinding,
                        std::vector<BindIR> &opcodes) {
OutputSegment *seg = osec->parent;
uint64_t offset = osec->getSegmentOffset() + outSecOff;
if (lastBinding.segment != seg) {
  opcodes.push_back(
      {static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                            seg->index),
       offset});
  lastBinding.segment = seg;
  lastBinding.offset = offset;
} else if (lastBinding.offset != offset) {
  opcodes.push_back({BIND_OPCODE_ADD_ADDR_ULEB, offset - lastBinding.offset});
  lastBinding.offset = offset;
}

if (lastBinding.addend != addend) {
  opcodes.push_back(
      {BIND_OPCODE_SET_ADDEND_SLEB, static_cast<uint64_t>(addend)});
  lastBinding.addend = addend;
}

opcodes.push_back({BIND_OPCODE_DO_BIND, 0});
// DO_BIND causes dyld to both perform the binding and increment the offset
lastBinding.offset += target->wordSize;
462}

464static void optimizeOpcodes(std::vector<BindIR> &opcodes) {
// Pass 1: Combine bind/add pairs
size_t i;
int pWrite = 0;
for (i = 1; i < opcodes.size(); ++i, ++pWrite) {
  if ((opcodes[i].opcode == BIND_OPCODE_ADD_ADDR_ULEB) &&
      (opcodes[i - 1].opcode == BIND_OPCODE_DO_BIND)) {
    opcodes[pWrite].opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB;
    opcodes[pWrite].data = opcodes[i].data;
    ++i;
  } else {
    opcodes[pWrite] = opcodes[i - 1];
  }
}
if (i == opcodes.size())
  opcodes[pWrite] = opcodes[i - 1];
opcodes.resize(pWrite + 1);

// Pass 2: Compress two or more bind_add opcodes
pWrite = 0;
for (i = 1; i < opcodes.size(); ++i, ++pWrite) {
  if ((opcodes[i].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
      (opcodes[i - 1].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
      (opcodes[i].data == opcodes[i - 1].data)) {
    opcodes[pWrite].opcode = BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB;
    opcodes[pWrite].consecutiveCount = 2;
    opcodes[pWrite].data = opcodes[i].data;
    ++i;
    while (i < opcodes.size() &&
           (opcodes[i].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
           (opcodes[i].data == opcodes[i - 1].data)) {
      opcodes[pWrite].consecutiveCount++;
      ++i;
    }
  } else {
    opcodes[pWrite] = opcodes[i - 1];
  }
}
if (i == opcodes.size())
  opcodes[pWrite] = opcodes[i - 1];
opcodes.resize(pWrite + 1);

// Pass 3: Use immediate encodings
// Every binding is the size of one pointer. If the next binding is a
// multiple of wordSize away that is within BIND_IMMEDIATE_MASK, the
// opcode can be scaled by wordSize into a single byte and dyld will
// expand it to the correct address.
for (auto &p : opcodes) {
  // It's unclear why the check needs to be less than BIND_IMMEDIATE_MASK,
  // but ld64 currently does this. This could be a potential bug, but
  // for now, perform the same behavior to prevent mysterious bugs.
  if ((p.opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
      ((p.data / target->wordSize) < BIND_IMMEDIATE_MASK) &&
      ((p.data % target->wordSize) == 0)) {
    p.opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED;
    p.data /= target->wordSize;
  }
}
522}

524static void flushOpcodes(const BindIR &op, raw_svector_ostream &os) {
uint8_t opcode = op.opcode & BIND_OPCODE_MASK;
switch (opcode) {
case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
case BIND_OPCODE_ADD_ADDR_ULEB:
case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
  os << op.opcode;
  encodeULEB128(op.data, os);
  break;
case BIND_OPCODE_SET_ADDEND_SLEB:
  os << op.opcode;
  encodeSLEB128(static_cast<int64_t>(op.data), os);
  break;
case BIND_OPCODE_DO_BIND:
  os << op.opcode;
  break;
case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
  os << op.opcode;
  encodeULEB128(op.consecutiveCount, os);
  encodeULEB128(op.data, os);
  break;
case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
  os << static_cast<uint8_t>(op.opcode | op.data);
  break;
default:
  llvm_unreachable("cannot bind to an unrecognized symbol")::llvm::llvm_unreachable_internal("cannot bind to an unrecognized symbol"
, "lld/MachO/SyntheticSections.cpp", 549);
}
551}

553// Non-weak bindings need to have their dylib ordinal encoded as well.
554static int16_t ordinalForDylibSymbol(const DylibSymbol &dysym) {
if (config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup())
  return static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP);
assert(dysym.getFile()->isReferenced())(static_cast <bool> (dysym.getFile()->isReferenced()
) ? void (0) : __assert_fail ("dysym.getFile()->isReferenced()"
, "lld/MachO/SyntheticSections.cpp", 557, __extension__ __PRETTY_FUNCTION__
));
return dysym.getFile()->ordinal;
559}

561static int16_t ordinalForSymbol(const Symbol &sym) {
if (const auto *dysym = dyn_cast<DylibSymbol>(&sym))
  return ordinalForDylibSymbol(*dysym);
assert(cast<Defined>(&sym)->interposable)(static_cast <bool> (cast<Defined>(&sym)->
interposable) ? void (0) : __assert_fail ("cast<Defined>(&sym)->interposable"
, "lld/MachO/SyntheticSections.cpp", 564, __extension__ __PRETTY_FUNCTION__
));
return BIND_SPECIAL_DYLIB_FLAT_LOOKUP;
566}

568static void encodeDylibOrdinal(int16_t ordinal, raw_svector_ostream &os) {
if (ordinal <= 0) {
  os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
                             (ordinal & BIND_IMMEDIATE_MASK));
} else if (ordinal <= BIND_IMMEDIATE_MASK) {
  os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);
} else {
  os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
  encodeULEB128(ordinal, os);
}
578}

580static void encodeWeakOverride(const Defined *defined,
                             raw_svector_ostream &os) {
os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
                           BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
   << defined->getName() << '\0';
585}

587// Organize the bindings so we can encoded them with fewer opcodes.
588//
589// First, all bindings for a given symbol should be grouped together.
590// BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM is the largest opcode (since it
591// has an associated symbol string), so we only want to emit it once per symbol.
592//
593// Within each group, we sort the bindings by address. Since bindings are
594// delta-encoded, sorting them allows for a more compact result. Note that
595// sorting by address alone ensures that bindings for the same segment / section
596// are located together, minimizing the number of times we have to emit
597// BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB.
598//
599// Finally, we sort the symbols by the address of their first binding, again
600// to facilitate the delta-encoding process.
601template <class Sym>
602std::vector<std::pair<const Sym *, std::vector<BindingEntry>>>
603sortBindings(const BindingsMap<const Sym *> &bindingsMap) {
std::vector<std::pair<const Sym *, std::vector<BindingEntry>>> bindingsVec(
    bindingsMap.begin(), bindingsMap.end());
for (auto &p : bindingsVec) {
  std::vector<BindingEntry> &bindings = p.second;
  llvm::sort(bindings, [](const BindingEntry &a, const BindingEntry &b) {
    return a.target.getVA() < b.target.getVA();
  });
}
llvm::sort(bindingsVec, [](const auto &a, const auto &b) {
  return a.second[0].target.getVA() < b.second[0].target.getVA();
});
return bindingsVec;
616}

618// Emit bind opcodes, which are a stream of byte-sized opcodes that dyld
619// interprets to update a record with the following fields:
620//  * segment index (of the segment to write the symbol addresses to, typically
621//    the __DATA_CONST segment which contains the GOT)
622//  * offset within the segment, indicating the next location to write a binding
623//  * symbol type
624//  * symbol library ordinal (the index of its library's LC_LOAD_DYLIB command)
625//  * symbol name
626//  * addend
627// When dyld sees BIND_OPCODE_DO_BIND, it uses the current record state to bind
628// a symbol in the GOT, and increments the segment offset to point to the next
629// entry. It does *not* clear the record state after doing the bind, so
630// subsequent opcodes only need to encode the differences between bindings.
631void BindingSection::finalizeContents() {
raw_svector_ostream os{contents};
Binding lastBinding;
int16_t lastOrdinal = 0;

for (auto &p : sortBindings(bindingsMap)) {
  const Symbol *sym = p.first;
  std::vector<BindingEntry> &bindings = p.second;
  uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
  if (sym->isWeakRef())
    flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
  os << flags << sym->getName() << '\0'
     << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
  int16_t ordinal = ordinalForSymbol(*sym);
  if (ordinal != lastOrdinal) {
    encodeDylibOrdinal(ordinal, os);
    lastOrdinal = ordinal;
  }
  std::vector<BindIR> opcodes;
  for (const BindingEntry &b : bindings)
    encodeBinding(b.target.isec->parent,
                  b.target.isec->getOffset(b.target.offset), b.addend,
                  lastBinding, opcodes);
  if (config->optimize > 1)
    optimizeOpcodes(opcodes);
  for (const auto &op : opcodes)
    flushOpcodes(op, os);
}
if (!bindingsMap.empty())
  os << static_cast<uint8_t>(BIND_OPCODE_DONE);
661}

663void BindingSection::writeTo(uint8_t *buf) const {
memcpy(buf, contents.data(), contents.size());
665}

667WeakBindingSection::WeakBindingSection()
  : LinkEditSection(segment_names::linkEdit, section_names::weakBinding) {}

670void WeakBindingSection::finalizeContents() {
raw_svector_ostream os{contents};
Binding lastBinding;

for (const Defined *defined : definitions)
  encodeWeakOverride(defined, os);

for (auto &p : sortBindings(bindingsMap)) {
  const Symbol *sym = p.first;
  std::vector<BindingEntry> &bindings = p.second;
  os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
     << sym->getName() << '\0'
     << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
  std::vector<BindIR> opcodes;
  for (const BindingEntry &b : bindings)
    encodeBinding(b.target.isec->parent,
                  b.target.isec->getOffset(b.target.offset), b.addend,
                  lastBinding, opcodes);
  if (config->optimize > 1)
    optimizeOpcodes(opcodes);
  for (const auto &op : opcodes)
    flushOpcodes(op, os);
}
if (!bindingsMap.empty() || !definitions.empty())
  os << static_cast<uint8_t>(BIND_OPCODE_DONE);
695}

697void WeakBindingSection::writeTo(uint8_t *buf) const {
memcpy(buf, contents.data(), contents.size());
699}

701StubsSection::StubsSection()
  : SyntheticSection(segment_names::text, section_names::stubs) {
flags = S_SYMBOL_STUBS | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
// The stubs section comprises machine instructions, which are aligned to
// 4 bytes on the archs we care about.
align = 4;
reserved2 = target->stubSize;
708}

710uint64_t StubsSection::getSize() const {
return entries.size() * target->stubSize;
712}

714void StubsSection::writeTo(uint8_t *buf) const {
size_t off = 0;
for (const Symbol *sym : entries) {
  uint64_t pointerVA =
      config->emitChainedFixups ? sym->getGotVA() : sym->getLazyPtrVA();
  target->writeStub(buf + off, *sym, pointerVA);
  off += target->stubSize;
}
722}

724void StubsSection::finalize() { isFinal = true; }

726static void addBindingsForStub(Symbol *sym) {
assert(!config->emitChainedFixups)(static_cast <bool> (!config->emitChainedFixups) ? void
 (0) : __assert_fail ("!config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 727, __extension__ __PRETTY_FUNCTION__));
if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
  if (sym->isWeakDef()) {
    in.binding->addEntry(dysym, in.lazyPointers->isec,
                         sym->stubsIndex * target->wordSize);
    in.weakBinding->addEntry(sym, in.lazyPointers->isec,
                             sym->stubsIndex * target->wordSize);
  } else {
    in.lazyBinding->addEntry(dysym);
  }
} else if (auto *defined = dyn_cast<Defined>(sym)) {
  if (defined->isExternalWeakDef()) {
    in.rebase->addEntry(in.lazyPointers->isec,
                        sym->stubsIndex * target->wordSize);
    in.weakBinding->addEntry(sym, in.lazyPointers->isec,
                             sym->stubsIndex * target->wordSize);
  } else if (defined->interposable) {
    in.lazyBinding->addEntry(sym);
  } else {
    llvm_unreachable("invalid stub target")::llvm::llvm_unreachable_internal("invalid stub target", "lld/MachO/SyntheticSections.cpp"
, 746);
  }
} else {
  llvm_unreachable("invalid stub target symbol type")::llvm::llvm_unreachable_internal("invalid stub target symbol type"
, "lld/MachO/SyntheticSections.cpp", 749);
}
751}

753void StubsSection::addEntry(Symbol *sym) {
bool inserted = entries.insert(sym);
if (inserted) {
  sym->stubsIndex = entries.size() - 1;

  if (config->emitChainedFixups)
    in.got->addEntry(sym);
  else
    addBindingsForStub(sym);
}
763}

765StubHelperSection::StubHelperSection()
  : SyntheticSection(segment_names::text, section_names::stubHelper) {
flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
align = 4; // This section comprises machine instructions
769}

771uint64_t StubHelperSection::getSize() const {
return target->stubHelperHeaderSize +
       in.lazyBinding->getEntries().size() * target->stubHelperEntrySize;
774}

776bool StubHelperSection::isNeeded() const { return in.lazyBinding->isNeeded(); }

778void StubHelperSection::writeTo(uint8_t *buf) const {
target->writeStubHelperHeader(buf);
size_t off = target->stubHelperHeaderSize;
for (const Symbol *sym : in.lazyBinding->getEntries()) {
  target->writeStubHelperEntry(buf + off, *sym, addr + off);
  off += target->stubHelperEntrySize;
}
785}

787void StubHelperSection::setUp() {
Symbol *binder = symtab->addUndefined("dyld_stub_binder", /*file=*/nullptr,
                                      /*isWeakRef=*/false);
if (auto *undefined = dyn_cast<Undefined>(binder))
  treatUndefinedSymbol(*undefined,
                       "lazy binding (normally in libSystem.dylib)");

// treatUndefinedSymbol() can replace binder with a DylibSymbol; re-check.
stubBinder = dyn_cast_or_null<DylibSymbol>(binder);
if (stubBinder == nullptr)
  return;

in.got->addEntry(stubBinder);

in.imageLoaderCache->parent =
    ConcatOutputSection::getOrCreateForInput(in.imageLoaderCache);
inputSections.push_back(in.imageLoaderCache);
// Since this isn't in the symbol table or in any input file, the noDeadStrip
// argument doesn't matter.
dyldPrivate =
    make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                  /*isWeakDef=*/false,
                  /*isExternal=*/false, /*isPrivateExtern=*/false,
                  /*includeInSymtab=*/true,
                  /*isThumb=*/false, /*isReferencedDynamically=*/false,
                  /*noDeadStrip=*/false);
dyldPrivate->used = true;
814}

816ObjCStubsSection::ObjCStubsSection()
  : SyntheticSection(segment_names::text, section_names::objcStubs) {
flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
align = target->objcStubsAlignment;
820}

822void ObjCStubsSection::addEntry(Symbol *sym) {
assert(sym->getName().startswith(symbolPrefix) && "not an objc stub")(static_cast <bool> (sym->getName().startswith(symbolPrefix
) && "not an objc stub") ? void (0) : __assert_fail (
"sym->getName().startswith(symbolPrefix) && \"not an objc stub\""
, "lld/MachO/SyntheticSections.cpp", 823, __extension__ __PRETTY_FUNCTION__
));
StringRef methname = sym->getName().drop_front(symbolPrefix.size());
offsets.push_back(
    in.objcMethnameSection->getStringOffset(methname).outSecOff);
Defined *newSym = replaceSymbol<Defined>(
    sym, sym->getName(), nullptr, isec,
    /*value=*/symbols.size() * target->objcStubsFastSize,
    /*size=*/target->objcStubsFastSize,
    /*isWeakDef=*/false, /*isExternal=*/true, /*isPrivateExtern=*/true,
    /*includeInSymtab=*/true, /*isThumb=*/false,
    /*isReferencedDynamically=*/false, /*noDeadStrip=*/false);
symbols.push_back(newSym);
835}

837void ObjCStubsSection::setUp() {
Symbol *objcMsgSend = symtab->addUndefined("_objc_msgSend", /*file=*/nullptr,
                                           /*isWeakRef=*/false);
objcMsgSend->used = true;
in.got->addEntry(objcMsgSend);
assert(objcMsgSend->isInGot())(static_cast <bool> (objcMsgSend->isInGot()) ? void (
0) : __assert_fail ("objcMsgSend->isInGot()", "lld/MachO/SyntheticSections.cpp"
, 842, __extension__ __PRETTY_FUNCTION__));
objcMsgSendGotIndex = objcMsgSend->gotIndex;

size_t size = offsets.size() * target->wordSize;
uint8_t *selrefsData = bAlloc().Allocate<uint8_t>(size);
for (size_t i = 0, n = offsets.size(); i < n; ++i)
  write64le(&selrefsData[i * target->wordSize], offsets[i]);

in.objcSelrefs =
    makeSyntheticInputSection(segment_names::data, section_names::objcSelrefs,
                              S_LITERAL_POINTERS | S_ATTR_NO_DEAD_STRIP,
                              ArrayRef<uint8_t>{selrefsData, size},
                              /*align=*/target->wordSize);
in.objcSelrefs->live = true;

for (size_t i = 0, n = offsets.size(); i < n; ++i) {
  in.objcSelrefs->relocs.push_back(
      {/*type=*/target->unsignedRelocType,
       /*pcrel=*/false, /*length=*/3,
       /*offset=*/static_cast<uint32_t>(i * target->wordSize),
       /*addend=*/offsets[i] * in.objcMethnameSection->align,
       /*referent=*/in.objcMethnameSection->isec});
}

in.objcSelrefs->parent =
    ConcatOutputSection::getOrCreateForInput(in.objcSelrefs);
inputSections.push_back(in.objcSelrefs);
in.objcSelrefs->isFinal = true;
870}

872uint64_t ObjCStubsSection::getSize() const {
return target->objcStubsFastSize * symbols.size();
874}

876void ObjCStubsSection::writeTo(uint8_t *buf) const {
assert(in.objcSelrefs->live)(static_cast <bool> (in.objcSelrefs->live) ? void (0
) : __assert_fail ("in.objcSelrefs->live", "lld/MachO/SyntheticSections.cpp"
, 877, __extension__ __PRETTY_FUNCTION__));
assert(in.objcSelrefs->isFinal)(static_cast <bool> (in.objcSelrefs->isFinal) ? void
 (0) : __assert_fail ("in.objcSelrefs->isFinal", "lld/MachO/SyntheticSections.cpp"
, 878, __extension__ __PRETTY_FUNCTION__));

uint64_t stubOffset = 0;
for (size_t i = 0, n = symbols.size(); i < n; ++i) {
  Defined *sym = symbols[i];
  target->writeObjCMsgSendStub(buf + stubOffset, sym, in.objcStubs->addr,
                               stubOffset, in.objcSelrefs->getVA(), i,
                               in.got->addr, objcMsgSendGotIndex);
  stubOffset += target->objcStubsFastSize;
}
888}

890LazyPointerSection::LazyPointerSection()
  : SyntheticSection(segment_names::data, section_names::lazySymbolPtr) {
align = target->wordSize;
flags = S_LAZY_SYMBOL_POINTERS;
894}

896uint64_t LazyPointerSection::getSize() const {
return in.stubs->getEntries().size() * target->wordSize;
898}

900bool LazyPointerSection::isNeeded() const {
return !in.stubs->getEntries().empty();
902}

904void LazyPointerSection::writeTo(uint8_t *buf) const {
size_t off = 0;
for (const Symbol *sym : in.stubs->getEntries()) {
  if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
    if (dysym->hasStubsHelper()) {
      uint64_t stubHelperOffset =
          target->stubHelperHeaderSize +
          dysym->stubsHelperIndex * target->stubHelperEntrySize;
      write64le(buf + off, in.stubHelper->addr + stubHelperOffset);
    }
  } else {
    write64le(buf + off, sym->getVA());
  }
  off += target->wordSize;
}
919}

921LazyBindingSection::LazyBindingSection()
  : LinkEditSection(segment_names::linkEdit, section_names::lazyBinding) {}

924void LazyBindingSection::finalizeContents() {
// TODO: Just precompute output size here instead of writing to a temporary
// buffer
for (Symbol *sym : entries)
  sym->lazyBindOffset = encode(*sym);
929}

931void LazyBindingSection::writeTo(uint8_t *buf) const {
memcpy(buf, contents.data(), contents.size());
933}

935void LazyBindingSection::addEntry(Symbol *sym) {
assert(!config->emitChainedFixups && "Chained fixups always bind eagerly")(static_cast <bool> (!config->emitChainedFixups &&
 "Chained fixups always bind eagerly") ? void (0) : __assert_fail
 ("!config->emitChainedFixups && \"Chained fixups always bind eagerly\""
, "lld/MachO/SyntheticSections.cpp", 936, __extension__ __PRETTY_FUNCTION__
));
if (entries.insert(sym)) {
  sym->stubsHelperIndex = entries.size() - 1;
  in.rebase->addEntry(in.lazyPointers->isec,
                      sym->stubsIndex * target->wordSize);
}
942}

944// Unlike the non-lazy binding section, the bind opcodes in this section aren't
945// interpreted all at once. Rather, dyld will start interpreting opcodes at a
946// given offset, typically only binding a single symbol before it finds a
947// BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
948// we cannot encode just the differences between symbols; we have to emit the
949// complete bind information for each symbol.
950uint32_t LazyBindingSection::encode(const Symbol &sym) {
uint32_t opstreamOffset = contents.size();
OutputSegment *dataSeg = in.lazyPointers->parent;
os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                           dataSeg->index);
uint64_t offset =
    in.lazyPointers->addr - dataSeg->addr + sym.stubsIndex * target->wordSize;
encodeULEB128(offset, os);
encodeDylibOrdinal(ordinalForSymbol(sym), os);

uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
if (sym.isWeakRef())
  flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;

os << flags << sym.getName() << '\0'
   << static_cast<uint8_t>(BIND_OPCODE_DO_BIND)
   << static_cast<uint8_t>(BIND_OPCODE_DONE);
return opstreamOffset;
968}

970ExportSection::ExportSection()
  : LinkEditSection(segment_names::linkEdit, section_names::export_) {}

973void ExportSection::finalizeContents() {
trieBuilder.setImageBase(in.header->addr);
for (const Symbol *sym : symtab->getSymbols()) {
  if (const auto *defined = dyn_cast<Defined>(sym)) {
    if (defined->privateExtern || !defined->isLive())
      continue;
    trieBuilder.addSymbol(*defined);
    hasWeakSymbol = hasWeakSymbol || sym->isWeakDef();
  } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
    if (dysym->shouldReexport)
      trieBuilder.addSymbol(*dysym);
  }
}
size = trieBuilder.build();
987}

989void ExportSection::writeTo(uint8_t *buf) const { trieBuilder.writeTo(buf); }

991DataInCodeSection::DataInCodeSection()
  : LinkEditSection(segment_names::linkEdit, section_names::dataInCode) {}

994template <class LP>
995static std::vector<MachO::data_in_code_entry> collectDataInCodeEntries() {
std::vector<MachO::data_in_code_entry> dataInCodeEntries;
for (const InputFile *inputFile : inputFiles) {
  if (!isa<ObjFile>(inputFile))
    continue;
  const ObjFile *objFile = cast<ObjFile>(inputFile);
  ArrayRef<MachO::data_in_code_entry> entries = objFile->getDataInCode();
  if (entries.empty())
    continue;

  assert(is_sorted(entries, [](const data_in_code_entry &lhs,(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
 &lhs, const data_in_code_entry &rhs) { return lhs.offset
 < rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
                               const data_in_code_entry &rhs) {(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
 &lhs, const data_in_code_entry &rhs) { return lhs.offset
 < rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
    return lhs.offset < rhs.offset;(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
 &lhs, const data_in_code_entry &rhs) { return lhs.offset
 < rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
  }))(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
 &lhs, const data_in_code_entry &rhs) { return lhs.offset
 < rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
));
  // For each code subsection find 'data in code' entries residing in it.
  // Compute the new offset values as
  // <offset within subsection> + <subsection address> - <__TEXT address>.
  for (const Section *section : objFile->sections) {
    for (const Subsection &subsec : section->subsections) {
      const InputSection *isec = subsec.isec;
      if (!isCodeSection(isec))
        continue;
      if (cast<ConcatInputSection>(isec)->shouldOmitFromOutput())
        continue;
      const uint64_t beginAddr = section->addr + subsec.offset;
      auto it = llvm::lower_bound(
          entries, beginAddr,
          [](const MachO::data_in_code_entry &entry, uint64_t addr) {
            return entry.offset < addr;
          });
      const uint64_t endAddr = beginAddr + isec->getSize();
      for (const auto end = entries.end();
           it != end && it->offset + it->length <= endAddr; ++it)
        dataInCodeEntries.push_back(
            {static_cast<uint32_t>(isec->getVA(it->offset - beginAddr) -
                                   in.header->addr),
             it->length, it->kind});
    }
  }
}

// ld64 emits the table in sorted order too.
llvm::sort(dataInCodeEntries,
           [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) {
             return lhs.offset < rhs.offset;
           });
return dataInCodeEntries;
1042}

1044void DataInCodeSection::finalizeContents() {
entries = target->wordSize == 8 ? collectDataInCodeEntries<LP64>()
                                : collectDataInCodeEntries<ILP32>();
1047}

1049void DataInCodeSection::writeTo(uint8_t *buf) const {
if (!entries.empty())
  memcpy(buf, entries.data(), getRawSize());
1052}

1054FunctionStartsSection::FunctionStartsSection()
  : LinkEditSection(segment_names::linkEdit, section_names::functionStarts) {}

1057void FunctionStartsSection::finalizeContents() {
raw_svector_ostream os{contents};
std::vector<uint64_t> addrs;
for (const InputFile *file : inputFiles) {
  if (auto *objFile = dyn_cast<ObjFile>(file)) {
    for (const Symbol *sym : objFile->symbols) {
      if (const auto *defined = dyn_cast_or_null<Defined>(sym)) {
        if (!defined->isec || !isCodeSection(defined->isec) ||
            !defined->isLive())
          continue;
        // TODO: Add support for thumbs, in that case
        // the lowest bit of nextAddr needs to be set to 1.
        addrs.push_back(defined->getVA());
      }
    }
  }
}
llvm::sort(addrs);
uint64_t addr = in.header->addr;
for (uint64_t nextAddr : addrs) {
  uint64_t delta = nextAddr - addr;
  if (delta == 0)
    continue;
  encodeULEB128(delta, os);
  addr = nextAddr;
}
os << '\0';
1084}

1086void FunctionStartsSection::writeTo(uint8_t *buf) const {
memcpy(buf, contents.data(), contents.size());
1088}

1090SymtabSection::SymtabSection(StringTableSection &stringTableSection)
  : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
    stringTableSection(stringTableSection) {}

1094void SymtabSection::emitBeginSourceStab(StringRef sourceFile) {
StabsEntry stab(N_SO);
stab.strx = stringTableSection.addString(saver().save(sourceFile));
stabs.emplace_back(std::move(stab));
1098}

1100void SymtabSection::emitEndSourceStab() {
StabsEntry stab(N_SO);
stab.sect = 1;
stabs.emplace_back(std::move(stab));
1104}

1106void SymtabSection::emitObjectFileStab(ObjFile *file) {
StabsEntry stab(N_OSO);
stab.sect = target->cpuSubtype;
SmallString<261> path(!file->archiveName.empty() ? file->archiveName
                                                 : file->getName());
std::error_code ec = sys::fs::make_absolute(path);
if (ec)
  fatal("failed to get absolute path for " + path);

if (!file->archiveName.empty())
  path.append({"(", file->getName(), ")"});

StringRef adjustedPath = saver().save(path.str());
adjustedPath.consume_front(config->osoPrefix);

stab.strx = stringTableSection.addString(adjustedPath);
stab.desc = 1;
stab.value = file->modTime;
stabs.emplace_back(std::move(stab));
1125}

1127void SymtabSection::emitEndFunStab(Defined *defined) {
StabsEntry stab(N_FUN);
stab.value = defined->size;
stabs.emplace_back(std::move(stab));
1131}

1133void SymtabSection::emitStabs() {
if (config->omitDebugInfo)
  return;

for (const std::string &s : config->astPaths) {
  StabsEntry astStab(N_AST);
  astStab.strx = stringTableSection.addString(s);
  stabs.emplace_back(std::move(astStab));
}

// Cache the file ID for each symbol in an std::pair for faster sorting.
using SortingPair = std::pair<Defined *, int>;
std::vector<SortingPair> symbolsNeedingStabs;
for (const SymtabEntry &entry :
     concat<SymtabEntry>(localSymbols, externalSymbols)) {
  Symbol *sym = entry.sym;
  assert(sym->isLive() &&(static_cast <bool> (sym->isLive() && "dead symbols should not be in localSymbols, externalSymbols"
) ? void (0) : __assert_fail ("sym->isLive() && \"dead symbols should not be in localSymbols, externalSymbols\""
, "lld/MachO/SyntheticSections.cpp", 1150, __extension__ __PRETTY_FUNCTION__
))
         "dead symbols should not be in localSymbols, externalSymbols")(static_cast <bool> (sym->isLive() && "dead symbols should not be in localSymbols, externalSymbols"
) ? void (0) : __assert_fail ("sym->isLive() && \"dead symbols should not be in localSymbols, externalSymbols\""
, "lld/MachO/SyntheticSections.cpp", 1150, __extension__ __PRETTY_FUNCTION__
));
  if (auto *defined = dyn_cast<Defined>(sym)) {
    // Excluded symbols should have been filtered out in finalizeContents().
    assert(defined->includeInSymtab)(static_cast <bool> (defined->includeInSymtab) ? void
 (0) : __assert_fail ("defined->includeInSymtab", "lld/MachO/SyntheticSections.cpp"
, 1153, __extension__ __PRETTY_FUNCTION__));

    if (defined->isAbsolute())
      continue;

    // Constant-folded symbols go in the executable's symbol table, but don't
    // get a stabs entry.
    if (defined->wasIdenticalCodeFolded)
      continue;

    ObjFile *file = defined->getObjectFile();
    if (!file || !file->compileUnit)
      continue;

    symbolsNeedingStabs.emplace_back(defined, defined->isec->getFile()->id);
  }
}

llvm::stable_sort(symbolsNeedingStabs,
                  [&](const SortingPair &a, const SortingPair &b) {
                    return a.second < b.second;
                  });

// Emit STABS symbols so that dsymutil and/or the debugger can map address
// regions in the final binary to the source and object files from which they
// originated.
InputFile *lastFile = nullptr;
for (SortingPair &pair : symbolsNeedingStabs) {
  Defined *defined = pair.first;
  InputSection *isec = defined->isec;
  ObjFile *file = cast<ObjFile>(isec->getFile());

  if (lastFile == nullptr || lastFile != file) {
    if (lastFile != nullptr)
      emitEndSourceStab();
    lastFile = file;

    emitBeginSourceStab(file->sourceFile());
    emitObjectFileStab(file);
  }

  StabsEntry symStab;
  symStab.sect = defined->isec->parent->index;
  symStab.strx = stringTableSection.addString(defined->getName());
  symStab.value = defined->getVA();

  if (isCodeSection(isec)) {
    symStab.type = N_FUN;
    stabs.emplace_back(std::move(symStab));
    emitEndFunStab(defined);
  } else {
    symStab.type = defined->isExternal() ? N_GSYM : N_STSYM;
    stabs.emplace_back(std::move(symStab));
  }
}

if (!stabs.empty())
  emitEndSourceStab();
1211}

1213void SymtabSection::finalizeContents() {
auto addSymbol = [&](std::vector<SymtabEntry> &symbols, Symbol *sym) {
  uint32_t strx = stringTableSection.addString(sym->getName());
  symbols.push_back({sym, strx});
};

std::function<void(Symbol *)> localSymbolsHandler;
switch (config->localSymbolsPresence) {
case SymtabPresence::All:
  localSymbolsHandler = [&](Symbol *sym) { addSymbol(localSymbols, sym); };
  break;
case SymtabPresence::None:
  localSymbolsHandler = [&](Symbol *) { /* Do nothing*/ };
  break;
case SymtabPresence::SelectivelyIncluded:
  localSymbolsHandler = [&](Symbol *sym) {
    if (config->localSymbolPatterns.match(sym->getName()))
      addSymbol(localSymbols, sym);
  };
  break;
case SymtabPresence::SelectivelyExcluded:
  localSymbolsHandler = [&](Symbol *sym) {
    if (!config->localSymbolPatterns.match(sym->getName()))
      addSymbol(localSymbols, sym);
  };
  break;
}

// Local symbols aren't in the SymbolTable, so we walk the list of object
// files to gather them.
// But if `-x` is set, then we don't need to. localSymbolsHandler() will do
// the right thing regardless, but this check is a perf optimization because
// iterating through all the input files and their symbols is expensive.
if (config->localSymbolsPresence != SymtabPresence::None) {
  for (const InputFile *file : inputFiles) {
    if (auto *objFile = dyn_cast<ObjFile>(file)) {
      for (Symbol *sym : objFile->symbols) {
        if (auto *defined = dyn_cast_or_null<Defined>(sym)) {
          if (defined->isExternal() || !defined->isLive() ||
              !defined->includeInSymtab)
            continue;
          localSymbolsHandler(sym);
        }
      }
    }
  }
}

// __dyld_private is a local symbol too. It's linker-created and doesn't
// exist in any object file.
if (in.stubHelper && in.stubHelper->dyldPrivate)
  localSymbolsHandler(in.stubHelper->dyldPrivate);

for (Symbol *sym : symtab->getSymbols()) {
  if (!sym->isLive())
    continue;
  if (auto *defined = dyn_cast<Defined>(sym)) {
    if (!defined->includeInSymtab)
      continue;
    assert(defined->isExternal())(static_cast <bool> (defined->isExternal()) ? void (
0) : __assert_fail ("defined->isExternal()", "lld/MachO/SyntheticSections.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__));
    if (defined->privateExtern)
      localSymbolsHandler(defined);
    else
      addSymbol(externalSymbols, defined);
  } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
    if (dysym->isReferenced())
      addSymbol(undefinedSymbols, sym);
  }
}

emitStabs();
uint32_t symtabIndex = stabs.size();
for (const SymtabEntry &entry :
     concat<SymtabEntry>(localSymbols, externalSymbols, undefinedSymbols)) {
  entry.sym->symtabIndex = symtabIndex++;
}
1289}

1291uint32_t SymtabSection::getNumSymbols() const {
return stabs.size() + localSymbols.size() + externalSymbols.size() +
       undefinedSymbols.size();
1294}

1296// This serves to hide (type-erase) the template parameter from SymtabSection.
1297template <class LP> class SymtabSectionImpl final : public SymtabSection {
1298public:
SymtabSectionImpl(StringTableSection &stringTableSection)
    : SymtabSection(stringTableSection) {}
uint64_t getRawSize() const override;
void writeTo(uint8_t *buf) const override;
1303};

1305template <class LP> uint64_t SymtabSectionImpl<LP>::getRawSize() const {
return getNumSymbols() * sizeof(typename LP::nlist);
1307}

1309template <class LP> void SymtabSectionImpl<LP>::writeTo(uint8_t *buf) const {
auto *nList = reinterpret_cast<typename LP::nlist *>(buf);
// Emit the stabs entries before the "real" symbols. We cannot emit them
// after as that would render Symbol::symtabIndex inaccurate.
for (const StabsEntry &entry : stabs) {
  nList->n_strx = entry.strx;
  nList->n_type = entry.type;
  nList->n_sect = entry.sect;
  nList->n_desc = entry.desc;
  nList->n_value = entry.value;
  ++nList;
}

for (const SymtabEntry &entry : concat<const SymtabEntry>(
         localSymbols, externalSymbols, undefinedSymbols)) {
  nList->n_strx = entry.strx;
  // TODO populate n_desc with more flags
  if (auto *defined = dyn_cast<Defined>(entry.sym)) {
    uint8_t scope = 0;
    if (defined->privateExtern) {
      // Private external -- dylib scoped symbol.
      // Promote to non-external at link time.
      scope = N_PEXT;
    } else if (defined->isExternal()) {
      // Normal global symbol.
      scope = N_EXT;
    } else {
      // TU-local symbol from localSymbols.
      scope = 0;
    }

    if (defined->isAbsolute()) {
      nList->n_type = scope | N_ABS;
      nList->n_sect = NO_SECT;
      nList->n_value = defined->value;
    } else {
      nList->n_type = scope | N_SECT;
      nList->n_sect = defined->isec->parent->index;
      // For the N_SECT symbol type, n_value is the address of the symbol
      nList->n_value = defined->getVA();
    }
    nList->n_desc |= defined->thumb ? N_ARM_THUMB_DEF : 0;
    nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
    nList->n_desc |=
        defined->referencedDynamically ? REFERENCED_DYNAMICALLY : 0;
  } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
    uint16_t n_desc = nList->n_desc;
    int16_t ordinal = ordinalForDylibSymbol(*dysym);
    if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
      SET_LIBRARY_ORDINAL(n_desc, DYNAMIC_LOOKUP_ORDINAL);
    else if (ordinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)
      SET_LIBRARY_ORDINAL(n_desc, EXECUTABLE_ORDINAL);
    else {
      assert(ordinal > 0)(static_cast <bool> (ordinal > 0) ? void (0) : __assert_fail
 ("ordinal > 0", "lld/MachO/SyntheticSections.cpp", 1362, __extension__
 __PRETTY_FUNCTION__));
      SET_LIBRARY_ORDINAL(n_desc, static_cast<uint8_t>(ordinal));
    }

    nList->n_type = N_EXT;
    n_desc |= dysym->isWeakDef() ? N_WEAK_DEF : 0;
    n_desc |= dysym->isWeakRef() ? N_WEAK_REF : 0;
    nList->n_desc = n_desc;
  }
  ++nList;
}
1373}

1375template <class LP>
1376SymtabSection *
1377macho::makeSymtabSection(StringTableSection &stringTableSection) {
return make<SymtabSectionImpl<LP>>(stringTableSection);
1379}

1381IndirectSymtabSection::IndirectSymtabSection()
  : LinkEditSection(segment_names::linkEdit,
                    section_names::indirectSymbolTable) {}

1385uint32_t IndirectSymtabSection::getNumSymbols() const {
uint32_t size = in.got->getEntries().size() +
                in.tlvPointers->getEntries().size() +
                in.stubs->getEntries().size();
if (!config->emitChainedFixups)
  size += in.stubs->getEntries().size();
return size;
1392}

1394bool IndirectSymtabSection::isNeeded() const {
return in.got->isNeeded() || in.tlvPointers->isNeeded() ||
       in.stubs->isNeeded();
1397}

1399void IndirectSymtabSection::finalizeContents() {
uint32_t off = 0;
in.got->reserved1 = off;
off += in.got->getEntries().size();
in.tlvPointers->reserved1 = off;
off += in.tlvPointers->getEntries().size();
in.stubs->reserved1 = off;
if (in.lazyPointers) {
  off += in.stubs->getEntries().size();
  in.lazyPointers->reserved1 = off;
}
1410}

1412static uint32_t indirectValue(const Symbol *sym) {
if (sym->symtabIndex == UINT32_MAX(4294967295U))
  return INDIRECT_SYMBOL_LOCAL;
if (auto *defined = dyn_cast<Defined>(sym))
  if (defined->privateExtern)
    return INDIRECT_SYMBOL_LOCAL;
return sym->symtabIndex;
1419}

1421void IndirectSymtabSection::writeTo(uint8_t *buf) const {
uint32_t off = 0;
for (const Symbol *sym : in.got->getEntries()) {
  write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
  ++off;
}
for (const Symbol *sym : in.tlvPointers->getEntries()) {
  write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
  ++off;
}
for (const Symbol *sym : in.stubs->getEntries()) {
  write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
  ++off;
}

if (in.lazyPointers) {
  // There is a 1:1 correspondence between stubs and LazyPointerSection
  // entries. But giving __stubs and __la_symbol_ptr the same reserved1
  // (the offset into the indirect symbol table) so that they both refer
  // to the same range of offsets confuses `strip`, so write the stubs
  // symbol table offsets a second time.
  for (const Symbol *sym : in.stubs->getEntries()) {
    write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
    ++off;
  }
}
1447}

1449StringTableSection::StringTableSection()
  : LinkEditSection(segment_names::linkEdit, section_names::stringTable) {}

1452uint32_t StringTableSection::addString(StringRef str) {
uint32_t strx = size;
strings.push_back(str); // TODO: consider deduplicating strings
size += str.size() + 1; // account for null terminator
return strx;
1457}

1459void StringTableSection::writeTo(uint8_t *buf) const {
uint32_t off = 0;
for (StringRef str : strings) {
  memcpy(buf + off, str.data(), str.size());
  off += str.size() + 1; // account for null terminator
}
1465}

1467static_assert((CodeSignatureSection::blobHeadersSize % 8) == 0);
1468static_assert((CodeSignatureSection::fixedHeadersSize % 8) == 0);

1470CodeSignatureSection::CodeSignatureSection()
  : LinkEditSection(segment_names::linkEdit, section_names::codeSignature) {
align = 16; // required by libstuff
// FIXME: Consider using finalOutput instead of outputFile.
fileName = config->outputFile;
size_t slashIndex = fileName.rfind("/");
if (slashIndex != std::string::npos)
  fileName = fileName.drop_front(slashIndex + 1);

// NOTE: Any changes to these calculations should be repeated
// in llvm-objcopy's MachOLayoutBuilder::layoutTail.
allHeadersSize = alignTo<16>(fixedHeadersSize + fileName.size() + 1);
fileNamePad = allHeadersSize - fixedHeadersSize - fileName.size();
1483}

1485uint32_t CodeSignatureSection::getBlockCount() const {
return (fileOff + blockSize - 1) / blockSize;
1487}

1489uint64_t CodeSignatureSection::getRawSize() const {
return allHeadersSize + getBlockCount() * hashSize;
1491}

1493void CodeSignatureSection::writeHashes(uint8_t *buf) const {
// NOTE: Changes to this functionality should be repeated in llvm-objcopy's
// MachOWriter::writeSignatureData.
uint8_t *hashes = buf + fileOff + allHeadersSize;
parallelFor(0, getBlockCount(), [&](size_t i) {
  sha256(buf + i * blockSize,
         std::min(static_cast<size_t>(fileOff - i * blockSize), blockSize),
         hashes + i * hashSize);
});
1502#if defined(__APPLE__)
// This is macOS-specific work-around and makes no sense for any
// other host OS. See https://openradar.appspot.com/FB8914231
//
// The macOS kernel maintains a signature-verification cache to
// quickly validate applications at time of execve(2).  The trouble
// is that for the kernel creates the cache entry at the time of the
// mmap(2) call, before we have a chance to write either the code to
// sign or the signature header+hashes.  The fix is to invalidate
// all cached data associated with the output file, thus discarding
// the bogus prematurely-cached signature.
msync(buf, fileOff + getSize(), MS_INVALIDATE);
1514#endif
1515}

1517void CodeSignatureSection::writeTo(uint8_t *buf) const {
// NOTE: Changes to this functionality should be repeated in llvm-objcopy's
// MachOWriter::writeSignatureData.
uint32_t signatureSize = static_cast<uint32_t>(getSize());
auto *superBlob = reinterpret_cast<CS_SuperBlob *>(buf);
write32be(&superBlob->magic, CSMAGIC_EMBEDDED_SIGNATURE);
write32be(&superBlob->length, signatureSize);
write32be(&superBlob->count, 1);
auto *blobIndex = reinterpret_cast<CS_BlobIndex *>(&superBlob[1]);
write32be(&blobIndex->type, CSSLOT_CODEDIRECTORY);
write32be(&blobIndex->offset, blobHeadersSize);
auto *codeDirectory =
    reinterpret_cast<CS_CodeDirectory *>(buf + blobHeadersSize);
write32be(&codeDirectory->magic, CSMAGIC_CODEDIRECTORY);
write32be(&codeDirectory->length, signatureSize - blobHeadersSize);
write32be(&codeDirectory->version, CS_SUPPORTSEXECSEG);
write32be(&codeDirectory->flags, CS_ADHOC | CS_LINKER_SIGNED);
write32be(&codeDirectory->hashOffset,
          sizeof(CS_CodeDirectory) + fileName.size() + fileNamePad);
write32be(&codeDirectory->identOffset, sizeof(CS_CodeDirectory));
codeDirectory->nSpecialSlots = 0;
write32be(&codeDirectory->nCodeSlots, getBlockCount());
write32be(&codeDirectory->codeLimit, fileOff);
codeDirectory->hashSize = static_cast<uint8_t>(hashSize);
codeDirectory->hashType = kSecCodeSignatureHashSHA256;
codeDirectory->platform = 0;
codeDirectory->pageSize = blockSizeShift;
codeDirectory->spare2 = 0;
codeDirectory->scatterOffset = 0;
codeDirectory->teamOffset = 0;
codeDirectory->spare3 = 0;
codeDirectory->codeLimit64 = 0;
OutputSegment *textSeg = getOrCreateOutputSegment(segment_names::text);
write64be(&codeDirectory->execSegBase, textSeg->fileOff);
write64be(&codeDirectory->execSegLimit, textSeg->fileSize);
write64be(&codeDirectory->execSegFlags,
          config->outputType == MH_EXECUTE ? CS_EXECSEG_MAIN_BINARY : 0);
auto *id = reinterpret_cast<char *>(&codeDirectory[1]);
memcpy(id, fileName.begin(), fileName.size());
memset(id + fileName.size(), 0, fileNamePad);
1557}

1559BitcodeBundleSection::BitcodeBundleSection()
  : SyntheticSection(segment_names::llvm, section_names::bitcodeBundle) {}

1562class ErrorCodeWrapper {
1563public:
explicit ErrorCodeWrapper(std::error_code ec) : errorCode(ec.value()) {}
explicit ErrorCodeWrapper(int ec) : errorCode(ec) {}
operator int() const { return errorCode; }

1568private:
int errorCode;
1570};

1572#define CHECK_EC(exp)do { ErrorCodeWrapper ec(exp); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "exp"); } while (0);                                                          \
do {                                                                         \
  ErrorCodeWrapper ec(exp);                                                  \
  if (ec)                                                                    \
    fatal(Twine("operation failed with error code ") + Twine(ec) + ": " +    \
          #exp);                                                             \
} while (0);

1580void BitcodeBundleSection::finalize() {
1581#ifdef LLVM_HAVE_LIBXAR
using namespace llvm::sys::fs;
CHECK_EC(createTemporaryFile("bitcode-bundle", "xar", xarPath))do { ErrorCodeWrapper ec(createTemporaryFile("bitcode-bundle"
, "xar", xarPath)); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "createTemporaryFile(\"bitcode-bundle\", \"xar\", xarPath)"
); } while (0);;

1585#pragma clang diagnostic push
1586#pragma clang diagnostic ignored "-Wdeprecated-declarations"
xar_t xar(xar_open(xarPath.data(), O_RDWR));
1588#pragma clang diagnostic pop
if (!xar)
  fatal("failed to open XAR temporary file at " + xarPath);
CHECK_EC(xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE))do { ErrorCodeWrapper ec(xar_opt_set(xar, XAR_OPT_COMPRESSION
, XAR_OPT_VAL_NONE)); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE)"
); } while (0);;
// FIXME: add more data to XAR
CHECK_EC(xar_close(xar))do { ErrorCodeWrapper ec(xar_close(xar)); if (ec) fatal(Twine
("operation failed with error code ") + Twine(ec) + ": " + "xar_close(xar)"
); } while (0);;

file_size(xarPath, xarSize);
1596#endif // defined(LLVM_HAVE_LIBXAR)
1597}

1599void BitcodeBundleSection::writeTo(uint8_t *buf) const {
using namespace llvm::sys::fs;
file_t handle =
    CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),check2((openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None
)), [&] { return toString("failed to open XAR file"); })
          "failed to open XAR file")check2((openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None
)), [&] { return toString("failed to open XAR file"); });
std::error_code ec;
mapped_file_region xarMap(handle, mapped_file_region::mapmode::readonly,
                          xarSize, 0, ec);
if (ec)
  fatal("failed to map XAR file");
memcpy(buf, xarMap.const_data(), xarSize);

closeFile(handle);
remove(xarPath);
1613}

1615CStringSection::CStringSection(const char *name)
  : SyntheticSection(segment_names::text, name) {
flags = S_CSTRING_LITERALS;
1618}

1620void CStringSection::addInput(CStringInputSection *isec) {
isec->parent = this;
inputs.push_back(isec);
if (isec->align > align)
  align = isec->align;
1625}

1627void CStringSection::writeTo(uint8_t *buf) const {
for (const CStringInputSection *isec : inputs) {
  for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
    if (!piece.live)
      continue;
    StringRef string = isec->getStringRef(i);
    memcpy(buf + piece.outSecOff, string.data(), string.size());
  }
}
1636}

1638void CStringSection::finalizeContents() {
uint64_t offset = 0;
for (CStringInputSection *isec : inputs) {
  for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
    if (!piece.live)
      continue;
    // See comment above DeduplicatedCStringSection for how alignment is
    // handled.
    uint32_t pieceAlign = 1
                          << llvm::countr_zero(isec->align | piece.inSecOff);
    offset = alignToPowerOf2(offset, pieceAlign);
    piece.outSecOff = offset;
    isec->isFinal = true;
    StringRef string = isec->getStringRef(i);
    offset += string.size() + 1; // account for null terminator
  }
}
size = offset;
1656}

1658// Mergeable cstring literals are found under the __TEXT,__cstring section. In
1659// contrast to ELF, which puts strings that need different alignments into
1660// different sections, clang's Mach-O backend puts them all in one section.
1661// Strings that need to be aligned have the .p2align directive emitted before
1662// them, which simply translates into zero padding in the object file. In other
1663// words, we have to infer the desired alignment of these cstrings from their
1664// addresses.
1665//
1666// We differ slightly from ld64 in how we've chosen to align these cstrings.
1667// Both LLD and ld64 preserve the number of trailing zeros in each cstring's
1668// address in the input object files. When deduplicating identical cstrings,
1669// both linkers pick the cstring whose address has more trailing zeros, and
1670// preserve the alignment of that address in the final binary. However, ld64
1671// goes a step further and also preserves the offset of the cstring from the
1672// last section-aligned address.  I.e. if a cstring is at offset 18 in the
1673// input, with a section alignment of 16, then both LLD and ld64 will ensure the
1674// final address is 2-byte aligned (since 18 == 16 + 2). But ld64 will also
1675// ensure that the final address is of the form 16 * k + 2 for some k.
1676//
1677// Note that ld64's heuristic means that a dedup'ed cstring's final address is
1678// dependent on the order of the input object files. E.g. if in addition to the
1679// cstring at offset 18 above, we have a duplicate one in another file with a
1680// `.cstring` section alignment of 2 and an offset of zero, then ld64 will pick
1681// the cstring from the object file earlier on the command line (since both have
1682// the same number of trailing zeros in their address). So the final cstring may
1683// either be at some address `16 * k + 2` or at some address `2 * k`.
1684//
1685// I've opted not to follow this behavior primarily for implementation
1686// simplicity, and secondarily to save a few more bytes. It's not clear to me
1687// that preserving the section alignment + offset is ever necessary, and there
1688// are many cases that are clearly redundant. In particular, if an x86_64 object
1689// file contains some strings that are accessed via SIMD instructions, then the
1690// .cstring section in the object file will be 16-byte-aligned (since SIMD
1691// requires its operand addresses to be 16-byte aligned). However, there will
1692// typically also be other cstrings in the same file that aren't used via SIMD
1693// and don't need this alignment. They will be emitted at some arbitrary address
1694// `A`, but ld64 will treat them as being 16-byte aligned with an offset of `16
1695// % A`.
1696void DeduplicatedCStringSection::finalizeContents() {
// Find the largest alignment required for each string.
for (const CStringInputSection *isec : inputs) {
  for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
    if (!piece.live)
      continue;
    auto s = isec->getCachedHashStringRef(i);
    assert(isec->align != 0)(static_cast <bool> (isec->align != 0) ? void (0) : __assert_fail
 ("isec->align != 0", "lld/MachO/SyntheticSections.cpp", 1703
, __extension__ __PRETTY_FUNCTION__));
    uint8_t trailingZeros = llvm::countr_zero(isec->align | piece.inSecOff);
    auto it = stringOffsetMap.insert(
        std::make_pair(s, StringOffset(trailingZeros)));
    if (!it.second && it.first->second.trailingZeros < trailingZeros)
      it.first->second.trailingZeros = trailingZeros;
  }
}

// Assign an offset for each string and save it to the corresponding
// StringPieces for easy access.
for (CStringInputSection *isec : inputs) {
  for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
    if (!piece.live)
      continue;
    auto s = isec->getCachedHashStringRef(i);
    auto it = stringOffsetMap.find(s);
    assert(it != stringOffsetMap.end())(static_cast <bool> (it != stringOffsetMap.end()) ? void
 (0) : __assert_fail ("it != stringOffsetMap.end()", "lld/MachO/SyntheticSections.cpp"
, 1720, __extension__ __PRETTY_FUNCTION__));
    StringOffset &offsetInfo = it->second;
    if (offsetInfo.outSecOff == UINT64_MAX(18446744073709551615UL)) {
      offsetInfo.outSecOff =
          alignToPowerOf2(size, 1ULL << offsetInfo.trailingZeros);
      size =
          offsetInfo.outSecOff + s.size() + 1; // account for null terminator
    }
    piece.outSecOff = offsetInfo.outSecOff;
  }
  isec->isFinal = true;
}
1732}

1734void DeduplicatedCStringSection::writeTo(uint8_t *buf) const {
for (const auto &p : stringOffsetMap) {
  StringRef data = p.first.val();
  uint64_t off = p.second.outSecOff;
  if (!data.empty())
    memcpy(buf + off, data.data(), data.size());
}
1741}

1743DeduplicatedCStringSection::StringOffset
1744DeduplicatedCStringSection::getStringOffset(StringRef str) const {
// StringPiece uses 31 bits to store the hashes, so we replicate that
uint32_t hash = xxHash64(str) & 0x7fffffff;
auto offset = stringOffsetMap.find(CachedHashStringRef(str, hash));
assert(offset != stringOffsetMap.end() &&(static_cast <bool> (offset != stringOffsetMap.end() &&
 "Looked-up strings should always exist in section") ? void (
0) : __assert_fail ("offset != stringOffsetMap.end() && \"Looked-up strings should always exist in section\""
, "lld/MachO/SyntheticSections.cpp", 1749, __extension__ __PRETTY_FUNCTION__
))
       "Looked-up strings should always exist in section")(static_cast <bool> (offset != stringOffsetMap.end() &&
 "Looked-up strings should always exist in section") ? void (
0) : __assert_fail ("offset != stringOffsetMap.end() && \"Looked-up strings should always exist in section\""
, "lld/MachO/SyntheticSections.cpp", 1749, __extension__ __PRETTY_FUNCTION__
));
return offset->second;
1751}

1753// This section is actually emitted as __TEXT,__const by ld64, but clang may
1754// emit input sections of that name, and LLD doesn't currently support mixing
1755// synthetic and concat-type OutputSections. To work around this, I've given
1756// our merged-literals section a different name.
1757WordLiteralSection::WordLiteralSection()
  : SyntheticSection(segment_names::text, section_names::literals) {
align = 16;
1760}

1762void WordLiteralSection::addInput(WordLiteralInputSection *isec) {
isec->parent = this;
inputs.push_back(isec);
1765}

1767void WordLiteralSection::finalizeContents() {
for (WordLiteralInputSection *isec : inputs) {
  // We do all processing of the InputSection here, so it will be effectively
  // finalized.
  isec->isFinal = true;
  const uint8_t *buf = isec->data.data();
  switch (sectionType(isec->getFlags())) {
  case S_4BYTE_LITERALS: {
    for (size_t off = 0, e = isec->data.size(); off < e; off += 4) {
      if (!isec->isLive(off))
        continue;
      uint32_t value = *reinterpret_cast<const uint32_t *>(buf + off);
      literal4Map.emplace(value, literal4Map.size());
    }
    break;
  }
  case S_8BYTE_LITERALS: {
    for (size_t off = 0, e = isec->data.size(); off < e; off += 8) {
      if (!isec->isLive(off))
        continue;
      uint64_t value = *reinterpret_cast<const uint64_t *>(buf + off);
      literal8Map.emplace(value, literal8Map.size());
    }
    break;
  }
  case S_16BYTE_LITERALS: {
    for (size_t off = 0, e = isec->data.size(); off < e; off += 16) {
      if (!isec->isLive(off))
        continue;
      UInt128 value = *reinterpret_cast<const UInt128 *>(buf + off);
      literal16Map.emplace(value, literal16Map.size());
    }
    break;
  }
  default:
    llvm_unreachable("invalid literal section type")::llvm::llvm_unreachable_internal("invalid literal section type"
, "lld/MachO/SyntheticSections.cpp", 1802);
  }
}
1805}

1807void WordLiteralSection::writeTo(uint8_t *buf) const {
// Note that we don't attempt to do any endianness conversion in addInput(),
// so we don't do it here either -- just write out the original value,
// byte-for-byte.
for (const auto &p : literal16Map)
  memcpy(buf + p.second * 16, &p.first, 16);
buf += literal16Map.size() * 16;

for (const auto &p : literal8Map)
  memcpy(buf + p.second * 8, &p.first, 8);
buf += literal8Map.size() * 8;

for (const auto &p : literal4Map)
  memcpy(buf + p.second * 4, &p.first, 4);
1821}

1823ObjCImageInfoSection::ObjCImageInfoSection()
  : SyntheticSection(segment_names::data, section_names::objCImageInfo) {}

1826ObjCImageInfoSection::ImageInfo
1827ObjCImageInfoSection::parseImageInfo(const InputFile *file) {
ImageInfo info;
ArrayRef<uint8_t> data = file->objCImageInfo;
// The image info struct has the following layout:
// struct {
//   uint32_t version;
//   uint32_t flags;
// };
if (data.size() < 8) {
  warn(toString(file) + ": invalid __objc_imageinfo size");
  return info;
}

auto *buf = reinterpret_cast<const uint32_t *>(data.data());
if (read32le(buf) != 0) {
  warn(toString(file) + ": invalid __objc_imageinfo version");
  return info;
}

uint32_t flags = read32le(buf + 1);
info.swiftVersion = (flags >> 8) & 0xff;
info.hasCategoryClassProperties = flags & 0x40;
return info;
1850}

1852static std::string swiftVersionString(uint8_t version) {
switch (version) {
  case 1:
    return "1.0";
  case 2:
    return "1.1";
  case 3:
    return "2.0";
  case 4:
    return "3.0";
  case 5:
    return "4.0";
  default:
    return ("0x" + Twine::utohexstr(version)).str();
}
1867}

1869// Validate each object file's __objc_imageinfo and use them to generate the
1870// image info for the output binary. Only two pieces of info are relevant:
1871// 1. The Swift version (should be identical across inputs)
1872// 2. `bool hasCategoryClassProperties` (true only if true for all inputs)
1873void ObjCImageInfoSection::finalizeContents() {
assert(files.size() != 0)(static_cast <bool> (files.size() != 0) ? void (0) : __assert_fail
 ("files.size() != 0", "lld/MachO/SyntheticSections.cpp", 1874
, __extension__ __PRETTY_FUNCTION__)); // should have already been checked via isNeeded()
1
Assuming the condition is true→
2
←
'?' condition is true→

info.hasCategoryClassProperties = true;
const InputFile *firstFile;
3
←
'firstFile' declared without an initial value→
for (const InputFile *file : files) {
  ImageInfo inputInfo = parseImageInfo(file);
  info.hasCategoryClassProperties &= inputInfo.hasCategoryClassProperties;

  // swiftVersion 0 means no Swift is present, so no version checking required
  if (inputInfo.swiftVersion == 0)
4
←
Assuming field 'swiftVersion' is not equal to 0→
    continue;

  if (info.swiftVersion != 0 && info.swiftVersion != inputInfo.swiftVersion) {
5
←
Assuming field 'swiftVersion' is not equal to 0→
6
←
Assuming 'info.swiftVersion' is not equal to 'inputInfo.swiftVersion'→
7
←
Taking true branch→
    error("Swift version mismatch: " + toString(firstFile) + " has version " +
8
←
1st function call argument is an uninitialized value
          swiftVersionString(info.swiftVersion) + " but " + toString(file) +
          " has version " + swiftVersionString(inputInfo.swiftVersion));
  } else {
    info.swiftVersion = inputInfo.swiftVersion;
    firstFile = file;
  }
}
1895}

1897void ObjCImageInfoSection::writeTo(uint8_t *buf) const {
uint32_t flags = info.hasCategoryClassProperties ? 0x40 : 0x0;
flags |= info.swiftVersion << 8;
write32le(buf + 4, flags);
1901}

1903InitOffsetsSection::InitOffsetsSection()
  : SyntheticSection(segment_names::text, section_names::initOffsets) {
flags = S_INIT_FUNC_OFFSETS;
align = 4; // This section contains 32-bit integers.
1907}

1909uint64_t InitOffsetsSection::getSize() const {
size_t count = 0;
for (const ConcatInputSection *isec : sections)
  count += isec->relocs.size();
return count * sizeof(uint32_t);
1914}

1916void InitOffsetsSection::writeTo(uint8_t *buf) const {
// FIXME: Add function specified by -init when that argument is implemented.
for (ConcatInputSection *isec : sections) {
  for (const Reloc &rel : isec->relocs) {
    const Symbol *referent = rel.referent.dyn_cast<Symbol *>();
    assert(referent && "section relocation should have been rejected")(static_cast <bool> (referent && "section relocation should have been rejected"
) ? void (0) : __assert_fail ("referent && \"section relocation should have been rejected\""
, "lld/MachO/SyntheticSections.cpp", 1921, __extension__ __PRETTY_FUNCTION__
));
    uint64_t offset = referent->getVA() - in.header->addr;
    // FIXME: Can we handle this gracefully?
    if (offset > UINT32_MAX(4294967295U))
      fatal(isec->getLocation(rel.offset) + ": offset to initializer " +
            referent->getName() + " (" + utohexstr(offset) +
            ") does not fit in 32 bits");

    // Entries need to be added in the order they appear in the section, but
    // relocations aren't guaranteed to be sorted.
    size_t index = rel.offset >> target->p2WordSize;
    write32le(&buf[index * sizeof(uint32_t)], offset);
  }
  buf += isec->relocs.size() * sizeof(uint32_t);
}
1936}

1938// The inputs are __mod_init_func sections, which contain pointers to
1939// initializer functions, therefore all relocations should be of the UNSIGNED
1940// type. InitOffsetsSection stores offsets, so if the initializer's address is
1941// not known at link time, stub-indirection has to be used.
1942void InitOffsetsSection::setUp() {
for (const ConcatInputSection *isec : sections) {
  for (const Reloc &rel : isec->relocs) {
    RelocAttrs attrs = target->getRelocAttrs(rel.type);
    if (!attrs.hasAttr(RelocAttrBits::UNSIGNED))
      error(isec->getLocation(rel.offset) +
            ": unsupported relocation type: " + attrs.name);
    if (rel.addend != 0)
      error(isec->getLocation(rel.offset) +
            ": relocation addend is not representable in __init_offsets");
    if (rel.referent.is<InputSection *>())
      error(isec->getLocation(rel.offset) +
            ": unexpected section relocation");

    Symbol *sym = rel.referent.dyn_cast<Symbol *>();
    if (auto *undefined = dyn_cast<Undefined>(sym))
      treatUndefinedSymbol(*undefined, isec, rel.offset);
    if (needsBinding(sym))
      in.stubs->addEntry(sym);
  }
}
1963}

1965void macho::createSyntheticSymbols() {
auto addHeaderSymbol = [](const char *name) {
  symtab->addSynthetic(name, in.header->isec, /*value=*/0,
                       /*isPrivateExtern=*/true, /*includeInSymtab=*/false,
                       /*referencedDynamically=*/false);
};

switch (config->outputType) {
  // FIXME: Assign the right address value for these symbols
  // (rather than 0). But we need to do that after assignAddresses().
case MH_EXECUTE:
  // If linking PIE, __mh_execute_header is a defined symbol in
  //  __TEXT, __text)
  // Otherwise, it's an absolute symbol.
  if (config->isPic)
    symtab->addSynthetic("__mh_execute_header", in.header->isec, /*value=*/0,
                         /*isPrivateExtern=*/false, /*includeInSymtab=*/true,
                         /*referencedDynamically=*/true);
  else
    symtab->addSynthetic("__mh_execute_header", /*isec=*/nullptr, /*value=*/0,
                         /*isPrivateExtern=*/false, /*includeInSymtab=*/true,
                         /*referencedDynamically=*/true);
  break;

  // The following symbols are N_SECT symbols, even though the header is not
  // part of any section and that they are private to the bundle/dylib/object
  // they are part of.
case MH_BUNDLE:
  addHeaderSymbol("__mh_bundle_header");
  break;
case MH_DYLIB:
  addHeaderSymbol("__mh_dylib_header");
  break;
case MH_DYLINKER:
  addHeaderSymbol("__mh_dylinker_header");
  break;
case MH_OBJECT:
  addHeaderSymbol("__mh_object_header");
  break;
default:
  llvm_unreachable("unexpected outputType")::llvm::llvm_unreachable_internal("unexpected outputType", "lld/MachO/SyntheticSections.cpp"
, 2005);
  break;
}

// The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
// which does e.g. cleanup of static global variables. The ABI document
// says that the pointer can point to any address in one of the dylib's
// segments, but in practice ld64 seems to set it to point to the header,
// so that's what's implemented here.
addHeaderSymbol("___dso_handle");
2015}

2017ChainedFixupsSection::ChainedFixupsSection()
  : LinkEditSection(segment_names::linkEdit, section_names::chainFixups) {}

2020bool ChainedFixupsSection::isNeeded() const {
assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
 (0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 2021, __extension__ __PRETTY_FUNCTION__));
// dyld always expects LC_DYLD_CHAINED_FIXUPS to point to a valid
// dyld_chained_fixups_header, so we create this section even if there aren't
// any fixups.
return true;
2026}

2028static bool needsWeakBind(const Symbol &sym) {
if (auto *dysym = dyn_cast<DylibSymbol>(&sym))
  return dysym->isWeakDef();
if (auto *defined = dyn_cast<Defined>(&sym))
  return defined->isExternalWeakDef();
return false;
2034}

2036void ChainedFixupsSection::addBinding(const Symbol *sym,
                                    const InputSection *isec, uint64_t offset,
                                    int64_t addend) {
locations.emplace_back(isec, offset);
int64_t outlineAddend = (addend < 0 || addend > 0xFF) ? addend : 0;
auto [it, inserted] = bindings.insert(
    {{sym, outlineAddend}, static_cast<uint32_t>(bindings.size())});

if (inserted) {
  symtabSize += sym->getName().size() + 1;
  hasWeakBind = hasWeakBind || needsWeakBind(*sym);
  if (!isInt<23>(outlineAddend))
    needsLargeAddend = true;
  else if (outlineAddend != 0)
    needsAddend = true;
}
2052}

2054std::pair<uint32_t, uint8_t>
2055ChainedFixupsSection::getBinding(const Symbol *sym, int64_t addend) const {
int64_t outlineAddend = (addend < 0 || addend > 0xFF) ? addend : 0;
auto it = bindings.find({sym, outlineAddend});
assert(it != bindings.end() && "binding not found in the imports table")(static_cast <bool> (it != bindings.end() && "binding not found in the imports table"
) ? void (0) : __assert_fail ("it != bindings.end() && \"binding not found in the imports table\""
, "lld/MachO/SyntheticSections.cpp", 2058, __extension__ __PRETTY_FUNCTION__
));
if (outlineAddend == 0)
  return {it->second, addend};
return {it->second, 0};
2062}

2064static size_t writeImport(uint8_t *buf, int format, uint32_t libOrdinal,
                        bool weakRef, uint32_t nameOffset, int64_t addend) {
switch (format) {
case DYLD_CHAINED_IMPORT: {
  auto *import = reinterpret_cast<dyld_chained_import *>(buf);
  import->lib_ordinal = libOrdinal;
  import->weak_import = weakRef;
  import->name_offset = nameOffset;
  return sizeof(dyld_chained_import);
}
case DYLD_CHAINED_IMPORT_ADDEND: {
  auto *import = reinterpret_cast<dyld_chained_import_addend *>(buf);
  import->lib_ordinal = libOrdinal;
  import->weak_import = weakRef;
  import->name_offset = nameOffset;
  import->addend = addend;
  return sizeof(dyld_chained_import_addend);
}
case DYLD_CHAINED_IMPORT_ADDEND64: {
  auto *import = reinterpret_cast<dyld_chained_import_addend64 *>(buf);
  import->lib_ordinal = libOrdinal;
  import->weak_import = weakRef;
  import->name_offset = nameOffset;
  import->addend = addend;
  return sizeof(dyld_chained_import_addend64);
}
default:
  llvm_unreachable("Unknown import format")::llvm::llvm_unreachable_internal("Unknown import format", "lld/MachO/SyntheticSections.cpp"
, 2091);
}
2093}

2095size_t ChainedFixupsSection::SegmentInfo::getSize() const {
assert(pageStarts.size() > 0 && "SegmentInfo for segment with no fixups?")(static_cast <bool> (pageStarts.size() > 0 &&
 "SegmentInfo for segment with no fixups?") ? void (0) : __assert_fail
 ("pageStarts.size() > 0 && \"SegmentInfo for segment with no fixups?\""
, "lld/MachO/SyntheticSections.cpp", 2096, __extension__ __PRETTY_FUNCTION__
));
return alignTo<8>(sizeof(dyld_chained_starts_in_segment) +
                  pageStarts.back().first * sizeof(uint16_t));
2099}

2101size_t ChainedFixupsSection::SegmentInfo::writeTo(uint8_t *buf) const {
auto *segInfo = reinterpret_cast<dyld_chained_starts_in_segment *>(buf);
segInfo->size = getSize();
segInfo->page_size = target->getPageSize();
// FIXME: Use DYLD_CHAINED_PTR_64_OFFSET on newer OS versions.
segInfo->pointer_format = DYLD_CHAINED_PTR_64;
segInfo->segment_offset = oseg->addr - in.header->addr;
segInfo->max_valid_pointer = 0; // not used on 64-bit
segInfo->page_count = pageStarts.back().first + 1;

uint16_t *starts = segInfo->page_start;
for (size_t i = 0; i < segInfo->page_count; ++i)
  starts[i] = DYLD_CHAINED_PTR_START_NONE;

for (auto [pageIdx, startAddr] : pageStarts)
  starts[pageIdx] = startAddr;
return segInfo->size;
2118}

2120static size_t importEntrySize(int format) {
switch (format) {
case DYLD_CHAINED_IMPORT:
  return sizeof(dyld_chained_import);
case DYLD_CHAINED_IMPORT_ADDEND:
  return sizeof(dyld_chained_import_addend);
case DYLD_CHAINED_IMPORT_ADDEND64:
  return sizeof(dyld_chained_import_addend64);
default:
  llvm_unreachable("Unknown import format")::llvm::llvm_unreachable_internal("Unknown import format", "lld/MachO/SyntheticSections.cpp"
, 2129);
}
2131}

2133// This is step 3 of the algorithm described in the class comment of
2134// ChainedFixupsSection.
2135//
2136// LC_DYLD_CHAINED_FIXUPS data consists of (in this order):
2137// * A dyld_chained_fixups_header
2138// * A dyld_chained_starts_in_image
2139// * One dyld_chained_starts_in_segment per segment
2140// * List of all imports (dyld_chained_import, dyld_chained_import_addend, or
2141//   dyld_chained_import_addend64)
2142// * Names of imported symbols
2143void ChainedFixupsSection::writeTo(uint8_t *buf) const {
auto *header = reinterpret_cast<dyld_chained_fixups_header *>(buf);
header->fixups_version = 0;
header->imports_count = bindings.size();
header->imports_format = importFormat;
header->symbols_format = 0;

buf += alignTo<8>(sizeof(*header));

auto curOffset = [&buf, &header]() -> uint32_t {
  return buf - reinterpret_cast<uint8_t *>(header);
};

header->starts_offset = curOffset();

auto *imageInfo = reinterpret_cast<dyld_chained_starts_in_image *>(buf);
imageInfo->seg_count = outputSegments.size();
uint32_t *segStarts = imageInfo->seg_info_offset;

// dyld_chained_starts_in_image ends in a flexible array member containing an
// uint32_t for each segment. Leave room for it, and fill it via segStarts.
buf += alignTo<8>(offsetof(dyld_chained_starts_in_image, seg_info_offset)__builtin_offsetof(dyld_chained_starts_in_image, seg_info_offset
) +
                  outputSegments.size() * sizeof(uint32_t));

// Initialize all offsets to 0, which indicates that the segment does not have
// fixups. Those that do have them will be filled in below.
for (size_t i = 0; i < outputSegments.size(); ++i)
  segStarts[i] = 0;

for (const SegmentInfo &seg : fixupSegments) {
  segStarts[seg.oseg->index] = curOffset() - header->starts_offset;
  buf += seg.writeTo(buf);
}

// Write imports table.
header->imports_offset = curOffset();
uint64_t nameOffset = 0;
for (auto [import, idx] : bindings) {
  const Symbol &sym = *import.first;
  int16_t libOrdinal = needsWeakBind(sym)
                           ? (int64_t)BIND_SPECIAL_DYLIB_WEAK_LOOKUP
                           : ordinalForSymbol(sym);
  buf += writeImport(buf, importFormat, libOrdinal, sym.isWeakRef(),
                     nameOffset, import.second);
  nameOffset += sym.getName().size() + 1;
}

// Write imported symbol names.
header->symbols_offset = curOffset();
for (auto [import, idx] : bindings) {
  StringRef name = import.first->getName();
  memcpy(buf, name.data(), name.size());
  buf += name.size() + 1; // account for null terminator
}

assert(curOffset() == getRawSize())(static_cast <bool> (curOffset() == getRawSize()) ? void
 (0) : __assert_fail ("curOffset() == getRawSize()", "lld/MachO/SyntheticSections.cpp"
, 2198, __extension__ __PRETTY_FUNCTION__));
2199}

2201// This is step 2 of the algorithm described in the class comment of
2202// ChainedFixupsSection.
2203void ChainedFixupsSection::finalizeContents() {
assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
 "Only 64-bit platforms are supported") ? void (0) : __assert_fail
 ("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 2204, __extension__ __PRETTY_FUNCTION__
));
assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
 (0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 2205, __extension__ __PRETTY_FUNCTION__));

if (!isUInt<32>(symtabSize))
  error("cannot encode chained fixups: imported symbols table size " +
        Twine(symtabSize) + " exceeds 4 GiB");

if (needsLargeAddend || !isUInt<23>(symtabSize))
  importFormat = DYLD_CHAINED_IMPORT_ADDEND64;
else if (needsAddend)
  importFormat = DYLD_CHAINED_IMPORT_ADDEND;
else
  importFormat = DYLD_CHAINED_IMPORT;

for (Location &loc : locations)
  loc.offset =
      loc.isec->parent->getSegmentOffset() + loc.isec->getOffset(loc.offset);

llvm::sort(locations, [](const Location &a, const Location &b) {
  const OutputSegment *segA = a.isec->parent->parent;
  const OutputSegment *segB = b.isec->parent->parent;
  if (segA == segB)
    return a.offset < b.offset;
  return segA->addr < segB->addr;
});

auto sameSegment = [](const Location &a, const Location &b) {
  return a.isec->parent->parent == b.isec->parent->parent;
};

const uint64_t pageSize = target->getPageSize();
for (size_t i = 0, count = locations.size(); i < count;) {
  const Location &firstLoc = locations[i];
  fixupSegments.emplace_back(firstLoc.isec->parent->parent);
  while (i < count && sameSegment(locations[i], firstLoc)) {
    uint32_t pageIdx = locations[i].offset / pageSize;
    fixupSegments.back().pageStarts.emplace_back(
        pageIdx, locations[i].offset % pageSize);
    ++i;
    while (i < count && sameSegment(locations[i], firstLoc) &&
           locations[i].offset / pageSize == pageIdx)
      ++i;
  }
}

// Compute expected encoded size.
size = alignTo<8>(sizeof(dyld_chained_fixups_header));
size += alignTo<8>(offsetof(dyld_chained_starts_in_image, seg_info_offset)__builtin_offsetof(dyld_chained_starts_in_image, seg_info_offset
) +
                   outputSegments.size() * sizeof(uint32_t));
for (const SegmentInfo &seg : fixupSegments)
  size += seg.getSize();
size += importEntrySize(importFormat) * bindings.size();
size += symtabSize;
2257}

2259template SymtabSection *macho::makeSymtabSection<LP64>(StringTableSection &);
2260template SymtabSection *macho::makeSymtabSection<ILP32>(StringTableSection &);