ConcatOutputSection.h

//===- ConcatOutputSection.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_CONCAT_OUTPUT_SECTION_H
#defineLLD_MACHO_CONCAT_OUTPUT_SECTION_H

#include"InputSection.h"
#include"OutputSection.h"
#include"lld/Common/LLVM.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/MapVector.h"

namespacelld::macho {

classDefined;

// Linking multiple files will inevitably mean resolving sections in different
// files that are labeled with the same segment and section name. This class
// contains all such sections and writes the data from each section sequentially
// in the final binary.
classConcatOutputSection : publicOutputSection {
public:
explicitConcatOutputSection(StringRef name,
 OutputSection::Kind kind = ConcatKind)
 : OutputSection(kind, name) {}

const ConcatInputSection *firstSection() const { return inputs.front(); }
const ConcatInputSection *lastSection() const { return inputs.back(); }
boolisNeeded() constoverride { return !inputs.empty(); }

// These accessors will only be valid after finalizing the section
uint64_tgetSize() constoverride { return size; }
uint64_tgetFileSize() constoverride { return fileSize; }

// Assign values to InputSection::outSecOff. In contrast to TextOutputSection,
// which does this in its implementation of `finalize()`, we can do this
// without `finalize()`'s sequential guarantees detailed in the block comment
// of `OutputSection::finalize()`.
virtualvoidfinalizeContents();

voidaddInput(ConcatInputSection *input);
voidwriteTo(uint8_t *buf) constoverride;

staticboolclassof(const OutputSection *sec) {
return sec->kind() == ConcatKind || sec->kind() == TextKind;
 }

static ConcatOutputSection *getOrCreateForInput(const InputSection *);

 std::vector<ConcatInputSection *> inputs;

protected:
size_t size = 0;
uint64_t fileSize = 0;
voidfinalizeOne(ConcatInputSection *);

private:
voidfinalizeFlags(InputSection *input);
};

// ConcatOutputSections that contain code (text) require special handling to
// support thunk insertion.
classTextOutputSection : publicConcatOutputSection {
public:
explicitTextOutputSection(StringRef name)
 : ConcatOutputSection(name, TextKind) {}
voidfinalizeContents() override {}
voidfinalize() override;
boolneedsThunks() const;
 ArrayRef<ConcatInputSection *> getThunks() const { return thunks; }
voidwriteTo(uint8_t *buf) constoverride;

staticboolclassof(const OutputSection *sec) {
return sec->kind() == TextKind;
 }

private:
uint64_testimateStubsInRangeVA(size_t callIdx) const;

 std::vector<ConcatInputSection *> thunks;
};

// We maintain one ThunkInfo per real function.
//
// The "active thunk" is represented by the sym/isec pair that
// turns-over during finalize(): as the call-site address advances,
// the active thunk goes out of branch-range, and we create a new
// thunk to take its place.
//
// The remaining members -- bools and counters -- apply to the
// collection of thunks associated with the real function.

structThunkInfo {
// These denote the active thunk:
 Defined *sym = nullptr; // private-extern symbol for active thunk
 ConcatInputSection *isec = nullptr; // input section for active thunk

// The following values are cumulative across all thunks on this function
uint32_t callSiteCount = 0; // how many calls to the real function?
uint32_t callSitesUsed = 0; // how many call sites processed so-far?
uint32_t thunkCallCount = 0; // how many call sites went to thunk?
uint8_t sequence = 0; // how many thunks created so-far?
};

NamePair maybeRenameSection(NamePair key);

// Output sections are added to output segments in iteration order
// of ConcatOutputSection, so must have deterministic iteration order.
extern llvm::MapVector<NamePair, ConcatOutputSection *> concatOutputSections;

extern llvm::DenseMap<Symbol *, ThunkInfo> thunkMap;

} // namespace lld::macho

#endif