InputSection.h

//===- InputSection.h -------------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//

#ifndef LLD_MACHO_INPUT_SECTION_H
#defineLLD_MACHO_INPUT_SECTION_H

#include"Config.h"
#include"Relocations.h"
#include"Symbols.h"

#include"lld/Common/LLVM.h"
#include"lld/Common/Memory.h"
#include"llvm/ADT/ArrayRef.h"
#include"llvm/ADT/BitVector.h"
#include"llvm/ADT/CachedHashString.h"
#include"llvm/ADT/TinyPtrVector.h"
#include"llvm/BinaryFormat/MachO.h"

namespacelld {
namespacemacho {

classInputFile;
classOutputSection;

classInputSection {
public:
enum Kind : uint8_t {
 ConcatKind,
 CStringLiteralKind,
 WordLiteralKind,
 };

 Kind kind() const { return sectionKind; }
virtual~InputSection() = default;
virtualuint64_tgetSize() const { return data.size(); }
virtualboolempty() const { return data.empty(); }
 InputFile *getFile() const { return section.file; }
 StringRef getName() const { return section.name; }
 StringRef getSegName() const { return section.segname; }
uint32_tgetFlags() const { return section.flags; }
uint64_tgetFileSize() const;
// Translates \p off -- an offset relative to this InputSection -- into an
// offset from the beginning of its parent OutputSection.
virtualuint64_tgetOffset(uint64_t off) const = 0;
// The offset from the beginning of the file.
uint64_tgetVA(uint64_t off) const;
// Return a user-friendly string for use in diagnostics.
// Format: /path/to/object.o:(symbol _func+0x123)
 std::string getLocation(uint64_t off) const;
// Return the source line corresponding to an address, or the empty string.
// Format: Source.cpp:123 (/path/to/Source.cpp:123)
 std::string getSourceLocation(uint64_t off) const;
// Return the relocation at \p off, if it exists. This does a linear search.
const Reloc *getRelocAt(uint32_t off) const;
// Whether the data at \p off in this InputSection is live.
virtualboolisLive(uint64_t off) const = 0;
virtualvoidmarkLive(uint64_t off) = 0;
virtual InputSection *canonical() { returnthis; }
virtualconst InputSection *canonical() const { returnthis; }

protected:
InputSection(Kind kind, const Section &section, ArrayRef<uint8_t> data,
uint32_t align)
 : sectionKind(kind), keepUnique(false), hasAltEntry(false), align(align),
data(data), section(section) {}

InputSection(const InputSection &rhs)
 : sectionKind(rhs.sectionKind), keepUnique(false), hasAltEntry(false),
 align(rhs.align), data(rhs.data), section(rhs.section) {}

 Kind sectionKind;

public:
// is address assigned?
bool isFinal = false;
// keep the address of the symbol(s) in this section unique in the final
// binary ?
bool keepUnique : 1;
// Does this section have symbols at offsets other than zero? (NOTE: only
// applies to ConcatInputSections.)
bool hasAltEntry : 1;
uint32_t align = 1;

 OutputSection *parent = nullptr;
 ArrayRef<uint8_t> data;
 std::vector<Reloc> relocs;
// The symbols that belong to this InputSection, sorted by value. With
// .subsections_via_symbols, there is typically only one element here.
 llvm::TinyPtrVector<Defined *> symbols;

const Section &section;

protected:
const Defined *getContainingSymbol(uint64_t off) const;
};

// ConcatInputSections are combined into (Concat)OutputSections through simple
// concatenation, in contrast with literal sections which may have their
// contents merged before output.
classConcatInputSectionfinal : public InputSection {
public:
ConcatInputSection(const Section &section, ArrayRef<uint8_t> data,
uint32_t align = 1)
 : InputSection(ConcatKind, section, data, align) {}

uint64_tgetOffset(uint64_t off) constoverride { return outSecOff + off; }
uint64_tgetVA() const { returnInputSection::getVA(0); }
// ConcatInputSections are entirely live or dead, so the offset is irrelevant.
boolisLive(uint64_t off) constoverride { return live; }
voidmarkLive(uint64_t off) override { live = true; }
boolisCoalescedWeak() const { return wasCoalesced && symbols.empty(); }
boolshouldOmitFromOutput() const { return !live || isCoalescedWeak(); }
voidwriteTo(uint8_t *buf);

voidfoldIdentical(ConcatInputSection *redundant,
 Symbol::ICFFoldKind foldKind = Symbol::ICFFoldKind::Body);
 ConcatInputSection *canonical() override {
return replacement ? replacement : this;
 }
const InputSection *canonical() constoverride {
return replacement ? replacement : this;
 }

staticboolclassof(const InputSection *isec) {
return isec->kind() == ConcatKind;
 }

// Points to the surviving section after this one is folded by ICF
 ConcatInputSection *replacement = nullptr;
// Equivalence-class ID for ICF
uint32_t icfEqClass[2] = {0, 0};

// With subsections_via_symbols, most symbols have their own InputSection,
// and for weak symbols (e.g. from inline functions), only the
// InputSection from one translation unit will make it to the output,
// while all copies in other translation units are coalesced into the
// first and not copied to the output.
bool wasCoalesced = false;
bool live = !config->deadStrip;
bool hasCallSites = false;
// This variable has two usages. Initially, it represents the input order.
// After assignAddresses is called, it represents the offset from the
// beginning of the output section this section was assigned to.
uint64_t outSecOff = 0;
};

// Initialize a fake InputSection that does not belong to any InputFile.
// The created ConcatInputSection will always have 'live=true'
ConcatInputSection *makeSyntheticInputSection(StringRef segName,
 StringRef sectName,
uint32_t flags = 0,
 ArrayRef<uint8_t> data = {},
uint32_t align = 1);

// Helper functions to make it easy to sprinkle asserts.

inlineboolshouldOmitFromOutput(InputSection *isec) {
return isa<ConcatInputSection>(isec) &&
 cast<ConcatInputSection>(isec)->shouldOmitFromOutput();
}

inlineboolisCoalescedWeak(InputSection *isec) {
return isa<ConcatInputSection>(isec) &&
 cast<ConcatInputSection>(isec)->isCoalescedWeak();
}

// We allocate a lot of these and binary search on them, so they should be as
// compact as possible. Hence the use of 31 rather than 64 bits for the hash.
structStringPiece {
// Offset from the start of the containing input section.
uint32_t inSecOff;
uint32_t live : 1;
// Only set if deduplicating literals
uint32_t hash : 31;
// Offset from the start of the containing output section.
uint64_t outSecOff = 0;

StringPiece(uint64_t off, uint32_t hash)
 : inSecOff(off), live(!config->deadStrip), hash(hash) {}
};

static_assert(sizeof(StringPiece) == 16, "StringPiece is too big!");

// CStringInputSections are composed of multiple null-terminated string
// literals, which we represent using StringPieces. These literals can be
// deduplicated and tail-merged, so translating offsets between the input and
// outputs sections is more complicated.
//
// NOTE: One significant difference between LLD and ld64 is that we merge all
// cstring literals, even those referenced directly by non-private symbols.
// ld64 is more conservative and does not do that. This was mostly done for
// implementation simplicity; if we find programs that need the more
// conservative behavior we can certainly implement that.
classCStringInputSectionfinal : public InputSection {
public:
CStringInputSection(const Section &section, ArrayRef<uint8_t> data,
uint32_t align, bool dedupLiterals)
 : InputSection(CStringLiteralKind, section, data, align),
deduplicateLiterals(dedupLiterals) {}

uint64_tgetOffset(uint64_t off) constoverride;
boolisLive(uint64_t off) constoverride { returngetStringPiece(off).live; }
voidmarkLive(uint64_t off) override { getStringPiece(off).live = true; }
// Find the StringPiece that contains this offset.
 StringPiece &getStringPiece(uint64_t off);
const StringPiece &getStringPiece(uint64_t off) const;
// Split at each null byte.
voidsplitIntoPieces();

 LLVM_ATTRIBUTE_ALWAYS_INLINE
 StringRef getStringRef(size_t i) const {
size_t begin = pieces[i].inSecOff;
// The endpoint should be *at* the null terminator, not after. This matches
// the behavior of StringRef(const char *Str).
size_t end =
 ((pieces.size() - 1 == i) ? data.size() : pieces[i + 1].inSecOff) - 1;
returntoStringRef(data.slice(begin, end - begin));
 }

 StringRef getStringRefAtOffset(uint64_t off) const {
returngetStringRef(getStringPieceIndex(off));
 }

// Returns i'th piece as a CachedHashStringRef. This function is very hot when
// string merging is enabled, so we want to inline.
 LLVM_ATTRIBUTE_ALWAYS_INLINE
 llvm::CachedHashStringRef getCachedHashStringRef(size_t i) const {
assert(deduplicateLiterals);
return {getStringRef(i), pieces[i].hash};
 }

staticboolclassof(const InputSection *isec) {
return isec->kind() == CStringLiteralKind;
 }

bool deduplicateLiterals = false;
 std::vector<StringPiece> pieces;

private:
size_tgetStringPieceIndex(uint64_t off) const;
};

classWordLiteralInputSectionfinal : public InputSection {
public:
WordLiteralInputSection(const Section &section, ArrayRef<uint8_t> data,
uint32_t align);
uint64_tgetOffset(uint64_t off) constoverride;
boolisLive(uint64_t off) constoverride {
return live[off >> power2LiteralSize];
 }
voidmarkLive(uint64_t off) override {
 live[off >> power2LiteralSize] = true;
 }

staticboolclassof(const InputSection *isec) {
return isec->kind() == WordLiteralKind;
 }

private:
unsigned power2LiteralSize;
// The liveness of data[off] is tracked by live[off >> power2LiteralSize].
 llvm::BitVector live;
};

inlineuint8_tsectionType(uint32_t flags) {
return flags & llvm::MachO::SECTION_TYPE;
}

inlineboolisZeroFill(uint32_t flags) {
returnllvm::MachO::isVirtualSection(sectionType(flags));
}

inlineboolisThreadLocalVariables(uint32_t flags) {
returnsectionType(flags) == llvm::MachO::S_THREAD_LOCAL_VARIABLES;
}

// These sections contain the data for initializing thread-local variables.
inlineboolisThreadLocalData(uint32_t flags) {
returnsectionType(flags) == llvm::MachO::S_THREAD_LOCAL_REGULAR ||
sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_ZEROFILL;
}

inlineboolisDebugSection(uint32_t flags) {
return (flags & llvm::MachO::SECTION_ATTRIBUTES_USR) ==
 llvm::MachO::S_ATTR_DEBUG;
}

inlineboolisWordLiteralSection(uint32_t flags) {
returnsectionType(flags) == llvm::MachO::S_4BYTE_LITERALS ||
sectionType(flags) == llvm::MachO::S_8BYTE_LITERALS ||
sectionType(flags) == llvm::MachO::S_16BYTE_LITERALS;
}

boolisCodeSection(const InputSection *);
boolisCfStringSection(const InputSection *);
boolisClassRefsSection(const InputSection *);
boolisSelRefsSection(const InputSection *);
boolisEhFrameSection(const InputSection *);
boolisGccExceptTabSection(const InputSection *);

extern std::vector<ConcatInputSection *> inputSections;
// This is used as a counter for specyfing input order for input sections
externint inputSectionsOrder;

namespacesection_names {

constexprconstchar authGot[] = "__auth_got";
constexprconstchar authPtr[] = "__auth_ptr";
constexprconstchar binding[] = "__binding";
constexprconstchar bitcodeBundle[] = "__bundle";
constexprconstchar cString[] = "__cstring";
constexprconstchar cfString[] = "__cfstring";
constexprconstchar cgProfile[] = "__cg_profile";
constexprconstchar chainFixups[] = "__chainfixups";
constexprconstchar codeSignature[] = "__code_signature";
constexprconstchar common[] = "__common";
constexprconstchar compactUnwind[] = "__compact_unwind";
constexprconstchar data[] = "__data";
constexprconstchar debugAbbrev[] = "__debug_abbrev";
constexprconstchar debugInfo[] = "__debug_info";
constexprconstchar debugLine[] = "__debug_line";
constexprconstchar debugStr[] = "__debug_str";
constexprconstchar debugStrOffs[] = "__debug_str_offs";
constexprconstchar ehFrame[] = "__eh_frame";
constexprconstchar gccExceptTab[] = "__gcc_except_tab";
constexprconstchar export_[] = "__export";
constexprconstchar dataInCode[] = "__data_in_code";
constexprconstchar functionStarts[] = "__func_starts";
constexprconstchar got[] = "__got";
constexprconstchar header[] = "__mach_header";
constexprconstchar indirectSymbolTable[] = "__ind_sym_tab";
constexprconstchar initOffsets[] = "__init_offsets";
constexprconstchar const_[] = "__const";
constexprconstchar lazySymbolPtr[] = "__la_symbol_ptr";
constexprconstchar lazyBinding[] = "__lazy_binding";
constexprconstchar literals[] = "__literals";
constexprconstchar functionMap[] = "__llvm_merge";
constexprconstchar moduleInitFunc[] = "__mod_init_func";
constexprconstchar moduleTermFunc[] = "__mod_term_func";
constexprconstchar nonLazySymbolPtr[] = "__nl_symbol_ptr";
constexprconstchar objcCatList[] = "__objc_catlist";
constexprconstchar objcClassList[] = "__objc_classlist";
constexprconstchar objcMethList[] = "__objc_methlist";
constexprconstchar objcClassRefs[] = "__objc_classrefs";
constexprconstchar objcConst[] = "__objc_const";
constexprconstchar objCImageInfo[] = "__objc_imageinfo";
constexprconstchar objcStubs[] = "__objc_stubs";
constexprconstchar objcSelrefs[] = "__objc_selrefs";
constexprconstchar objcMethname[] = "__objc_methname";
constexprconstchar objcNonLazyCatList[] = "__objc_nlcatlist";
constexprconstchar objcNonLazyClassList[] = "__objc_nlclslist";
constexprconstchar objcProtoList[] = "__objc_protolist";
constexprconstchar outlinedHashTree[] = "__llvm_outline";
constexprconstchar pageZero[] = "__pagezero";
constexprconstchar pointers[] = "__pointers";
constexprconstchar rebase[] = "__rebase";
constexprconstchar staticInit[] = "__StaticInit";
constexprconstchar stringTable[] = "__string_table";
constexprconstchar stubHelper[] = "__stub_helper";
constexprconstchar stubs[] = "__stubs";
constexprconstchar swift[] = "__swift";
constexprconstchar symbolTable[] = "__symbol_table";
constexprconstchar textCoalNt[] = "__textcoal_nt";
constexprconstchar text[] = "__text";
constexprconstchar threadPtrs[] = "__thread_ptrs";
constexprconstchar threadVars[] = "__thread_vars";
constexprconstchar unwindInfo[] = "__unwind_info";
constexprconstchar weakBinding[] = "__weak_binding";
constexprconstchar zeroFill[] = "__zerofill";
constexprconstchar addrSig[] = "__llvm_addrsig";

} // namespace section_names

voidaddInputSection(InputSection *inputSection);
} // namespace macho

std::string toString(const macho::InputSection *);

} // namespace lld

#endif