1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
//===- 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
#define LLD_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"
namespace lld::macho {
class Defined;
// 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.
class ConcatOutputSection : public OutputSection {
public:
explicit ConcatOutputSection(StringRef name)
: OutputSection(ConcatKind, name) {}
const ConcatInputSection *firstSection() const { return inputs.front(); }
const ConcatInputSection *lastSection() const { return inputs.back(); }
bool isNeeded() const override { return !inputs.empty(); }
// These accessors will only be valid after finalizing the section
uint64_t getSize() const override { return size; }
uint64_t getFileSize() const override { 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()`.
virtual void finalizeContents();
void addInput(ConcatInputSection *input);
void writeTo(uint8_t *buf) const override;
static bool classof(const OutputSection *sec) {
return sec->kind() == ConcatKind;
}
static ConcatOutputSection *getOrCreateForInput(const InputSection *);
std::vector<ConcatInputSection *> inputs;
protected:
size_t size = 0;
uint64_t fileSize = 0;
void finalizeOne(ConcatInputSection *);
private:
void finalizeFlags(InputSection *input);
};
// ConcatOutputSections that contain code (text) require special handling to
// support thunk insertion.
class TextOutputSection : public ConcatOutputSection {
public:
explicit TextOutputSection(StringRef name) : ConcatOutputSection(name) {}
void finalizeContents() override {}
void finalize() override;
bool needsThunks() const;
void writeTo(uint8_t *buf) const override;
private:
uint64_t estimateStubsInRangeVA(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.
struct ThunkInfo {
// 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
|
