/
InputSection.cpp
175 lines (150 loc) · 5.78 KB
/
InputSection.cpp
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
//===- 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 "InputFiles.h"
#include "OutputSegment.h"
#include "Symbols.h"
#include "SyntheticSections.h"
#include "Target.h"
#include "Writer.h"
#include "lld/Common/Memory.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/xxhash.h"
using namespace llvm;
using namespace llvm::MachO;
using namespace llvm::support;
using namespace lld;
using namespace lld::macho;
std::vector<InputSection *> macho::inputSections;
uint64_t ConcatInputSection::getFileOffset(uint64_t off) const {
return parent->fileOff + outSecFileOff + off;
}
uint64_t InputSection::getFileSize() const {
return isZeroFill(flags) ? 0 : getSize();
}
uint64_t InputSection::getVA(uint64_t off) const {
return parent->addr + getOffset(off);
}
static uint64_t resolveSymbolVA(const Symbol *sym, uint8_t type) {
const RelocAttrs &relocAttrs = target->getRelocAttrs(type);
if (relocAttrs.hasAttr(RelocAttrBits::BRANCH))
return sym->resolveBranchVA();
else if (relocAttrs.hasAttr(RelocAttrBits::GOT))
return sym->resolveGotVA();
else if (relocAttrs.hasAttr(RelocAttrBits::TLV))
return sym->resolveTlvVA();
return sym->getVA();
}
void InputSection::writeTo(uint8_t *buf) {
assert(!shouldOmitFromOutput());
if (getFileSize() == 0)
return;
memcpy(buf, data.data(), data.size());
for (size_t i = 0; i < relocs.size(); i++) {
const Reloc &r = relocs[i];
uint8_t *loc = buf + r.offset;
uint64_t referentVA = 0;
if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
const Symbol *fromSym = r.referent.get<Symbol *>();
const Reloc &minuend = relocs[++i];
uint64_t minuendVA;
if (const Symbol *toSym = minuend.referent.dyn_cast<Symbol *>())
minuendVA = toSym->getVA() + minuend.addend;
else {
auto *referentIsec = minuend.referent.get<InputSection *>();
assert(!referentIsec->shouldOmitFromOutput());
minuendVA = referentIsec->getVA(minuend.addend);
}
referentVA = minuendVA - fromSym->getVA();
} else if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
if (target->hasAttr(r.type, RelocAttrBits::LOAD) &&
!referentSym->isInGot())
target->relaxGotLoad(loc, r.type);
referentVA = resolveSymbolVA(referentSym, r.type) + r.addend;
if (isThreadLocalVariables(flags)) {
// References from thread-local variable sections are treated as offsets
// relative to the start of the thread-local data memory area, which
// is initialized via copying all the TLV data sections (which are all
// contiguous).
if (isa<Defined>(referentSym))
referentVA -= firstTLVDataSection->addr;
}
} else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
assert(!referentIsec->shouldOmitFromOutput());
referentVA = referentIsec->getVA(r.addend);
}
target->relocateOne(loc, r, referentVA, getVA(r.offset));
}
}
void CStringInputSection::splitIntoPieces() {
size_t off = 0;
StringRef s = toStringRef(data);
while (!s.empty()) {
size_t end = s.find(0);
if (end == StringRef::npos)
fatal(toString(this) + ": string is not null terminated");
size_t size = end + 1;
pieces.emplace_back(off, xxHash64(s.substr(0, size)));
s = s.substr(size);
off += size;
}
}
const StringPiece &CStringInputSection::getStringPiece(uint64_t off) const {
if (off >= data.size())
fatal(toString(this) + ": offset is outside the section");
auto it =
partition_point(pieces, [=](StringPiece p) { return p.inSecOff <= off; });
return it[-1];
}
uint64_t CStringInputSection::getFileOffset(uint64_t off) const {
return parent->fileOff + getOffset(off);
}
uint64_t CStringInputSection::getOffset(uint64_t off) const {
const StringPiece &piece = getStringPiece(off);
uint64_t addend = off - piece.inSecOff;
return piece.outSecOff + addend;
}
WordLiteralInputSection::WordLiteralInputSection(StringRef segname,
StringRef name,
InputFile *file,
ArrayRef<uint8_t> data,
uint32_t align, uint32_t flags)
: InputSection(WordLiteralKind, segname, name, file, data, align, flags) {}
uint64_t WordLiteralInputSection::getFileOffset(uint64_t off) const {
return parent->fileOff + getOffset(off);
}
uint64_t WordLiteralInputSection::getOffset(uint64_t off) const {
auto *osec = cast<WordLiteralSection>(parent);
const uint8_t *buf = data.data();
switch (sectionType(flags)) {
case S_4BYTE_LITERALS:
return osec->getLiteral4Offset(buf + off);
case S_8BYTE_LITERALS:
return osec->getLiteral8Offset(buf + off);
case S_16BYTE_LITERALS:
return osec->getLiteral16Offset(buf + off);
default:
llvm_unreachable("invalid literal section type");
}
}
bool macho::isCodeSection(const InputSection *isec) {
uint32_t type = sectionType(isec->flags);
if (type != S_REGULAR && type != S_COALESCED)
return false;
uint32_t attr = isec->flags & SECTION_ATTRIBUTES_USR;
if (attr == S_ATTR_PURE_INSTRUCTIONS)
return true;
if (isec->segname == segment_names::text)
return StringSwitch<bool>(isec->name)
.Cases(section_names::textCoalNt, section_names::staticInit, true)
.Default(false);
return false;
}
std::string lld::toString(const InputSection *isec) {
return (toString(isec->file) + ":(" + isec->name + ")").str();
}