llvm/lld/MachO/InputSection.cpp

//===- InputSection.cpp ---------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "InputSection.h"
#include "ConcatOutputSection.h"
#include "Config.h"
#include "InputFiles.h"
#include "OutputSegment.h"
#include "Sections.h"
#include "Symbols.h"
#include "SyntheticSections.h"
#include "Target.h"
#include "UnwindInfoSection.h"
#include "Writer.h"

#include "lld/Common/ErrorHandler.h"
#include "lld/Common/Memory.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/xxhash.h"

usingnamespacellvm;
usingnamespacellvm::MachO;
usingnamespacellvm::support;
usingnamespacelld;
usingnamespacelld::macho;

// Verify ConcatInputSection's size on 64-bit builds. The size of std::vector
// can differ based on STL debug levels (e.g. iterator debugging on MSVC's STL),
// so account for that.
static_assert …;

std::vector<ConcatInputSection *> macho::inputSections;
int macho::inputSectionsOrder = …;

// Call this function to add a new InputSection and have it routed to the
// appropriate container. Depending on its type and current config, it will
// either be added to 'inputSections' vector or to a synthetic section.
void lld::macho::addInputSection(InputSection *inputSection) { … }

uint64_t InputSection::getFileSize() const { … }

uint64_t InputSection::getVA(uint64_t off) const { … }

static uint64_t resolveSymbolVA(const Symbol *sym, uint8_t type) { … }

const Defined *InputSection::getContainingSymbol(uint64_t off) const { … }

std::string InputSection::getLocation(uint64_t off) const { … }

std::string InputSection::getSourceLocation(uint64_t off) const { … }

const Reloc *InputSection::getRelocAt(uint32_t off) const { … }

void ConcatInputSection::foldIdentical(ConcatInputSection *copy,
                                       Symbol::ICFFoldKind foldKind) { … }

void ConcatInputSection::writeTo(uint8_t *buf) { … }

ConcatInputSection *macho::makeSyntheticInputSection(StringRef segName,
                                                     StringRef sectName,
                                                     uint32_t flags,
                                                     ArrayRef<uint8_t> data,
                                                     uint32_t align) { … }

void CStringInputSection::splitIntoPieces() { … }

StringPiece &CStringInputSection::getStringPiece(uint64_t off) { … }

const StringPiece &CStringInputSection::getStringPiece(uint64_t off) const { … }

size_t CStringInputSection::getStringPieceIndex(uint64_t off) const { … }

uint64_t CStringInputSection::getOffset(uint64_t off) const { … }

WordLiteralInputSection::WordLiteralInputSection(const Section &section,
                                                 ArrayRef<uint8_t> data,
                                                 uint32_t align)
    : … { … }

uint64_t WordLiteralInputSection::getOffset(uint64_t off) const { … }

bool macho::isCodeSection(const InputSection *isec) { … }

bool macho::isCfStringSection(const InputSection *isec) { … }

bool macho::isClassRefsSection(const InputSection *isec) { … }

bool macho::isSelRefsSection(const InputSection *isec) { … }

bool macho::isEhFrameSection(const InputSection *isec) { … }

bool macho::isGccExceptTabSection(const InputSection *isec) { … }

std::string lld::toString(const InputSection *isec) { … }