1//===- InputChunks.h --------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// An InputChunks represents an indivisible opaque region of a input wasm file.
10// i.e. a single wasm data segment or a single wasm function.
11//
12// They are written directly to the mmap'd output file after which relocations
13// are applied. Because each Chunk is independent they can be written in
14// parallel.
15//
16// Chunks are also unit on which garbage collection (--gc-sections) operates.
17//
18//===----------------------------------------------------------------------===//
19
20#ifndef LLD_WASM_INPUT_CHUNKS_H
21#define LLD_WASM_INPUT_CHUNKS_H
22
23#include "Config.h"
24#include "InputFiles.h"
25#include "lld/Common/ErrorHandler.h"
26#include "lld/Common/LLVM.h"
27#include "llvm/ADT/CachedHashString.h"
28#include "llvm/MC/StringTableBuilder.h"
29#include "llvm/Object/Wasm.h"
30#include <optional>
31
32namespace lld {
33namespace wasm {
34
35class ObjFile;
36class OutputSegment;
37class OutputSection;
38
39class InputChunk {
40public:
41 enum Kind {
42 DataSegment,
43 Merge,
44 MergedChunk,
45 Function,
46 SyntheticFunction,
47 Section,
48 };
49
50 StringRef name;
51 StringRef debugName;
52
53 Kind kind() const { return (Kind)sectionKind; }
54
55 uint32_t getSize() const;
56 uint32_t getInputSize() const;
57
58 void writeTo(uint8_t *buf) const;
59 void relocate(uint8_t *buf) const;
60
61 ArrayRef<WasmRelocation> getRelocations() const { return relocations; }
62 void setRelocations(ArrayRef<WasmRelocation> rs) { relocations = rs; }
63
64 // Translate an offset into the input chunk to an offset in the output
65 // section.
66 uint64_t getOffset(uint64_t offset) const;
67 // Translate an offset into the input chunk into an offset into the output
68 // chunk. For data segments (InputSegment) this will return and offset into
69 // the output segment. For MergeInputChunk, this will return an offset into
70 // the parent merged chunk. For other chunk types this is no-op and we just
71 // return unmodified offset.
72 uint64_t getChunkOffset(uint64_t offset) const;
73 uint64_t getVA(uint64_t offset = 0) const;
74
75 uint32_t getComdat() const { return comdat; }
76 StringRef getComdatName() const;
77 uint32_t getInputSectionOffset() const { return inputSectionOffset; }
78
79 size_t getNumRelocations() const { return relocations.size(); }
80 void writeRelocations(llvm::raw_ostream &os) const;
81 void generateRelocationCode(raw_ostream &os) const;
82
83 bool isTLS() const { return flags & llvm::wasm::WASM_SEG_FLAG_TLS; }
84 bool isRetained() const { return flags & llvm::wasm::WASM_SEG_FLAG_RETAIN; }
85
86 ObjFile *file;
87 OutputSection *outputSec = nullptr;
88 uint32_t comdat = UINT32_MAX;
89 uint32_t inputSectionOffset = 0;
90 uint32_t alignment;
91 uint32_t flags;
92
93 // Only applies to data segments.
94 uint32_t outputSegmentOffset = 0;
95 const OutputSegment *outputSeg = nullptr;
96
97 // After assignAddresses is called, this represents the offset from
98 // the beginning of the output section this chunk was assigned to.
99 int32_t outSecOff = 0;
100
101 uint8_t sectionKind : 3;
102
103 // Signals that the section is part of the output. The garbage collector,
104 // and COMDAT handling can set a sections' Live bit.
105 // If GC is disabled, all sections start out as live by default.
106 unsigned live : 1;
107
108 // Signals the chunk was discarded by COMDAT handling.
109 unsigned discarded : 1;
110
111protected:
112 InputChunk(ObjFile *f, Kind k, StringRef name, uint32_t alignment = 0,
113 uint32_t flags = 0)
114 : name(name), file(f), alignment(alignment), flags(flags), sectionKind(k),
115 live(!config->gcSections), discarded(false) {}
116 ArrayRef<uint8_t> data() const { return rawData; }
117 uint64_t getTombstone() const;
118
119 ArrayRef<WasmRelocation> relocations;
120 ArrayRef<uint8_t> rawData;
121};
122
123// Represents a WebAssembly data segment which can be included as part of
124// an output data segments. Note that in WebAssembly, unlike ELF and other
125// formats, used the term "data segment" to refer to the continuous regions of
126// memory that make on the data section. See:
127// https://webassembly.github.io/spec/syntax/modules.html#syntax-data
128//
129// For example, by default, clang will produce a separate data section for
130// each global variable.
131class InputSegment : public InputChunk {
132public:
133 InputSegment(const WasmSegment &seg, ObjFile *f)
134 : InputChunk(f, InputChunk::DataSegment, seg.Data.Name,
135 seg.Data.Alignment, seg.Data.LinkingFlags),
136 segment(seg) {
137 rawData = segment.Data.Content;
138 comdat = segment.Data.Comdat;
139 inputSectionOffset = segment.SectionOffset;
140 }
141
142 static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
143
144protected:
145 const WasmSegment &segment;
146};
147
148class SyntheticMergedChunk;
149
150// Merge segment handling copied from lld/ELF/InputSection.h. Keep in sync
151// where possible.
152
153// SectionPiece represents a piece of splittable segment contents.
154// We allocate a lot of these and binary search on them. This means that they
155// have to be as compact as possible, which is why we don't store the size (can
156// be found by looking at the next one).
157struct SectionPiece {
158 SectionPiece(size_t off, uint32_t hash, bool live)
159 : inputOff(off), live(live || !config->gcSections), hash(hash >> 1) {}
160
161 uint32_t inputOff;
162 uint32_t live : 1;
163 uint32_t hash : 31;
164 uint64_t outputOff = 0;
165};
166
167static_assert(sizeof(SectionPiece) == 16, "SectionPiece is too big");
168
169// This corresponds segments marked as WASM_SEG_FLAG_STRINGS.
170class MergeInputChunk : public InputChunk {
171public:
172 MergeInputChunk(const WasmSegment &seg, ObjFile *f)
173 : InputChunk(f, Merge, seg.Data.Name, seg.Data.Alignment,
174 seg.Data.LinkingFlags) {
175 rawData = seg.Data.Content;
176 comdat = seg.Data.Comdat;
177 inputSectionOffset = seg.SectionOffset;
178 }
179
180 MergeInputChunk(const WasmSection &s, ObjFile *f)
181 : InputChunk(f, Merge, s.Name, 0, llvm::wasm::WASM_SEG_FLAG_STRINGS) {
182 assert(s.Type == llvm::wasm::WASM_SEC_CUSTOM);
183 comdat = s.Comdat;
184 rawData = s.Content;
185 }
186
187 static bool classof(const InputChunk *s) { return s->kind() == Merge; }
188 void splitIntoPieces();
189
190 // Translate an offset in the input section to an offset in the parent
191 // MergeSyntheticSection.
192 uint64_t getParentOffset(uint64_t offset) const;
193
194 // Splittable sections are handled as a sequence of data
195 // rather than a single large blob of data.
196 std::vector<SectionPiece> pieces;
197
198 // Returns I'th piece's data. This function is very hot when
199 // string merging is enabled, so we want to inline.
200 LLVM_ATTRIBUTE_ALWAYS_INLINE
201 llvm::CachedHashStringRef getData(size_t i) const {
202 size_t begin = pieces[i].inputOff;
203 size_t end =
204 (pieces.size() - 1 == i) ? data().size() : pieces[i + 1].inputOff;
205 return {toStringRef(Input: data().slice(N: begin, M: end - begin)), pieces[i].hash};
206 }
207
208 // Returns the SectionPiece at a given input section offset.
209 SectionPiece *getSectionPiece(uint64_t offset);
210 const SectionPiece *getSectionPiece(uint64_t offset) const {
211 return const_cast<MergeInputChunk *>(this)->getSectionPiece(offset);
212 }
213
214 SyntheticMergedChunk *parent = nullptr;
215
216private:
217 void splitStrings(ArrayRef<uint8_t> a);
218};
219
220// SyntheticMergedChunk is a class that allows us to put mergeable
221// sections with different attributes in a single output sections. To do that we
222// put them into SyntheticMergedChunk synthetic input sections which are
223// attached to regular output sections.
224class SyntheticMergedChunk : public InputChunk {
225public:
226 SyntheticMergedChunk(StringRef name, uint32_t alignment, uint32_t flags)
227 : InputChunk(nullptr, InputChunk::MergedChunk, name, alignment, flags),
228 builder(llvm::StringTableBuilder::RAW, llvm::Align(1ULL << alignment)) {
229 }
230
231 static bool classof(const InputChunk *c) {
232 return c->kind() == InputChunk::MergedChunk;
233 }
234
235 void addMergeChunk(MergeInputChunk *ms) {
236 comdat = ms->getComdat();
237 ms->parent = this;
238 chunks.push_back(x: ms);
239 }
240
241 void finalizeContents();
242
243 llvm::StringTableBuilder builder;
244
245protected:
246 std::vector<MergeInputChunk *> chunks;
247};
248
249// Represents a single wasm function within and input file. These are
250// combined to create the final output CODE section.
251class InputFunction : public InputChunk {
252public:
253 InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f)
254 : InputChunk(f, InputChunk::Function, func->SymbolName), signature(s),
255 function(func),
256 exportName(func && func->ExportName ? (*func->ExportName).str()
257 : std::optional<std::string>()) {
258 inputSectionOffset = function->CodeSectionOffset;
259 rawData =
260 file->codeSection->Content.slice(N: inputSectionOffset, M: function->Size);
261 debugName = function->DebugName;
262 comdat = function->Comdat;
263 assert(s.Kind != WasmSignature::Placeholder);
264 }
265
266 InputFunction(StringRef name, const WasmSignature &s)
267 : InputChunk(nullptr, InputChunk::Function, name), signature(s) {
268 assert(s.Kind == WasmSignature::Function);
269 }
270
271 static bool classof(const InputChunk *c) {
272 return c->kind() == InputChunk::Function ||
273 c->kind() == InputChunk::SyntheticFunction;
274 }
275
276 std::optional<StringRef> getExportName() const {
277 return exportName ? std::optional<StringRef>(*exportName)
278 : std::optional<StringRef>();
279 }
280 void setExportName(std::string exportName) { this->exportName = exportName; }
281 uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
282 uint32_t getFunctionCodeOffset() const {
283 // For generated synthetic functions, such as unreachable stubs generated
284 // for signature mismatches, 'function' reference does not exist. This
285 // function is used to get function offsets for .debug_info section, and for
286 // those generated stubs function offsets are not meaningful anyway. So just
287 // return 0 in those cases.
288 return function ? function->CodeOffset : 0;
289 }
290 uint32_t getFunctionIndex() const { return *functionIndex; }
291 bool hasFunctionIndex() const { return functionIndex.has_value(); }
292 void setFunctionIndex(uint32_t index);
293 uint32_t getTableIndex() const { return *tableIndex; }
294 bool hasTableIndex() const { return tableIndex.has_value(); }
295 void setTableIndex(uint32_t index);
296 void writeCompressed(uint8_t *buf) const;
297
298 // The size of a given input function can depend on the values of the
299 // LEB relocations within it. This finalizeContents method is called after
300 // all the symbol values have be calculated but before getSize() is ever
301 // called.
302 void calculateSize();
303
304 const WasmSignature &signature;
305
306 uint32_t getCompressedSize() const {
307 assert(compressedSize);
308 return compressedSize;
309 }
310
311 const WasmFunction *function = nullptr;
312
313protected:
314 std::optional<std::string> exportName;
315 std::optional<uint32_t> functionIndex;
316 std::optional<uint32_t> tableIndex;
317 uint32_t compressedFuncSize = 0;
318 uint32_t compressedSize = 0;
319};
320
321class SyntheticFunction : public InputFunction {
322public:
323 SyntheticFunction(const WasmSignature &s, StringRef name,
324 StringRef debugName = {})
325 : InputFunction(name, s) {
326 sectionKind = InputChunk::SyntheticFunction;
327 this->debugName = debugName;
328 }
329
330 static bool classof(const InputChunk *c) {
331 return c->kind() == InputChunk::SyntheticFunction;
332 }
333
334 void setBody(ArrayRef<uint8_t> body) { rawData = body; }
335};
336
337// Represents a single Wasm Section within an input file.
338class InputSection : public InputChunk {
339public:
340 InputSection(const WasmSection &s, ObjFile *f)
341 : InputChunk(f, InputChunk::Section, s.Name),
342 tombstoneValue(getTombstoneForSection(name: s.Name)), section(s) {
343 assert(section.Type == llvm::wasm::WASM_SEC_CUSTOM);
344 comdat = section.Comdat;
345 rawData = section.Content;
346 }
347
348 static bool classof(const InputChunk *c) {
349 return c->kind() == InputChunk::Section;
350 }
351
352 const uint64_t tombstoneValue;
353
354protected:
355 static uint64_t getTombstoneForSection(StringRef name);
356 const WasmSection &section;
357};
358
359} // namespace wasm
360
361std::string toString(const wasm::InputChunk *);
362StringRef relocTypeToString(uint8_t relocType);
363
364} // namespace lld
365
366#endif // LLD_WASM_INPUT_CHUNKS_H
367