1//===- WasmObjectFile.cpp - Wasm object file implementation ---------------===//
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#include "llvm/ADT/ArrayRef.h"
10#include "llvm/ADT/DenseSet.h"
11#include "llvm/ADT/SmallSet.h"
12#include "llvm/ADT/StringRef.h"
13#include "llvm/ADT/StringSet.h"
14#include "llvm/ADT/StringSwitch.h"
15#include "llvm/BinaryFormat/Wasm.h"
16#include "llvm/Object/Binary.h"
17#include "llvm/Object/Error.h"
18#include "llvm/Object/ObjectFile.h"
19#include "llvm/Object/SymbolicFile.h"
20#include "llvm/Object/Wasm.h"
21#include "llvm/Support/Endian.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/ErrorHandling.h"
24#include "llvm/Support/LEB128.h"
25#include "llvm/Support/ScopedPrinter.h"
26#include "llvm/TargetParser/SubtargetFeature.h"
27#include "llvm/TargetParser/Triple.h"
28#include <cassert>
29#include <cstdint>
30#include <cstring>
31
32#define DEBUG_TYPE "wasm-object"
33
34using namespace llvm;
35using namespace object;
36
37void WasmSymbol::print(raw_ostream &Out) const {
38 Out << "Name=" << Info.Name
39 << ", Kind=" << toString(type: wasm::WasmSymbolType(Info.Kind)) << ", Flags=0x"
40 << Twine::utohexstr(Val: Info.Flags) << " [";
41 switch (getBinding()) {
42 case wasm::WASM_SYMBOL_BINDING_GLOBAL: Out << "global"; break;
43 case wasm::WASM_SYMBOL_BINDING_LOCAL: Out << "local"; break;
44 case wasm::WASM_SYMBOL_BINDING_WEAK: Out << "weak"; break;
45 }
46 if (isHidden())
47 Out << ", hidden";
48 else
49 Out << ", default";
50 if (Info.Flags & wasm::WASM_SYMBOL_NO_STRIP)
51 Out << ", no_strip";
52 if (Info.Flags & wasm::WASM_SYMBOL_TLS)
53 Out << ", tls";
54 if (Info.Flags & wasm::WASM_SYMBOL_ABSOLUTE)
55 Out << ", absolute";
56 if (Info.Flags & wasm::WASM_SYMBOL_EXPORTED)
57 Out << ", exported";
58 if (isUndefined())
59 Out << ", undefined";
60 Out << "]";
61 if (!isTypeData()) {
62 Out << ", ElemIndex=" << Info.ElementIndex;
63 } else if (isDefined()) {
64 Out << ", Segment=" << Info.DataRef.Segment;
65 Out << ", Offset=" << Info.DataRef.Offset;
66 Out << ", Size=" << Info.DataRef.Size;
67 }
68}
69
70#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
71LLVM_DUMP_METHOD void WasmSymbol::dump() const { print(dbgs()); }
72#endif
73
74Expected<std::unique_ptr<WasmObjectFile>>
75ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
76 Error Err = Error::success();
77 auto ObjectFile = std::make_unique<WasmObjectFile>(args&: Buffer, args&: Err);
78 if (Err)
79 return std::move(Err);
80
81 return std::move(ObjectFile);
82}
83
84#define VARINT7_MAX ((1 << 7) - 1)
85#define VARINT7_MIN (-(1 << 7))
86#define VARUINT7_MAX (1 << 7)
87#define VARUINT1_MAX (1)
88
89static uint8_t readUint8(WasmObjectFile::ReadContext &Ctx) {
90 if (Ctx.Ptr == Ctx.End)
91 report_fatal_error(reason: "EOF while reading uint8");
92 return *Ctx.Ptr++;
93}
94
95static uint32_t readUint32(WasmObjectFile::ReadContext &Ctx) {
96 if (Ctx.Ptr + 4 > Ctx.End)
97 report_fatal_error(reason: "EOF while reading uint32");
98 uint32_t Result = support::endian::read32le(P: Ctx.Ptr);
99 Ctx.Ptr += 4;
100 return Result;
101}
102
103static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
104 if (Ctx.Ptr + 4 > Ctx.End)
105 report_fatal_error(reason: "EOF while reading float64");
106 int32_t Result = 0;
107 memcpy(dest: &Result, src: Ctx.Ptr, n: sizeof(Result));
108 Ctx.Ptr += sizeof(Result);
109 return Result;
110}
111
112static int64_t readFloat64(WasmObjectFile::ReadContext &Ctx) {
113 if (Ctx.Ptr + 8 > Ctx.End)
114 report_fatal_error(reason: "EOF while reading float64");
115 int64_t Result = 0;
116 memcpy(dest: &Result, src: Ctx.Ptr, n: sizeof(Result));
117 Ctx.Ptr += sizeof(Result);
118 return Result;
119}
120
121static uint64_t readULEB128(WasmObjectFile::ReadContext &Ctx) {
122 unsigned Count;
123 const char *Error = nullptr;
124 uint64_t Result = decodeULEB128(p: Ctx.Ptr, n: &Count, end: Ctx.End, error: &Error);
125 if (Error)
126 report_fatal_error(reason: Error);
127 Ctx.Ptr += Count;
128 return Result;
129}
130
131static StringRef readString(WasmObjectFile::ReadContext &Ctx) {
132 uint32_t StringLen = readULEB128(Ctx);
133 if (Ctx.Ptr + StringLen > Ctx.End)
134 report_fatal_error(reason: "EOF while reading string");
135 StringRef Return =
136 StringRef(reinterpret_cast<const char *>(Ctx.Ptr), StringLen);
137 Ctx.Ptr += StringLen;
138 return Return;
139}
140
141static int64_t readLEB128(WasmObjectFile::ReadContext &Ctx) {
142 unsigned Count;
143 const char *Error = nullptr;
144 uint64_t Result = decodeSLEB128(p: Ctx.Ptr, n: &Count, end: Ctx.End, error: &Error);
145 if (Error)
146 report_fatal_error(reason: Error);
147 Ctx.Ptr += Count;
148 return Result;
149}
150
151static uint8_t readVaruint1(WasmObjectFile::ReadContext &Ctx) {
152 int64_t Result = readLEB128(Ctx);
153 if (Result > VARUINT1_MAX || Result < 0)
154 report_fatal_error(reason: "LEB is outside Varuint1 range");
155 return Result;
156}
157
158static int32_t readVarint32(WasmObjectFile::ReadContext &Ctx) {
159 int64_t Result = readLEB128(Ctx);
160 if (Result > INT32_MAX || Result < INT32_MIN)
161 report_fatal_error(reason: "LEB is outside Varint32 range");
162 return Result;
163}
164
165static uint32_t readVaruint32(WasmObjectFile::ReadContext &Ctx) {
166 uint64_t Result = readULEB128(Ctx);
167 if (Result > UINT32_MAX)
168 report_fatal_error(reason: "LEB is outside Varuint32 range");
169 return Result;
170}
171
172static int64_t readVarint64(WasmObjectFile::ReadContext &Ctx) {
173 return readLEB128(Ctx);
174}
175
176static uint64_t readVaruint64(WasmObjectFile::ReadContext &Ctx) {
177 return readULEB128(Ctx);
178}
179
180static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
181 return readUint8(Ctx);
182}
183
184static wasm::ValType parseValType(WasmObjectFile::ReadContext &Ctx,
185 uint32_t Code) {
186 // only directly encoded FUNCREF/EXTERNREF/EXNREF are supported
187 // (not ref null func, ref null extern, or ref null exn)
188 switch (Code) {
189 case wasm::WASM_TYPE_I32:
190 case wasm::WASM_TYPE_I64:
191 case wasm::WASM_TYPE_F32:
192 case wasm::WASM_TYPE_F64:
193 case wasm::WASM_TYPE_V128:
194 case wasm::WASM_TYPE_FUNCREF:
195 case wasm::WASM_TYPE_EXTERNREF:
196 case wasm::WASM_TYPE_EXNREF:
197 return wasm::ValType(Code);
198 }
199 if (Code == wasm::WASM_TYPE_NULLABLE || Code == wasm::WASM_TYPE_NONNULLABLE) {
200 /* Discard HeapType */ readVarint64(Ctx);
201 }
202 return wasm::ValType(wasm::ValType::OTHERREF);
203}
204
205static Error readInitExpr(wasm::WasmInitExpr &Expr,
206 WasmObjectFile::ReadContext &Ctx) {
207 auto Start = Ctx.Ptr;
208
209 Expr.Extended = false;
210 Expr.Inst.Opcode = readOpcode(Ctx);
211 switch (Expr.Inst.Opcode) {
212 case wasm::WASM_OPCODE_I32_CONST:
213 Expr.Inst.Value.Int32 = readVarint32(Ctx);
214 break;
215 case wasm::WASM_OPCODE_I64_CONST:
216 Expr.Inst.Value.Int64 = readVarint64(Ctx);
217 break;
218 case wasm::WASM_OPCODE_F32_CONST:
219 Expr.Inst.Value.Float32 = readFloat32(Ctx);
220 break;
221 case wasm::WASM_OPCODE_F64_CONST:
222 Expr.Inst.Value.Float64 = readFloat64(Ctx);
223 break;
224 case wasm::WASM_OPCODE_GLOBAL_GET:
225 Expr.Inst.Value.Global = readULEB128(Ctx);
226 break;
227 case wasm::WASM_OPCODE_REF_NULL: {
228 /* Discard type */ parseValType(Ctx, Code: readVaruint32(Ctx));
229 break;
230 }
231 default:
232 Expr.Extended = true;
233 }
234
235 if (!Expr.Extended) {
236 uint8_t EndOpcode = readOpcode(Ctx);
237 if (EndOpcode != wasm::WASM_OPCODE_END)
238 Expr.Extended = true;
239 }
240
241 if (Expr.Extended) {
242 Ctx.Ptr = Start;
243 while (true) {
244 uint8_t Opcode = readOpcode(Ctx);
245 switch (Opcode) {
246 case wasm::WASM_OPCODE_I32_CONST:
247 case wasm::WASM_OPCODE_GLOBAL_GET:
248 case wasm::WASM_OPCODE_REF_NULL:
249 case wasm::WASM_OPCODE_REF_FUNC:
250 case wasm::WASM_OPCODE_I64_CONST:
251 readULEB128(Ctx);
252 break;
253 case wasm::WASM_OPCODE_F32_CONST:
254 readFloat32(Ctx);
255 break;
256 case wasm::WASM_OPCODE_F64_CONST:
257 readFloat64(Ctx);
258 break;
259 case wasm::WASM_OPCODE_I32_ADD:
260 case wasm::WASM_OPCODE_I32_SUB:
261 case wasm::WASM_OPCODE_I32_MUL:
262 case wasm::WASM_OPCODE_I64_ADD:
263 case wasm::WASM_OPCODE_I64_SUB:
264 case wasm::WASM_OPCODE_I64_MUL:
265 break;
266 case wasm::WASM_OPCODE_GC_PREFIX:
267 break;
268 // The GC opcodes are in a separate (prefixed space). This flat switch
269 // structure works as long as there is no overlap between the GC and
270 // general opcodes used in init exprs.
271 case wasm::WASM_OPCODE_STRUCT_NEW:
272 case wasm::WASM_OPCODE_STRUCT_NEW_DEFAULT:
273 case wasm::WASM_OPCODE_ARRAY_NEW:
274 case wasm::WASM_OPCODE_ARRAY_NEW_DEFAULT:
275 readULEB128(Ctx); // heap type index
276 break;
277 case wasm::WASM_OPCODE_ARRAY_NEW_FIXED:
278 readULEB128(Ctx); // heap type index
279 readULEB128(Ctx); // array size
280 break;
281 case wasm::WASM_OPCODE_REF_I31:
282 break;
283 case wasm::WASM_OPCODE_END:
284 Expr.Body = ArrayRef<uint8_t>(Start, Ctx.Ptr - Start);
285 return Error::success();
286 default:
287 return make_error<GenericBinaryError>(Args: "invalid opcode in init_expr: " +
288 Twine(unsigned(Opcode)),
289 Args: object_error::parse_failed);
290 }
291 }
292 }
293
294 return Error::success();
295}
296
297static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
298 wasm::WasmLimits Result;
299 Result.Flags = readVaruint32(Ctx);
300 Result.Minimum = readVaruint64(Ctx);
301 if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
302 Result.Maximum = readVaruint64(Ctx);
303 if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_PAGE_SIZE) {
304 uint32_t PageSizeLog2 = readVaruint32(Ctx);
305 if (PageSizeLog2 >= 32)
306 report_fatal_error(reason: "log2(wasm page size) too large");
307 Result.PageSize = 1 << PageSizeLog2;
308 }
309 return Result;
310}
311
312static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
313 wasm::WasmTableType TableType;
314 auto ElemType = parseValType(Ctx, Code: readVaruint32(Ctx));
315 TableType.ElemType = ElemType;
316 TableType.Limits = readLimits(Ctx);
317 return TableType;
318}
319
320static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
321 WasmSectionOrderChecker &Checker) {
322 Section.Type = readUint8(Ctx);
323 LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n");
324 // When reading the section's size, store the size of the LEB used to encode
325 // it. This allows objcopy/strip to reproduce the binary identically.
326 const uint8_t *PreSizePtr = Ctx.Ptr;
327 uint32_t Size = readVaruint32(Ctx);
328 Section.HeaderSecSizeEncodingLen = Ctx.Ptr - PreSizePtr;
329 Section.Offset = Ctx.Ptr - Ctx.Start;
330 if (Size == 0)
331 return make_error<StringError>(Args: "zero length section",
332 Args: object_error::parse_failed);
333 if (Ctx.Ptr + Size > Ctx.End)
334 return make_error<StringError>(Args: "section too large",
335 Args: object_error::parse_failed);
336 if (Section.Type == wasm::WASM_SEC_CUSTOM) {
337 WasmObjectFile::ReadContext SectionCtx;
338 SectionCtx.Start = Ctx.Ptr;
339 SectionCtx.Ptr = Ctx.Ptr;
340 SectionCtx.End = Ctx.Ptr + Size;
341
342 Section.Name = readString(Ctx&: SectionCtx);
343
344 uint32_t SectionNameSize = SectionCtx.Ptr - SectionCtx.Start;
345 Ctx.Ptr += SectionNameSize;
346 Size -= SectionNameSize;
347 }
348
349 if (!Checker.isValidSectionOrder(ID: Section.Type, CustomSectionName: Section.Name)) {
350 return make_error<StringError>(Args: "out of order section type: " +
351 llvm::to_string(Value: Section.Type),
352 Args: object_error::parse_failed);
353 }
354
355 Section.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
356 Ctx.Ptr += Size;
357 return Error::success();
358}
359
360WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
361 : ObjectFile(Binary::ID_Wasm, Buffer) {
362 ErrorAsOutParameter ErrAsOutParam(Err);
363 Header.Magic = getData().substr(Start: 0, N: 4);
364 if (Header.Magic != StringRef("\0asm", 4)) {
365 Err = make_error<StringError>(Args: "invalid magic number",
366 Args: object_error::parse_failed);
367 return;
368 }
369
370 ReadContext Ctx;
371 Ctx.Start = getData().bytes_begin();
372 Ctx.Ptr = Ctx.Start + 4;
373 Ctx.End = Ctx.Start + getData().size();
374
375 if (Ctx.Ptr + 4 > Ctx.End) {
376 Err = make_error<StringError>(Args: "missing version number",
377 Args: object_error::parse_failed);
378 return;
379 }
380
381 Header.Version = readUint32(Ctx);
382 if (Header.Version != wasm::WasmVersion) {
383 Err = make_error<StringError>(Args: "invalid version number: " +
384 Twine(Header.Version),
385 Args: object_error::parse_failed);
386 return;
387 }
388
389 WasmSectionOrderChecker Checker;
390 while (Ctx.Ptr < Ctx.End) {
391 WasmSection Sec;
392 if ((Err = readSection(Section&: Sec, Ctx, Checker)))
393 return;
394 if ((Err = parseSection(Sec)))
395 return;
396
397 Sections.push_back(x: Sec);
398 }
399}
400
401Error WasmObjectFile::parseSection(WasmSection &Sec) {
402 ReadContext Ctx;
403 Ctx.Start = Sec.Content.data();
404 Ctx.End = Ctx.Start + Sec.Content.size();
405 Ctx.Ptr = Ctx.Start;
406 switch (Sec.Type) {
407 case wasm::WASM_SEC_CUSTOM:
408 return parseCustomSection(Sec, Ctx);
409 case wasm::WASM_SEC_TYPE:
410 return parseTypeSection(Ctx);
411 case wasm::WASM_SEC_IMPORT:
412 return parseImportSection(Ctx);
413 case wasm::WASM_SEC_FUNCTION:
414 return parseFunctionSection(Ctx);
415 case wasm::WASM_SEC_TABLE:
416 return parseTableSection(Ctx);
417 case wasm::WASM_SEC_MEMORY:
418 return parseMemorySection(Ctx);
419 case wasm::WASM_SEC_TAG:
420 return parseTagSection(Ctx);
421 case wasm::WASM_SEC_GLOBAL:
422 return parseGlobalSection(Ctx);
423 case wasm::WASM_SEC_EXPORT:
424 return parseExportSection(Ctx);
425 case wasm::WASM_SEC_START:
426 return parseStartSection(Ctx);
427 case wasm::WASM_SEC_ELEM:
428 return parseElemSection(Ctx);
429 case wasm::WASM_SEC_CODE:
430 return parseCodeSection(Ctx);
431 case wasm::WASM_SEC_DATA:
432 return parseDataSection(Ctx);
433 case wasm::WASM_SEC_DATACOUNT:
434 return parseDataCountSection(Ctx);
435 default:
436 return make_error<GenericBinaryError>(
437 Args: "invalid section type: " + Twine(Sec.Type), Args: object_error::parse_failed);
438 }
439}
440
441Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
442 // Legacy "dylink" section support.
443 // See parseDylink0Section for the current "dylink.0" section parsing.
444 HasDylinkSection = true;
445 DylinkInfo.MemorySize = readVaruint32(Ctx);
446 DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
447 DylinkInfo.TableSize = readVaruint32(Ctx);
448 DylinkInfo.TableAlignment = readVaruint32(Ctx);
449 uint32_t Count = readVaruint32(Ctx);
450 while (Count--) {
451 DylinkInfo.Needed.push_back(x: readString(Ctx));
452 }
453
454 if (Ctx.Ptr != Ctx.End)
455 return make_error<GenericBinaryError>(Args: "dylink section ended prematurely",
456 Args: object_error::parse_failed);
457 return Error::success();
458}
459
460Error WasmObjectFile::parseDylink0Section(ReadContext &Ctx) {
461 // See
462 // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md
463 HasDylinkSection = true;
464
465 const uint8_t *OrigEnd = Ctx.End;
466 while (Ctx.Ptr < OrigEnd) {
467 Ctx.End = OrigEnd;
468 uint8_t Type = readUint8(Ctx);
469 uint32_t Size = readVaruint32(Ctx);
470 LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
471 << "\n");
472 Ctx.End = Ctx.Ptr + Size;
473 uint32_t Count;
474 switch (Type) {
475 case wasm::WASM_DYLINK_MEM_INFO:
476 DylinkInfo.MemorySize = readVaruint32(Ctx);
477 DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
478 DylinkInfo.TableSize = readVaruint32(Ctx);
479 DylinkInfo.TableAlignment = readVaruint32(Ctx);
480 break;
481 case wasm::WASM_DYLINK_NEEDED:
482 Count = readVaruint32(Ctx);
483 while (Count--) {
484 DylinkInfo.Needed.push_back(x: readString(Ctx));
485 }
486 break;
487 case wasm::WASM_DYLINK_EXPORT_INFO: {
488 uint32_t Count = readVaruint32(Ctx);
489 while (Count--) {
490 DylinkInfo.ExportInfo.push_back(x: {.Name: readString(Ctx), .Flags: readVaruint32(Ctx)});
491 }
492 break;
493 }
494 case wasm::WASM_DYLINK_IMPORT_INFO: {
495 uint32_t Count = readVaruint32(Ctx);
496 while (Count--) {
497 DylinkInfo.ImportInfo.push_back(
498 x: {.Module: readString(Ctx), .Field: readString(Ctx), .Flags: readVaruint32(Ctx)});
499 }
500 break;
501 }
502 case wasm::WASM_DYLINK_RUNTIME_PATH: {
503 Count = readVaruint32(Ctx);
504 while (Count--) {
505 DylinkInfo.RuntimePath.push_back(x: readString(Ctx));
506 }
507 break;
508 }
509 default:
510 LLVM_DEBUG(dbgs() << "unknown dylink.0 sub-section: " << Type << "\n");
511 Ctx.Ptr += Size;
512 break;
513 }
514 if (Ctx.Ptr != Ctx.End) {
515 return make_error<GenericBinaryError>(
516 Args: "dylink.0 sub-section ended prematurely", Args: object_error::parse_failed);
517 }
518 }
519
520 if (Ctx.Ptr != Ctx.End)
521 return make_error<GenericBinaryError>(Args: "dylink.0 section ended prematurely",
522 Args: object_error::parse_failed);
523 return Error::success();
524}
525
526Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
527 llvm::DenseSet<uint64_t> SeenFunctions;
528 llvm::DenseSet<uint64_t> SeenGlobals;
529 llvm::DenseSet<uint64_t> SeenSegments;
530
531 // If we have linking section (symbol table) or if we are parsing a DSO
532 // then we don't use the name section for symbol information.
533 bool PopulateSymbolTable = !HasLinkingSection && !HasDylinkSection;
534
535 // If we are using the name section for symbol information then it will
536 // supersede any symbols created by the export section.
537 if (PopulateSymbolTable)
538 Symbols.clear();
539
540 while (Ctx.Ptr < Ctx.End) {
541 uint8_t Type = readUint8(Ctx);
542 uint32_t Size = readVaruint32(Ctx);
543 const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
544
545 switch (Type) {
546 case wasm::WASM_NAMES_FUNCTION:
547 case wasm::WASM_NAMES_GLOBAL:
548 case wasm::WASM_NAMES_DATA_SEGMENT: {
549 uint32_t Count = readVaruint32(Ctx);
550 while (Count--) {
551 uint32_t Index = readVaruint32(Ctx);
552 StringRef Name = readString(Ctx);
553 wasm::NameType nameType = wasm::NameType::FUNCTION;
554 wasm::WasmSymbolInfo Info{.Name: Name,
555 /*Kind */ wasm::WASM_SYMBOL_TYPE_FUNCTION,
556 /* Flags */ 0,
557 /* ImportModule */ std::nullopt,
558 /* ImportName */ std::nullopt,
559 /* ExportName */ std::nullopt,
560 {/* ElementIndex */ Index}};
561 const wasm::WasmSignature *Signature = nullptr;
562 const wasm::WasmGlobalType *GlobalType = nullptr;
563 const wasm::WasmTableType *TableType = nullptr;
564 if (Type == wasm::WASM_NAMES_FUNCTION) {
565 if (!SeenFunctions.insert(V: Index).second)
566 return make_error<GenericBinaryError>(
567 Args: "function named more than once", Args: object_error::parse_failed);
568 if (!isValidFunctionIndex(Index) || Name.empty())
569 return make_error<GenericBinaryError>(Args: "invalid function name entry",
570 Args: object_error::parse_failed);
571
572 if (isDefinedFunctionIndex(Index)) {
573 wasm::WasmFunction &F = getDefinedFunction(Index);
574 F.DebugName = Name;
575 Signature = &Signatures[F.SigIndex];
576 if (F.ExportName) {
577 Info.ExportName = F.ExportName;
578 Info.Flags |= wasm::WASM_SYMBOL_BINDING_GLOBAL;
579 } else {
580 Info.Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
581 }
582 } else {
583 Info.Flags |= wasm::WASM_SYMBOL_UNDEFINED;
584 }
585 } else if (Type == wasm::WASM_NAMES_GLOBAL) {
586 if (!SeenGlobals.insert(V: Index).second)
587 return make_error<GenericBinaryError>(Args: "global named more than once",
588 Args: object_error::parse_failed);
589 if (!isValidGlobalIndex(Index) || Name.empty())
590 return make_error<GenericBinaryError>(Args: "invalid global name entry",
591 Args: object_error::parse_failed);
592 nameType = wasm::NameType::GLOBAL;
593 Info.Kind = wasm::WASM_SYMBOL_TYPE_GLOBAL;
594 if (isDefinedGlobalIndex(Index)) {
595 GlobalType = &getDefinedGlobal(Index).Type;
596 } else {
597 Info.Flags |= wasm::WASM_SYMBOL_UNDEFINED;
598 }
599 } else {
600 if (!SeenSegments.insert(V: Index).second)
601 return make_error<GenericBinaryError>(
602 Args: "segment named more than once", Args: object_error::parse_failed);
603 if (Index >= DataSegments.size())
604 return make_error<GenericBinaryError>(Args: "invalid data segment name entry",
605 Args: object_error::parse_failed);
606 nameType = wasm::NameType::DATA_SEGMENT;
607 Info.Kind = wasm::WASM_SYMBOL_TYPE_DATA;
608 Info.Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
609 assert(Index < DataSegments.size());
610 Info.DataRef = wasm::WasmDataReference{
611 .Segment: Index, .Offset: 0, .Size: DataSegments[Index].Data.Content.size()};
612 }
613 DebugNames.push_back(x: wasm::WasmDebugName{.Type: nameType, .Index: Index, .Name: Name});
614 if (PopulateSymbolTable)
615 Symbols.emplace_back(args&: Info, args&: GlobalType, args&: TableType, args&: Signature);
616 }
617 break;
618 }
619 // Ignore local names for now
620 case wasm::WASM_NAMES_LOCAL:
621 default:
622 Ctx.Ptr += Size;
623 break;
624 }
625 if (Ctx.Ptr != SubSectionEnd)
626 return make_error<GenericBinaryError>(
627 Args: "name sub-section ended prematurely", Args: object_error::parse_failed);
628 }
629
630 if (Ctx.Ptr != Ctx.End)
631 return make_error<GenericBinaryError>(Args: "name section ended prematurely",
632 Args: object_error::parse_failed);
633 return Error::success();
634}
635
636Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
637 HasLinkingSection = true;
638
639 LinkingData.Version = readVaruint32(Ctx);
640 if (LinkingData.Version != wasm::WasmMetadataVersion) {
641 return make_error<GenericBinaryError>(
642 Args: "unexpected metadata version: " + Twine(LinkingData.Version) +
643 " (Expected: " + Twine(wasm::WasmMetadataVersion) + ")",
644 Args: object_error::parse_failed);
645 }
646
647 const uint8_t *OrigEnd = Ctx.End;
648 while (Ctx.Ptr < OrigEnd) {
649 Ctx.End = OrigEnd;
650 uint8_t Type = readUint8(Ctx);
651 uint32_t Size = readVaruint32(Ctx);
652 LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
653 << "\n");
654 Ctx.End = Ctx.Ptr + Size;
655 switch (Type) {
656 case wasm::WASM_SYMBOL_TABLE:
657 if (Error Err = parseLinkingSectionSymtab(Ctx))
658 return Err;
659 break;
660 case wasm::WASM_SEGMENT_INFO: {
661 uint32_t Count = readVaruint32(Ctx);
662 if (Count > DataSegments.size())
663 return make_error<GenericBinaryError>(Args: "too many segment names",
664 Args: object_error::parse_failed);
665 for (uint32_t I = 0; I < Count; I++) {
666 DataSegments[I].Data.Name = readString(Ctx);
667 DataSegments[I].Data.Alignment = readVaruint32(Ctx);
668 DataSegments[I].Data.LinkingFlags = readVaruint32(Ctx);
669 }
670 break;
671 }
672 case wasm::WASM_INIT_FUNCS: {
673 uint32_t Count = readVaruint32(Ctx);
674 LinkingData.InitFunctions.reserve(n: Count);
675 for (uint32_t I = 0; I < Count; I++) {
676 wasm::WasmInitFunc Init;
677 Init.Priority = readVaruint32(Ctx);
678 Init.Symbol = readVaruint32(Ctx);
679 if (!isValidFunctionSymbol(Index: Init.Symbol))
680 return make_error<GenericBinaryError>(Args: "invalid function symbol: " +
681 Twine(Init.Symbol),
682 Args: object_error::parse_failed);
683 LinkingData.InitFunctions.emplace_back(args&: Init);
684 }
685 break;
686 }
687 case wasm::WASM_COMDAT_INFO:
688 if (Error Err = parseLinkingSectionComdat(Ctx))
689 return Err;
690 break;
691 default:
692 Ctx.Ptr += Size;
693 break;
694 }
695 if (Ctx.Ptr != Ctx.End)
696 return make_error<GenericBinaryError>(
697 Args: "linking sub-section ended prematurely", Args: object_error::parse_failed);
698 }
699 if (Ctx.Ptr != OrigEnd)
700 return make_error<GenericBinaryError>(Args: "linking section ended prematurely",
701 Args: object_error::parse_failed);
702 return Error::success();
703}
704
705Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
706 uint32_t Count = readVaruint32(Ctx);
707 // Clear out any symbol information that was derived from the exports
708 // section.
709 Symbols.clear();
710 Symbols.reserve(n: Count);
711 StringSet<> SymbolNames;
712
713 std::vector<wasm::WasmImport *> ImportedGlobals;
714 std::vector<wasm::WasmImport *> ImportedFunctions;
715 std::vector<wasm::WasmImport *> ImportedTags;
716 std::vector<wasm::WasmImport *> ImportedTables;
717 ImportedGlobals.reserve(n: Imports.size());
718 ImportedFunctions.reserve(n: Imports.size());
719 ImportedTags.reserve(n: Imports.size());
720 ImportedTables.reserve(n: Imports.size());
721 for (auto &I : Imports) {
722 if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
723 ImportedFunctions.emplace_back(args: &I);
724 else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
725 ImportedGlobals.emplace_back(args: &I);
726 else if (I.Kind == wasm::WASM_EXTERNAL_TAG)
727 ImportedTags.emplace_back(args: &I);
728 else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
729 ImportedTables.emplace_back(args: &I);
730 }
731
732 while (Count--) {
733 wasm::WasmSymbolInfo Info;
734 const wasm::WasmSignature *Signature = nullptr;
735 const wasm::WasmGlobalType *GlobalType = nullptr;
736 const wasm::WasmTableType *TableType = nullptr;
737
738 Info.Kind = readUint8(Ctx);
739 Info.Flags = readVaruint32(Ctx);
740 bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
741
742 switch (Info.Kind) {
743 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
744 Info.ElementIndex = readVaruint32(Ctx);
745 if (!isValidFunctionIndex(Index: Info.ElementIndex) ||
746 IsDefined != isDefinedFunctionIndex(Index: Info.ElementIndex))
747 return make_error<GenericBinaryError>(Args: "invalid function symbol index",
748 Args: object_error::parse_failed);
749 if (IsDefined) {
750 Info.Name = readString(Ctx);
751 unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
752 wasm::WasmFunction &Function = Functions[FuncIndex];
753 Signature = &Signatures[Function.SigIndex];
754 if (Function.SymbolName.empty())
755 Function.SymbolName = Info.Name;
756 } else {
757 wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
758 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
759 Info.Name = readString(Ctx);
760 Info.ImportName = Import.Field;
761 } else {
762 Info.Name = Import.Field;
763 }
764 Signature = &Signatures[Import.SigIndex];
765 Info.ImportModule = Import.Module;
766 }
767 break;
768
769 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
770 Info.ElementIndex = readVaruint32(Ctx);
771 if (!isValidGlobalIndex(Index: Info.ElementIndex) ||
772 IsDefined != isDefinedGlobalIndex(Index: Info.ElementIndex))
773 return make_error<GenericBinaryError>(Args: "invalid global symbol index",
774 Args: object_error::parse_failed);
775 if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
776 wasm::WASM_SYMBOL_BINDING_WEAK)
777 return make_error<GenericBinaryError>(Args: "undefined weak global symbol",
778 Args: object_error::parse_failed);
779 if (IsDefined) {
780 Info.Name = readString(Ctx);
781 unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
782 wasm::WasmGlobal &Global = Globals[GlobalIndex];
783 GlobalType = &Global.Type;
784 if (Global.SymbolName.empty())
785 Global.SymbolName = Info.Name;
786 } else {
787 wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
788 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
789 Info.Name = readString(Ctx);
790 Info.ImportName = Import.Field;
791 } else {
792 Info.Name = Import.Field;
793 }
794 GlobalType = &Import.Global;
795 Info.ImportModule = Import.Module;
796 }
797 break;
798
799 case wasm::WASM_SYMBOL_TYPE_TABLE:
800 Info.ElementIndex = readVaruint32(Ctx);
801 if (!isValidTableNumber(Index: Info.ElementIndex) ||
802 IsDefined != isDefinedTableNumber(Index: Info.ElementIndex))
803 return make_error<GenericBinaryError>(Args: "invalid table symbol index",
804 Args: object_error::parse_failed);
805 if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
806 wasm::WASM_SYMBOL_BINDING_WEAK)
807 return make_error<GenericBinaryError>(Args: "undefined weak table symbol",
808 Args: object_error::parse_failed);
809 if (IsDefined) {
810 Info.Name = readString(Ctx);
811 unsigned TableNumber = Info.ElementIndex - NumImportedTables;
812 wasm::WasmTable &Table = Tables[TableNumber];
813 TableType = &Table.Type;
814 if (Table.SymbolName.empty())
815 Table.SymbolName = Info.Name;
816 } else {
817 wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
818 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
819 Info.Name = readString(Ctx);
820 Info.ImportName = Import.Field;
821 } else {
822 Info.Name = Import.Field;
823 }
824 TableType = &Import.Table;
825 Info.ImportModule = Import.Module;
826 }
827 break;
828
829 case wasm::WASM_SYMBOL_TYPE_DATA:
830 Info.Name = readString(Ctx);
831 if (IsDefined) {
832 auto Index = readVaruint32(Ctx);
833 auto Offset = readVaruint64(Ctx);
834 auto Size = readVaruint64(Ctx);
835 if (!(Info.Flags & wasm::WASM_SYMBOL_ABSOLUTE)) {
836 if (Index >= DataSegments.size())
837 return make_error<GenericBinaryError>(
838 Args: "invalid data segment index: " + Twine(Index),
839 Args: object_error::parse_failed);
840 size_t SegmentSize = DataSegments[Index].Data.Content.size();
841 if (Offset > SegmentSize)
842 return make_error<GenericBinaryError>(
843 Args: "invalid data symbol offset: `" + Info.Name +
844 "` (offset: " + Twine(Offset) +
845 " segment size: " + Twine(SegmentSize) + ")",
846 Args: object_error::parse_failed);
847 }
848 Info.DataRef = wasm::WasmDataReference{.Segment: Index, .Offset: Offset, .Size: Size};
849 }
850 break;
851
852 case wasm::WASM_SYMBOL_TYPE_SECTION: {
853 if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
854 wasm::WASM_SYMBOL_BINDING_LOCAL)
855 return make_error<GenericBinaryError>(
856 Args: "section symbols must have local binding",
857 Args: object_error::parse_failed);
858 Info.ElementIndex = readVaruint32(Ctx);
859 // Use somewhat unique section name as symbol name.
860 StringRef SectionName = Sections[Info.ElementIndex].Name;
861 Info.Name = SectionName;
862 break;
863 }
864
865 case wasm::WASM_SYMBOL_TYPE_TAG: {
866 Info.ElementIndex = readVaruint32(Ctx);
867 if (!isValidTagIndex(Index: Info.ElementIndex) ||
868 IsDefined != isDefinedTagIndex(Index: Info.ElementIndex))
869 return make_error<GenericBinaryError>(Args: "invalid tag symbol index",
870 Args: object_error::parse_failed);
871 if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
872 wasm::WASM_SYMBOL_BINDING_WEAK)
873 return make_error<GenericBinaryError>(Args: "undefined weak global symbol",
874 Args: object_error::parse_failed);
875 if (IsDefined) {
876 Info.Name = readString(Ctx);
877 unsigned TagIndex = Info.ElementIndex - NumImportedTags;
878 wasm::WasmTag &Tag = Tags[TagIndex];
879 Signature = &Signatures[Tag.SigIndex];
880 if (Tag.SymbolName.empty())
881 Tag.SymbolName = Info.Name;
882
883 } else {
884 wasm::WasmImport &Import = *ImportedTags[Info.ElementIndex];
885 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
886 Info.Name = readString(Ctx);
887 Info.ImportName = Import.Field;
888 } else {
889 Info.Name = Import.Field;
890 }
891 Signature = &Signatures[Import.SigIndex];
892 Info.ImportModule = Import.Module;
893 }
894 break;
895 }
896
897 default:
898 return make_error<GenericBinaryError>(Args: "invalid symbol type: " +
899 Twine(unsigned(Info.Kind)),
900 Args: object_error::parse_failed);
901 }
902
903 if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
904 wasm::WASM_SYMBOL_BINDING_LOCAL &&
905 !SymbolNames.insert(key: Info.Name).second)
906 return make_error<GenericBinaryError>(Args: "duplicate symbol name " +
907 Twine(Info.Name),
908 Args: object_error::parse_failed);
909 Symbols.emplace_back(args&: Info, args&: GlobalType, args&: TableType, args&: Signature);
910 LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
911 }
912
913 return Error::success();
914}
915
916Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
917 uint32_t ComdatCount = readVaruint32(Ctx);
918 StringSet<> ComdatSet;
919 for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
920 StringRef Name = readString(Ctx);
921 if (Name.empty() || !ComdatSet.insert(key: Name).second)
922 return make_error<GenericBinaryError>(Args: "bad/duplicate COMDAT name " +
923 Twine(Name),
924 Args: object_error::parse_failed);
925 LinkingData.Comdats.emplace_back(args&: Name);
926 uint32_t Flags = readVaruint32(Ctx);
927 if (Flags != 0)
928 return make_error<GenericBinaryError>(Args: "unsupported COMDAT flags",
929 Args: object_error::parse_failed);
930
931 uint32_t EntryCount = readVaruint32(Ctx);
932 while (EntryCount--) {
933 unsigned Kind = readVaruint32(Ctx);
934 unsigned Index = readVaruint32(Ctx);
935 switch (Kind) {
936 default:
937 return make_error<GenericBinaryError>(Args: "invalid COMDAT entry type",
938 Args: object_error::parse_failed);
939 case wasm::WASM_COMDAT_DATA:
940 if (Index >= DataSegments.size())
941 return make_error<GenericBinaryError>(
942 Args: "COMDAT data index out of range", Args: object_error::parse_failed);
943 if (DataSegments[Index].Data.Comdat != UINT32_MAX)
944 return make_error<GenericBinaryError>(Args: "data segment in two COMDATs",
945 Args: object_error::parse_failed);
946 DataSegments[Index].Data.Comdat = ComdatIndex;
947 break;
948 case wasm::WASM_COMDAT_FUNCTION:
949 if (!isDefinedFunctionIndex(Index))
950 return make_error<GenericBinaryError>(
951 Args: "COMDAT function index out of range", Args: object_error::parse_failed);
952 if (getDefinedFunction(Index).Comdat != UINT32_MAX)
953 return make_error<GenericBinaryError>(Args: "function in two COMDATs",
954 Args: object_error::parse_failed);
955 getDefinedFunction(Index).Comdat = ComdatIndex;
956 break;
957 case wasm::WASM_COMDAT_SECTION:
958 if (Index >= Sections.size())
959 return make_error<GenericBinaryError>(
960 Args: "COMDAT section index out of range", Args: object_error::parse_failed);
961 if (Sections[Index].Type != wasm::WASM_SEC_CUSTOM)
962 return make_error<GenericBinaryError>(
963 Args: "non-custom section in a COMDAT", Args: object_error::parse_failed);
964 Sections[Index].Comdat = ComdatIndex;
965 break;
966 }
967 }
968 }
969 return Error::success();
970}
971
972Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
973 llvm::SmallSet<StringRef, 3> FieldsSeen;
974 uint32_t Fields = readVaruint32(Ctx);
975 for (size_t I = 0; I < Fields; ++I) {
976 StringRef FieldName = readString(Ctx);
977 if (!FieldsSeen.insert(V: FieldName).second)
978 return make_error<GenericBinaryError>(
979 Args: "producers section does not have unique fields",
980 Args: object_error::parse_failed);
981 std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
982 if (FieldName == "language") {
983 ProducerVec = &ProducerInfo.Languages;
984 } else if (FieldName == "processed-by") {
985 ProducerVec = &ProducerInfo.Tools;
986 } else if (FieldName == "sdk") {
987 ProducerVec = &ProducerInfo.SDKs;
988 } else {
989 return make_error<GenericBinaryError>(
990 Args: "producers section field is not named one of language, processed-by, "
991 "or sdk",
992 Args: object_error::parse_failed);
993 }
994 uint32_t ValueCount = readVaruint32(Ctx);
995 llvm::SmallSet<StringRef, 8> ProducersSeen;
996 for (size_t J = 0; J < ValueCount; ++J) {
997 StringRef Name = readString(Ctx);
998 StringRef Version = readString(Ctx);
999 if (!ProducersSeen.insert(V: Name).second) {
1000 return make_error<GenericBinaryError>(
1001 Args: "producers section contains repeated producer",
1002 Args: object_error::parse_failed);
1003 }
1004 ProducerVec->emplace_back(args: std::string(Name), args: std::string(Version));
1005 }
1006 }
1007 if (Ctx.Ptr != Ctx.End)
1008 return make_error<GenericBinaryError>(Args: "producers section ended prematurely",
1009 Args: object_error::parse_failed);
1010 return Error::success();
1011}
1012
1013Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
1014 llvm::SmallSet<std::string, 8> FeaturesSeen;
1015 uint32_t FeatureCount = readVaruint32(Ctx);
1016 for (size_t I = 0; I < FeatureCount; ++I) {
1017 wasm::WasmFeatureEntry Feature;
1018 Feature.Prefix = readUint8(Ctx);
1019 switch (Feature.Prefix) {
1020 case wasm::WASM_FEATURE_PREFIX_USED:
1021 case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
1022 break;
1023 default:
1024 return make_error<GenericBinaryError>(Args: "unknown feature policy prefix",
1025 Args: object_error::parse_failed);
1026 }
1027 Feature.Name = std::string(readString(Ctx));
1028 if (!FeaturesSeen.insert(V: Feature.Name).second)
1029 return make_error<GenericBinaryError>(
1030 Args: "target features section contains repeated feature \"" +
1031 Feature.Name + "\"",
1032 Args: object_error::parse_failed);
1033 TargetFeatures.push_back(x: Feature);
1034 }
1035 if (Ctx.Ptr != Ctx.End)
1036 return make_error<GenericBinaryError>(
1037 Args: "target features section ended prematurely",
1038 Args: object_error::parse_failed);
1039 return Error::success();
1040}
1041
1042Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
1043 uint32_t SectionIndex = readVaruint32(Ctx);
1044 if (SectionIndex >= Sections.size())
1045 return make_error<GenericBinaryError>(Args: "invalid section index",
1046 Args: object_error::parse_failed);
1047 WasmSection &Section = Sections[SectionIndex];
1048 uint32_t RelocCount = readVaruint32(Ctx);
1049 uint32_t EndOffset = Section.Content.size();
1050 uint32_t PreviousOffset = 0;
1051 while (RelocCount--) {
1052 wasm::WasmRelocation Reloc = {};
1053 uint32_t type = readVaruint32(Ctx);
1054 Reloc.Type = type;
1055 Reloc.Offset = readVaruint32(Ctx);
1056 if (Reloc.Offset < PreviousOffset)
1057 return make_error<GenericBinaryError>(Args: "relocations not in offset order",
1058 Args: object_error::parse_failed);
1059
1060 auto badReloc = [&](StringRef msg) {
1061 return make_error<GenericBinaryError>(
1062 Args: msg + ": " + Twine(Symbols[Reloc.Index].Info.Name),
1063 Args: object_error::parse_failed);
1064 };
1065
1066 PreviousOffset = Reloc.Offset;
1067 Reloc.Index = readVaruint32(Ctx);
1068 switch (type) {
1069 case wasm::R_WASM_FUNCTION_INDEX_LEB:
1070 case wasm::R_WASM_FUNCTION_INDEX_I32:
1071 case wasm::R_WASM_TABLE_INDEX_SLEB:
1072 case wasm::R_WASM_TABLE_INDEX_SLEB64:
1073 case wasm::R_WASM_TABLE_INDEX_I32:
1074 case wasm::R_WASM_TABLE_INDEX_I64:
1075 case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
1076 case wasm::R_WASM_TABLE_INDEX_REL_SLEB64:
1077 if (!isValidFunctionSymbol(Index: Reloc.Index))
1078 return badReloc("invalid function relocation");
1079 break;
1080 case wasm::R_WASM_TABLE_NUMBER_LEB:
1081 if (!isValidTableSymbol(Index: Reloc.Index))
1082 return badReloc("invalid table relocation");
1083 break;
1084 case wasm::R_WASM_TYPE_INDEX_LEB:
1085 if (Reloc.Index >= Signatures.size())
1086 return badReloc("invalid relocation type index");
1087 break;
1088 case wasm::R_WASM_GLOBAL_INDEX_LEB:
1089 // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
1090 // symbols to refer to their GOT entries.
1091 if (!isValidGlobalSymbol(Index: Reloc.Index) &&
1092 !isValidDataSymbol(Index: Reloc.Index) &&
1093 !isValidFunctionSymbol(Index: Reloc.Index))
1094 return badReloc("invalid global relocation");
1095 break;
1096 case wasm::R_WASM_GLOBAL_INDEX_I32:
1097 if (!isValidGlobalSymbol(Index: Reloc.Index))
1098 return badReloc("invalid global relocation");
1099 break;
1100 case wasm::R_WASM_TAG_INDEX_LEB:
1101 if (!isValidTagSymbol(Index: Reloc.Index))
1102 return badReloc("invalid tag relocation");
1103 break;
1104 case wasm::R_WASM_MEMORY_ADDR_LEB:
1105 case wasm::R_WASM_MEMORY_ADDR_SLEB:
1106 case wasm::R_WASM_MEMORY_ADDR_I32:
1107 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
1108 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
1109 case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
1110 if (!isValidDataSymbol(Index: Reloc.Index))
1111 return badReloc("invalid data relocation");
1112 Reloc.Addend = readVarint32(Ctx);
1113 break;
1114 case wasm::R_WASM_MEMORY_ADDR_LEB64:
1115 case wasm::R_WASM_MEMORY_ADDR_SLEB64:
1116 case wasm::R_WASM_MEMORY_ADDR_I64:
1117 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
1118 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64:
1119 case wasm::R_WASM_MEMORY_ADDR_LOCREL_I64:
1120 if (!isValidDataSymbol(Index: Reloc.Index))
1121 return badReloc("invalid data relocation");
1122 Reloc.Addend = readVarint64(Ctx);
1123 break;
1124 case wasm::R_WASM_FUNCTION_OFFSET_I32:
1125 if (!isValidFunctionSymbol(Index: Reloc.Index))
1126 return badReloc("invalid function relocation");
1127 Reloc.Addend = readVarint32(Ctx);
1128 break;
1129 case wasm::R_WASM_FUNCTION_OFFSET_I64:
1130 if (!isValidFunctionSymbol(Index: Reloc.Index))
1131 return badReloc("invalid function relocation");
1132 Reloc.Addend = readVarint64(Ctx);
1133 break;
1134 case wasm::R_WASM_SECTION_OFFSET_I32:
1135 if (!isValidSectionSymbol(Index: Reloc.Index))
1136 return badReloc("invalid section relocation");
1137 Reloc.Addend = readVarint32(Ctx);
1138 break;
1139 default:
1140 return make_error<GenericBinaryError>(Args: "invalid relocation type: " +
1141 Twine(type),
1142 Args: object_error::parse_failed);
1143 }
1144
1145 // Relocations must fit inside the section, and must appear in order. They
1146 // also shouldn't overlap a function/element boundary, but we don't bother
1147 // to check that.
1148 uint64_t Size = 5;
1149 if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LEB64 ||
1150 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_SLEB64 ||
1151 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_REL_SLEB64)
1152 Size = 10;
1153 if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
1154 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
1155 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LOCREL_I32 ||
1156 Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
1157 Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
1158 Reloc.Type == wasm::R_WASM_FUNCTION_INDEX_I32 ||
1159 Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
1160 Size = 4;
1161 if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I64 ||
1162 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64 ||
1163 Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
1164 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LOCREL_I64)
1165 Size = 8;
1166 if (Reloc.Offset + Size > EndOffset)
1167 return make_error<GenericBinaryError>(Args: "invalid relocation offset",
1168 Args: object_error::parse_failed);
1169
1170 Section.Relocations.push_back(x: Reloc);
1171 }
1172 if (Ctx.Ptr != Ctx.End)
1173 return make_error<GenericBinaryError>(Args: "reloc section ended prematurely",
1174 Args: object_error::parse_failed);
1175 return Error::success();
1176}
1177
1178Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
1179 if (Sec.Name == "dylink") {
1180 if (Error Err = parseDylinkSection(Ctx))
1181 return Err;
1182 } else if (Sec.Name == "dylink.0") {
1183 if (Error Err = parseDylink0Section(Ctx))
1184 return Err;
1185 } else if (Sec.Name == "name") {
1186 if (Error Err = parseNameSection(Ctx))
1187 return Err;
1188 } else if (Sec.Name == "linking") {
1189 if (Error Err = parseLinkingSection(Ctx))
1190 return Err;
1191 } else if (Sec.Name == "producers") {
1192 if (Error Err = parseProducersSection(Ctx))
1193 return Err;
1194 } else if (Sec.Name == "target_features") {
1195 if (Error Err = parseTargetFeaturesSection(Ctx))
1196 return Err;
1197 } else if (Sec.Name.starts_with(Prefix: "reloc.")) {
1198 if (Error Err = parseRelocSection(Name: Sec.Name, Ctx))
1199 return Err;
1200 }
1201 return Error::success();
1202}
1203
1204Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
1205 auto parseFieldDef = [&]() {
1206 uint32_t TypeCode = readVaruint32((Ctx));
1207 /* Discard StorageType */ parseValType(Ctx, Code: TypeCode);
1208 /* Discard Mutability */ readVaruint32(Ctx);
1209 };
1210
1211 uint32_t Count = readVaruint32(Ctx);
1212 Signatures.reserve(n: Count);
1213 while (Count--) {
1214 wasm::WasmSignature Sig;
1215 uint8_t Form = readUint8(Ctx);
1216 if (Form == wasm::WASM_TYPE_REC) {
1217 // Rec groups expand the type index space (beyond what was declared at
1218 // the top of the section, and also consume one element in that space.
1219 uint32_t RecSize = readVaruint32(Ctx);
1220 if (RecSize == 0)
1221 return make_error<GenericBinaryError>(Args: "Rec group size cannot be 0",
1222 Args: object_error::parse_failed);
1223 Signatures.reserve(n: Signatures.size() + RecSize);
1224 Count += RecSize;
1225 Sig.Kind = wasm::WasmSignature::Placeholder;
1226 Signatures.push_back(x: std::move(Sig));
1227 HasUnmodeledTypes = true;
1228 continue;
1229 }
1230 if (Form != wasm::WASM_TYPE_FUNC) {
1231 // Currently LLVM only models function types, and not other composite
1232 // types. Here we parse the type declarations just enough to skip past
1233 // them in the binary.
1234 if (Form == wasm::WASM_TYPE_SUB || Form == wasm::WASM_TYPE_SUB_FINAL) {
1235 uint32_t Supers = readVaruint32(Ctx);
1236 if (Supers > 0) {
1237 if (Supers != 1)
1238 return make_error<GenericBinaryError>(
1239 Args: "Invalid number of supertypes", Args: object_error::parse_failed);
1240 /* Discard SuperIndex */ readVaruint32(Ctx);
1241 }
1242 Form = readVaruint32(Ctx);
1243 }
1244 if (Form == wasm::WASM_TYPE_STRUCT) {
1245 uint32_t FieldCount = readVaruint32(Ctx);
1246 while (FieldCount--) {
1247 parseFieldDef();
1248 }
1249 } else if (Form == wasm::WASM_TYPE_ARRAY) {
1250 parseFieldDef();
1251 } else {
1252 return make_error<GenericBinaryError>(Args: "bad form",
1253 Args: object_error::parse_failed);
1254 }
1255 Sig.Kind = wasm::WasmSignature::Placeholder;
1256 Signatures.push_back(x: std::move(Sig));
1257 HasUnmodeledTypes = true;
1258 continue;
1259 }
1260
1261 uint32_t ParamCount = readVaruint32(Ctx);
1262 Sig.Params.reserve(N: ParamCount);
1263 while (ParamCount--) {
1264 uint32_t ParamType = readUint8(Ctx);
1265 Sig.Params.push_back(Elt: parseValType(Ctx, Code: ParamType));
1266 }
1267 uint32_t ReturnCount = readVaruint32(Ctx);
1268 while (ReturnCount--) {
1269 uint32_t ReturnType = readUint8(Ctx);
1270 Sig.Returns.push_back(Elt: parseValType(Ctx, Code: ReturnType));
1271 }
1272
1273 Signatures.push_back(x: std::move(Sig));
1274 }
1275 if (Ctx.Ptr != Ctx.End)
1276 return make_error<GenericBinaryError>(Args: "type section ended prematurely",
1277 Args: object_error::parse_failed);
1278 return Error::success();
1279}
1280
1281Error WasmObjectFile::parseImport(ReadContext &Ctx, wasm::WasmImport &Im) {
1282 switch (Im.Kind) {
1283 case wasm::WASM_EXTERNAL_FUNCTION:
1284 NumImportedFunctions++;
1285 Im.SigIndex = readVaruint32(Ctx);
1286 if (Im.SigIndex >= Signatures.size())
1287 return make_error<GenericBinaryError>(Args: "invalid function type",
1288 Args: object_error::parse_failed);
1289 break;
1290 case wasm::WASM_EXTERNAL_GLOBAL:
1291 NumImportedGlobals++;
1292 Im.Global.Type = readUint8(Ctx);
1293 Im.Global.Mutable = readVaruint1(Ctx);
1294 break;
1295 case wasm::WASM_EXTERNAL_MEMORY:
1296 Im.Memory = readLimits(Ctx);
1297 if (Im.Memory.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1298 HasMemory64 = true;
1299 break;
1300 case wasm::WASM_EXTERNAL_TABLE: {
1301 Im.Table = readTableType(Ctx);
1302 NumImportedTables++;
1303 auto ElemType = Im.Table.ElemType;
1304 if (ElemType != wasm::ValType::FUNCREF &&
1305 ElemType != wasm::ValType::EXTERNREF &&
1306 ElemType != wasm::ValType::EXNREF &&
1307 ElemType != wasm::ValType::OTHERREF)
1308 return make_error<GenericBinaryError>(Args: "invalid table element type",
1309 Args: object_error::parse_failed);
1310 break;
1311 }
1312 case wasm::WASM_EXTERNAL_TAG:
1313 NumImportedTags++;
1314 if (readUint8(Ctx) != 0) // Reserved 'attribute' field
1315 return make_error<GenericBinaryError>(Args: "invalid attribute",
1316 Args: object_error::parse_failed);
1317 Im.SigIndex = readVaruint32(Ctx);
1318 if (Im.SigIndex >= Signatures.size())
1319 return make_error<GenericBinaryError>(Args: "invalid tag type",
1320 Args: object_error::parse_failed);
1321 break;
1322 default:
1323 return make_error<GenericBinaryError>(Args: "unexpected import kind: " +
1324 Twine(unsigned(Im.Kind)),
1325 Args: object_error::parse_failed);
1326 }
1327 Imports.push_back(x: Im);
1328 return Error::success();
1329}
1330
1331Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
1332 uint32_t Count = readVaruint32(Ctx);
1333 Imports.reserve(n: Count);
1334 uint32_t I = 0;
1335 while (I < Count) {
1336 wasm::WasmImport Im;
1337 Im.Module = readString(Ctx);
1338 Im.Field = readString(Ctx);
1339 Im.Kind = readUint8(Ctx);
1340 // 0x7E/0x7F along with an empty Field signals a block of compact imports.
1341 if (Im.Kind == 0x7E && Im.Field == "") {
1342 return make_error<GenericBinaryError>(
1343 Args: "compact import format (0x7E) is not yet supported",
1344 Args: object_error::parse_failed);
1345 } else if (Im.Kind == 0x7F && Im.Field == "") {
1346 uint32_t NumCompactImports = readVaruint32(Ctx);
1347 while (NumCompactImports--) {
1348 Im.Field = readString(Ctx);
1349 Im.Kind = readUint8(Ctx);
1350 Error rtn = parseImport(Ctx, Im);
1351 if (rtn)
1352 return rtn;
1353 I++;
1354 }
1355 } else {
1356 Error rtn = parseImport(Ctx, Im);
1357 if (rtn)
1358 return rtn;
1359 I++;
1360 }
1361 }
1362 if (Ctx.Ptr != Ctx.End)
1363 return make_error<GenericBinaryError>(Args: "import section ended prematurely",
1364 Args: object_error::parse_failed);
1365 return Error::success();
1366}
1367
1368Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
1369 uint32_t Count = readVaruint32(Ctx);
1370 Functions.reserve(n: Count);
1371 uint32_t NumTypes = Signatures.size();
1372 while (Count--) {
1373 uint32_t Type = readVaruint32(Ctx);
1374 if (Type >= NumTypes)
1375 return make_error<GenericBinaryError>(Args: "invalid function type",
1376 Args: object_error::parse_failed);
1377 wasm::WasmFunction F;
1378 F.SigIndex = Type;
1379 Functions.push_back(x: F);
1380 }
1381 if (Ctx.Ptr != Ctx.End)
1382 return make_error<GenericBinaryError>(Args: "function section ended prematurely",
1383 Args: object_error::parse_failed);
1384 return Error::success();
1385}
1386
1387Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
1388 TableSection = Sections.size();
1389 uint32_t Count = readVaruint32(Ctx);
1390 Tables.reserve(n: Count);
1391 while (Count--) {
1392 wasm::WasmTable T;
1393 T.Type = readTableType(Ctx);
1394 T.Index = NumImportedTables + Tables.size();
1395 Tables.push_back(x: T);
1396 auto ElemType = Tables.back().Type.ElemType;
1397 if (ElemType != wasm::ValType::FUNCREF &&
1398 ElemType != wasm::ValType::EXTERNREF &&
1399 ElemType != wasm::ValType::EXNREF &&
1400 ElemType != wasm::ValType::OTHERREF) {
1401 return make_error<GenericBinaryError>(Args: "invalid table element type",
1402 Args: object_error::parse_failed);
1403 }
1404 }
1405 if (Ctx.Ptr != Ctx.End)
1406 return make_error<GenericBinaryError>(Args: "table section ended prematurely",
1407 Args: object_error::parse_failed);
1408 return Error::success();
1409}
1410
1411Error WasmObjectFile::parseMemorySection(ReadContext &Ctx) {
1412 uint32_t Count = readVaruint32(Ctx);
1413 Memories.reserve(n: Count);
1414 while (Count--) {
1415 auto Limits = readLimits(Ctx);
1416 if (Limits.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1417 HasMemory64 = true;
1418 Memories.push_back(x: Limits);
1419 }
1420 if (Ctx.Ptr != Ctx.End)
1421 return make_error<GenericBinaryError>(Args: "memory section ended prematurely",
1422 Args: object_error::parse_failed);
1423 return Error::success();
1424}
1425
1426Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
1427 TagSection = Sections.size();
1428 uint32_t Count = readVaruint32(Ctx);
1429 Tags.reserve(n: Count);
1430 uint32_t NumTypes = Signatures.size();
1431 while (Count--) {
1432 if (readUint8(Ctx) != 0) // Reserved 'attribute' field
1433 return make_error<GenericBinaryError>(Args: "invalid attribute",
1434 Args: object_error::parse_failed);
1435 uint32_t Type = readVaruint32(Ctx);
1436 if (Type >= NumTypes)
1437 return make_error<GenericBinaryError>(Args: "invalid tag type",
1438 Args: object_error::parse_failed);
1439 wasm::WasmTag Tag;
1440 Tag.Index = NumImportedTags + Tags.size();
1441 Tag.SigIndex = Type;
1442 Signatures[Type].Kind = wasm::WasmSignature::Tag;
1443 Tags.push_back(x: Tag);
1444 }
1445
1446 if (Ctx.Ptr != Ctx.End)
1447 return make_error<GenericBinaryError>(Args: "tag section ended prematurely",
1448 Args: object_error::parse_failed);
1449 return Error::success();
1450}
1451
1452Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
1453 GlobalSection = Sections.size();
1454 const uint8_t *SectionStart = Ctx.Ptr;
1455 uint32_t Count = readVaruint32(Ctx);
1456 Globals.reserve(n: Count);
1457 while (Count--) {
1458 wasm::WasmGlobal Global;
1459 Global.Index = NumImportedGlobals + Globals.size();
1460 const uint8_t *GlobalStart = Ctx.Ptr;
1461 Global.Offset = static_cast<uint32_t>(GlobalStart - SectionStart);
1462 auto GlobalOpcode = readVaruint32(Ctx);
1463 Global.Type.Type = (uint8_t)parseValType(Ctx, Code: GlobalOpcode);
1464 Global.Type.Mutable = readVaruint1(Ctx);
1465 if (Error Err = readInitExpr(Expr&: Global.InitExpr, Ctx))
1466 return Err;
1467 Global.Size = static_cast<uint32_t>(Ctx.Ptr - GlobalStart);
1468 Globals.push_back(x: Global);
1469 }
1470 if (Ctx.Ptr != Ctx.End)
1471 return make_error<GenericBinaryError>(Args: "global section ended prematurely",
1472 Args: object_error::parse_failed);
1473 return Error::success();
1474}
1475
1476Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
1477 uint32_t Count = readVaruint32(Ctx);
1478 Exports.reserve(n: Count);
1479 Symbols.reserve(n: Count);
1480
1481 // Build hash map of export flags for faster cross-referencing
1482 llvm::DenseMap<StringRef, uint32_t> ExportFlags;
1483 if (HasDylinkSection) {
1484 for (const auto &ExportInfo : DylinkInfo.ExportInfo) {
1485 ExportFlags[ExportInfo.Name] = ExportInfo.Flags;
1486 }
1487 }
1488
1489 for (uint32_t I = 0; I < Count; I++) {
1490 wasm::WasmExport Ex;
1491 Ex.Name = readString(Ctx);
1492 Ex.Kind = readUint8(Ctx);
1493 Ex.Index = readVaruint32(Ctx);
1494 const wasm::WasmSignature *Signature = nullptr;
1495 const wasm::WasmGlobalType *GlobalType = nullptr;
1496 const wasm::WasmTableType *TableType = nullptr;
1497 wasm::WasmSymbolInfo Info;
1498 Info.Name = Ex.Name;
1499 Info.Flags = 0;
1500 // For shared objects, symbol flags may be specified in the dylink section
1501 // instead of the export section
1502 if (HasDylinkSection) {
1503 auto It = ExportFlags.find(Val: Ex.Name);
1504 if (It != ExportFlags.end()) {
1505 Info.Flags = It->second;
1506 }
1507 }
1508 switch (Ex.Kind) {
1509 case wasm::WASM_EXTERNAL_FUNCTION: {
1510 if (!isValidFunctionIndex(Index: Ex.Index))
1511 return make_error<GenericBinaryError>(Args: "invalid function export",
1512 Args: object_error::parse_failed);
1513 Info.Kind = wasm::WASM_SYMBOL_TYPE_FUNCTION;
1514 Info.ElementIndex = Ex.Index;
1515 if (isDefinedFunctionIndex(Index: Ex.Index)) {
1516 getDefinedFunction(Index: Ex.Index).ExportName = Ex.Name;
1517 unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
1518 wasm::WasmFunction &Function = Functions[FuncIndex];
1519 Signature = &Signatures[Function.SigIndex];
1520 }
1521 // Else the function is imported. LLVM object files don't use this
1522 // pattern and we still treat this as an undefined symbol, but we want to
1523 // parse it without crashing.
1524 break;
1525 }
1526 case wasm::WASM_EXTERNAL_GLOBAL: {
1527 if (!isValidGlobalIndex(Index: Ex.Index))
1528 return make_error<GenericBinaryError>(Args: "invalid global export",
1529 Args: object_error::parse_failed);
1530 Info.Kind = wasm::WASM_SYMBOL_TYPE_DATA;
1531 uint64_t Offset = 0;
1532 if (isDefinedGlobalIndex(Index: Ex.Index)) {
1533 auto Global = getDefinedGlobal(Index: Ex.Index);
1534 if (!Global.InitExpr.Extended) {
1535 auto Inst = Global.InitExpr.Inst;
1536 if (Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
1537 Offset = Inst.Value.Int32;
1538 } else if (Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
1539 Offset = Inst.Value.Int64;
1540 }
1541 }
1542 }
1543 Info.DataRef = wasm::WasmDataReference{.Segment: 0, .Offset: Offset, .Size: 0};
1544 break;
1545 }
1546 case wasm::WASM_EXTERNAL_TAG:
1547 if (!isValidTagIndex(Index: Ex.Index))
1548 return make_error<GenericBinaryError>(Args: "invalid tag export",
1549 Args: object_error::parse_failed);
1550 Info.Kind = wasm::WASM_SYMBOL_TYPE_TAG;
1551 Info.ElementIndex = Ex.Index;
1552 if (isDefinedTagIndex(Index: Ex.Index)) {
1553 unsigned TagIndex = Ex.Index - NumImportedTags;
1554 Signature = &Signatures[Tags[TagIndex].SigIndex];
1555 }
1556 break;
1557 case wasm::WASM_EXTERNAL_MEMORY:
1558 break;
1559 case wasm::WASM_EXTERNAL_TABLE:
1560 Info.Kind = wasm::WASM_SYMBOL_TYPE_TABLE;
1561 Info.ElementIndex = Ex.Index;
1562 break;
1563 default:
1564 return make_error<GenericBinaryError>(Args: "unexpected export kind",
1565 Args: object_error::parse_failed);
1566 }
1567 Exports.push_back(x: Ex);
1568 if (Ex.Kind != wasm::WASM_EXTERNAL_MEMORY) {
1569 Symbols.emplace_back(args&: Info, args&: GlobalType, args&: TableType, args&: Signature);
1570 LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
1571 }
1572 }
1573 if (Ctx.Ptr != Ctx.End)
1574 return make_error<GenericBinaryError>(Args: "export section ended prematurely",
1575 Args: object_error::parse_failed);
1576 return Error::success();
1577}
1578
1579bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
1580 return Index < NumImportedFunctions + Functions.size();
1581}
1582
1583bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
1584 return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
1585}
1586
1587bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
1588 return Index < NumImportedGlobals + Globals.size();
1589}
1590
1591bool WasmObjectFile::isValidTableNumber(uint32_t Index) const {
1592 return Index < NumImportedTables + Tables.size();
1593}
1594
1595bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
1596 return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
1597}
1598
1599bool WasmObjectFile::isDefinedTableNumber(uint32_t Index) const {
1600 return Index >= NumImportedTables && isValidTableNumber(Index);
1601}
1602
1603bool WasmObjectFile::isValidTagIndex(uint32_t Index) const {
1604 return Index < NumImportedTags + Tags.size();
1605}
1606
1607bool WasmObjectFile::isDefinedTagIndex(uint32_t Index) const {
1608 return Index >= NumImportedTags && isValidTagIndex(Index);
1609}
1610
1611bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
1612 return Index < Symbols.size() && Symbols[Index].isTypeFunction();
1613}
1614
1615bool WasmObjectFile::isValidTableSymbol(uint32_t Index) const {
1616 return Index < Symbols.size() && Symbols[Index].isTypeTable();
1617}
1618
1619bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
1620 return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
1621}
1622
1623bool WasmObjectFile::isValidTagSymbol(uint32_t Index) const {
1624 return Index < Symbols.size() && Symbols[Index].isTypeTag();
1625}
1626
1627bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
1628 return Index < Symbols.size() && Symbols[Index].isTypeData();
1629}
1630
1631bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
1632 return Index < Symbols.size() && Symbols[Index].isTypeSection();
1633}
1634
1635wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
1636 assert(isDefinedFunctionIndex(Index));
1637 return Functions[Index - NumImportedFunctions];
1638}
1639
1640const wasm::WasmFunction &
1641WasmObjectFile::getDefinedFunction(uint32_t Index) const {
1642 assert(isDefinedFunctionIndex(Index));
1643 return Functions[Index - NumImportedFunctions];
1644}
1645
1646const wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) const {
1647 assert(isDefinedGlobalIndex(Index));
1648 return Globals[Index - NumImportedGlobals];
1649}
1650
1651wasm::WasmTag &WasmObjectFile::getDefinedTag(uint32_t Index) {
1652 assert(isDefinedTagIndex(Index));
1653 return Tags[Index - NumImportedTags];
1654}
1655
1656Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
1657 StartFunction = readVaruint32(Ctx);
1658 if (!isValidFunctionIndex(Index: StartFunction))
1659 return make_error<GenericBinaryError>(Args: "invalid start function",
1660 Args: object_error::parse_failed);
1661 return Error::success();
1662}
1663
1664Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
1665 CodeSection = Sections.size();
1666 uint32_t FunctionCount = readVaruint32(Ctx);
1667 if (FunctionCount != Functions.size()) {
1668 return make_error<GenericBinaryError>(Args: "invalid function count",
1669 Args: object_error::parse_failed);
1670 }
1671
1672 for (uint32_t i = 0; i < FunctionCount; i++) {
1673 wasm::WasmFunction& Function = Functions[i];
1674 const uint8_t *FunctionStart = Ctx.Ptr;
1675 uint32_t Size = readVaruint32(Ctx);
1676 const uint8_t *FunctionEnd = Ctx.Ptr + Size;
1677
1678 Function.CodeOffset = Ctx.Ptr - FunctionStart;
1679 Function.Index = NumImportedFunctions + i;
1680 Function.CodeSectionOffset = FunctionStart - Ctx.Start;
1681 Function.Size = FunctionEnd - FunctionStart;
1682
1683 uint32_t NumLocalDecls = readVaruint32(Ctx);
1684 Function.Locals.reserve(n: NumLocalDecls);
1685 while (NumLocalDecls--) {
1686 wasm::WasmLocalDecl Decl;
1687 Decl.Count = readVaruint32(Ctx);
1688 Decl.Type = readUint8(Ctx);
1689 Function.Locals.push_back(x: Decl);
1690 }
1691
1692 uint32_t BodySize = FunctionEnd - Ctx.Ptr;
1693 // Ensure that Function is within Ctx's buffer.
1694 if (Ctx.Ptr + BodySize > Ctx.End) {
1695 return make_error<GenericBinaryError>(Args: "Function extends beyond buffer",
1696 Args: object_error::parse_failed);
1697 }
1698 Function.Body = ArrayRef<uint8_t>(Ctx.Ptr, BodySize);
1699 // This will be set later when reading in the linking metadata section.
1700 Function.Comdat = UINT32_MAX;
1701 Ctx.Ptr += BodySize;
1702 assert(Ctx.Ptr == FunctionEnd);
1703 }
1704 if (Ctx.Ptr != Ctx.End)
1705 return make_error<GenericBinaryError>(Args: "code section ended prematurely",
1706 Args: object_error::parse_failed);
1707 return Error::success();
1708}
1709
1710Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
1711 uint32_t Count = readVaruint32(Ctx);
1712 ElemSegments.reserve(n: Count);
1713 while (Count--) {
1714 wasm::WasmElemSegment Segment;
1715 Segment.Flags = readVaruint32(Ctx);
1716
1717 uint32_t SupportedFlags = wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER |
1718 wasm::WASM_ELEM_SEGMENT_IS_PASSIVE |
1719 wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS;
1720 if (Segment.Flags & ~SupportedFlags)
1721 return make_error<GenericBinaryError>(
1722 Args: "Unsupported flags for element segment", Args: object_error::parse_failed);
1723
1724 wasm::ElemSegmentMode Mode;
1725 if ((Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_PASSIVE) == 0) {
1726 Mode = wasm::ElemSegmentMode::Active;
1727 } else if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_DECLARATIVE) {
1728 Mode = wasm::ElemSegmentMode::Declarative;
1729 } else {
1730 Mode = wasm::ElemSegmentMode::Passive;
1731 }
1732 bool HasTableNumber =
1733 Mode == wasm::ElemSegmentMode::Active &&
1734 (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER);
1735 bool HasElemKind =
1736 (Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_DESC) &&
1737 !(Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS);
1738 bool HasElemType =
1739 (Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_DESC) &&
1740 (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS);
1741 bool HasInitExprs =
1742 (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS);
1743
1744 if (HasTableNumber)
1745 Segment.TableNumber = readVaruint32(Ctx);
1746 else
1747 Segment.TableNumber = 0;
1748
1749 if (!isValidTableNumber(Index: Segment.TableNumber))
1750 return make_error<GenericBinaryError>(Args: "invalid TableNumber",
1751 Args: object_error::parse_failed);
1752
1753 if (Mode != wasm::ElemSegmentMode::Active) {
1754 Segment.Offset.Extended = false;
1755 Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
1756 Segment.Offset.Inst.Value.Int32 = 0;
1757 } else {
1758 if (Error Err = readInitExpr(Expr&: Segment.Offset, Ctx))
1759 return Err;
1760 }
1761
1762 if (HasElemKind) {
1763 auto ElemKind = readVaruint32(Ctx);
1764 if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS) {
1765 Segment.ElemKind = parseValType(Ctx, Code: ElemKind);
1766 if (Segment.ElemKind != wasm::ValType::FUNCREF &&
1767 Segment.ElemKind != wasm::ValType::EXTERNREF &&
1768 Segment.ElemKind != wasm::ValType::EXNREF &&
1769 Segment.ElemKind != wasm::ValType::OTHERREF) {
1770 return make_error<GenericBinaryError>(Args: "invalid elem type",
1771 Args: object_error::parse_failed);
1772 }
1773 } else {
1774 if (ElemKind != 0)
1775 return make_error<GenericBinaryError>(Args: "invalid elem type",
1776 Args: object_error::parse_failed);
1777 Segment.ElemKind = wasm::ValType::FUNCREF;
1778 }
1779 } else if (HasElemType) {
1780 auto ElemType = parseValType(Ctx, Code: readVaruint32(Ctx));
1781 Segment.ElemKind = ElemType;
1782 } else {
1783 Segment.ElemKind = wasm::ValType::FUNCREF;
1784 }
1785
1786 uint32_t NumElems = readVaruint32(Ctx);
1787
1788 if (HasInitExprs) {
1789 while (NumElems--) {
1790 wasm::WasmInitExpr Expr;
1791 if (Error Err = readInitExpr(Expr, Ctx))
1792 return Err;
1793 }
1794 } else {
1795 while (NumElems--) {
1796 Segment.Functions.push_back(x: readVaruint32(Ctx));
1797 }
1798 }
1799 ElemSegments.push_back(x: Segment);
1800 }
1801 if (Ctx.Ptr != Ctx.End)
1802 return make_error<GenericBinaryError>(Args: "elem section ended prematurely",
1803 Args: object_error::parse_failed);
1804 return Error::success();
1805}
1806
1807Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
1808 DataSection = Sections.size();
1809 uint32_t Count = readVaruint32(Ctx);
1810 if (DataCount && Count != *DataCount)
1811 return make_error<GenericBinaryError>(
1812 Args: "number of data segments does not match DataCount section");
1813 DataSegments.reserve(n: Count);
1814 while (Count--) {
1815 WasmSegment Segment;
1816 Segment.Data.InitFlags = readVaruint32(Ctx);
1817 Segment.Data.MemoryIndex =
1818 (Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
1819 ? readVaruint32(Ctx)
1820 : 0;
1821 if ((Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
1822 if (Error Err = readInitExpr(Expr&: Segment.Data.Offset, Ctx))
1823 return Err;
1824 } else {
1825 Segment.Data.Offset.Extended = false;
1826 Segment.Data.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
1827 Segment.Data.Offset.Inst.Value.Int32 = 0;
1828 }
1829 uint32_t Size = readVaruint32(Ctx);
1830 if (Size > (size_t)(Ctx.End - Ctx.Ptr))
1831 return make_error<GenericBinaryError>(Args: "invalid segment size",
1832 Args: object_error::parse_failed);
1833 Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
1834 // The rest of these Data fields are set later, when reading in the linking
1835 // metadata section.
1836 Segment.Data.Alignment = 0;
1837 Segment.Data.LinkingFlags = 0;
1838 Segment.Data.Comdat = UINT32_MAX;
1839 Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
1840 Ctx.Ptr += Size;
1841 DataSegments.push_back(x: Segment);
1842 }
1843 if (Ctx.Ptr != Ctx.End)
1844 return make_error<GenericBinaryError>(Args: "data section ended prematurely",
1845 Args: object_error::parse_failed);
1846 return Error::success();
1847}
1848
1849Error WasmObjectFile::parseDataCountSection(ReadContext &Ctx) {
1850 DataCount = readVaruint32(Ctx);
1851 return Error::success();
1852}
1853
1854const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
1855 return Header;
1856}
1857
1858void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.b++; }
1859
1860Expected<uint32_t> WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
1861 uint32_t Result = SymbolRef::SF_None;
1862 const WasmSymbol &Sym = getWasmSymbol(Symb);
1863
1864 LLVM_DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
1865 if (Sym.isBindingWeak())
1866 Result |= SymbolRef::SF_Weak;
1867 if (!Sym.isBindingLocal())
1868 Result |= SymbolRef::SF_Global;
1869 if (Sym.isHidden())
1870 Result |= SymbolRef::SF_Hidden;
1871 if (!Sym.isDefined())
1872 Result |= SymbolRef::SF_Undefined;
1873 if (Sym.isTypeFunction())
1874 Result |= SymbolRef::SF_Executable;
1875 return Result;
1876}
1877
1878basic_symbol_iterator WasmObjectFile::symbol_begin() const {
1879 DataRefImpl Ref;
1880 Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1881 Ref.d.b = 0; // Symbol index
1882 return BasicSymbolRef(Ref, this);
1883}
1884
1885basic_symbol_iterator WasmObjectFile::symbol_end() const {
1886 DataRefImpl Ref;
1887 Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1888 Ref.d.b = Symbols.size(); // Symbol index
1889 return BasicSymbolRef(Ref, this);
1890}
1891
1892const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
1893 return Symbols[Symb.d.b];
1894}
1895
1896const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
1897 return getWasmSymbol(Symb: Symb.getRawDataRefImpl());
1898}
1899
1900Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
1901 return getWasmSymbol(Symb).Info.Name;
1902}
1903
1904Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
1905 auto &Sym = getWasmSymbol(Symb);
1906 if (!Sym.isDefined())
1907 return 0;
1908 Expected<section_iterator> Sec = getSymbolSection(Symb);
1909 if (!Sec)
1910 return Sec.takeError();
1911 uint32_t SectionAddress = getSectionAddress(Sec: Sec.get()->getRawDataRefImpl());
1912 if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION &&
1913 isDefinedFunctionIndex(Index: Sym.Info.ElementIndex)) {
1914 return getDefinedFunction(Index: Sym.Info.ElementIndex).CodeSectionOffset +
1915 SectionAddress;
1916 }
1917 if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL &&
1918 isDefinedGlobalIndex(Index: Sym.Info.ElementIndex)) {
1919 return getDefinedGlobal(Index: Sym.Info.ElementIndex).Offset + SectionAddress;
1920 }
1921
1922 return getSymbolValue(Symb);
1923}
1924
1925uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
1926 switch (Sym.Info.Kind) {
1927 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1928 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1929 case wasm::WASM_SYMBOL_TYPE_TAG:
1930 case wasm::WASM_SYMBOL_TYPE_TABLE:
1931 return Sym.Info.ElementIndex;
1932 case wasm::WASM_SYMBOL_TYPE_DATA: {
1933 // The value of a data symbol is the segment offset, plus the symbol
1934 // offset within the segment.
1935 uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
1936 const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
1937 if (Segment.Offset.Extended) {
1938 llvm_unreachable("extended init exprs not supported");
1939 } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
1940 return Segment.Offset.Inst.Value.Int32 + Sym.Info.DataRef.Offset;
1941 } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
1942 return Segment.Offset.Inst.Value.Int64 + Sym.Info.DataRef.Offset;
1943 } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_GLOBAL_GET) {
1944 return Sym.Info.DataRef.Offset;
1945 } else {
1946 llvm_unreachable("unknown init expr opcode");
1947 }
1948 }
1949 case wasm::WASM_SYMBOL_TYPE_SECTION:
1950 return 0;
1951 }
1952 llvm_unreachable("invalid symbol type");
1953}
1954
1955uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
1956 return getWasmSymbolValue(Sym: getWasmSymbol(Symb));
1957}
1958
1959uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
1960 llvm_unreachable("not yet implemented");
1961 return 0;
1962}
1963
1964uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
1965 llvm_unreachable("not yet implemented");
1966 return 0;
1967}
1968
1969Expected<SymbolRef::Type>
1970WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
1971 const WasmSymbol &Sym = getWasmSymbol(Symb);
1972
1973 switch (Sym.Info.Kind) {
1974 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1975 return SymbolRef::ST_Function;
1976 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1977 return SymbolRef::ST_Other;
1978 case wasm::WASM_SYMBOL_TYPE_DATA:
1979 return SymbolRef::ST_Data;
1980 case wasm::WASM_SYMBOL_TYPE_SECTION:
1981 return SymbolRef::ST_Debug;
1982 case wasm::WASM_SYMBOL_TYPE_TAG:
1983 return SymbolRef::ST_Other;
1984 case wasm::WASM_SYMBOL_TYPE_TABLE:
1985 return SymbolRef::ST_Other;
1986 }
1987
1988 llvm_unreachable("unknown WasmSymbol::SymbolType");
1989 return SymbolRef::ST_Other;
1990}
1991
1992Expected<section_iterator>
1993WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1994 const WasmSymbol &Sym = getWasmSymbol(Symb);
1995 if (Sym.isUndefined())
1996 return section_end();
1997
1998 DataRefImpl Ref;
1999 Ref.d.a = getSymbolSectionIdImpl(Symb: Sym);
2000 return section_iterator(SectionRef(Ref, this));
2001}
2002
2003uint32_t WasmObjectFile::getSymbolSectionId(SymbolRef Symb) const {
2004 const WasmSymbol &Sym = getWasmSymbol(Symb);
2005 return getSymbolSectionIdImpl(Symb: Sym);
2006}
2007
2008uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
2009 switch (Sym.Info.Kind) {
2010 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
2011 return CodeSection;
2012 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
2013 return GlobalSection;
2014 case wasm::WASM_SYMBOL_TYPE_DATA:
2015 return DataSection;
2016 case wasm::WASM_SYMBOL_TYPE_SECTION:
2017 return Sym.Info.ElementIndex;
2018 case wasm::WASM_SYMBOL_TYPE_TAG:
2019 return TagSection;
2020 case wasm::WASM_SYMBOL_TYPE_TABLE:
2021 return TableSection;
2022 default:
2023 llvm_unreachable("unknown WasmSymbol::SymbolType");
2024 }
2025}
2026
2027uint32_t WasmObjectFile::getSymbolSize(SymbolRef Symb) const {
2028 const WasmSymbol &Sym = getWasmSymbol(Symb);
2029 if (!Sym.isDefined())
2030 return 0;
2031 if (Sym.isTypeGlobal())
2032 return getDefinedGlobal(Index: Sym.Info.ElementIndex).Size;
2033 if (Sym.isTypeData())
2034 return Sym.Info.DataRef.Size;
2035 if (Sym.isTypeFunction())
2036 return functions()[Sym.Info.ElementIndex - getNumImportedFunctions()].Size;
2037 // Currently symbol size is only tracked for data segments and functions. In
2038 // principle we could also track size (e.g. binary size) for tables, globals
2039 // and element segments etc too.
2040 return 0;
2041}
2042
2043void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
2044
2045Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
2046 const WasmSection &S = Sections[Sec.d.a];
2047 if (S.Type == wasm::WASM_SEC_CUSTOM)
2048 return S.Name;
2049 if (S.Type > wasm::WASM_SEC_LAST_KNOWN)
2050 return createStringError(EC: object_error::invalid_section_index, S: "");
2051 return wasm::sectionTypeToString(type: S.Type);
2052}
2053
2054uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const {
2055 // For object files, use 0 for section addresses, and section offsets for
2056 // symbol addresses. For linked files, use file offsets.
2057 // See also getSymbolAddress.
2058 return isRelocatableObject() || isSharedObject() ? 0
2059 : Sections[Sec.d.a].Offset;
2060}
2061
2062uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
2063 return Sec.d.a;
2064}
2065
2066uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
2067 const WasmSection &S = Sections[Sec.d.a];
2068 return S.Content.size();
2069}
2070
2071Expected<ArrayRef<uint8_t>>
2072WasmObjectFile::getSectionContents(DataRefImpl Sec) const {
2073 const WasmSection &S = Sections[Sec.d.a];
2074 // This will never fail since wasm sections can never be empty (user-sections
2075 // must have a name and non-user sections each have a defined structure).
2076 return S.Content;
2077}
2078
2079uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
2080 return 1;
2081}
2082
2083bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
2084 return false;
2085}
2086
2087bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
2088 return getWasmSection(Ref: Sec).Type == wasm::WASM_SEC_CODE;
2089}
2090
2091bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
2092 return getWasmSection(Ref: Sec).Type == wasm::WASM_SEC_DATA;
2093}
2094
2095bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
2096
2097bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
2098
2099relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
2100 DataRefImpl RelocRef;
2101 RelocRef.d.a = Ref.d.a;
2102 RelocRef.d.b = 0;
2103 return relocation_iterator(RelocationRef(RelocRef, this));
2104}
2105
2106relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
2107 const WasmSection &Sec = getWasmSection(Ref);
2108 DataRefImpl RelocRef;
2109 RelocRef.d.a = Ref.d.a;
2110 RelocRef.d.b = Sec.Relocations.size();
2111 return relocation_iterator(RelocationRef(RelocRef, this));
2112}
2113
2114void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const { Rel.d.b++; }
2115
2116uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
2117 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2118 return Rel.Offset;
2119}
2120
2121symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
2122 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2123 if (Rel.Type == wasm::R_WASM_TYPE_INDEX_LEB)
2124 return symbol_end();
2125 DataRefImpl Sym;
2126 Sym.d.a = 1;
2127 Sym.d.b = Rel.Index;
2128 return symbol_iterator(SymbolRef(Sym, this));
2129}
2130
2131uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
2132 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2133 return Rel.Type;
2134}
2135
2136void WasmObjectFile::getRelocationTypeName(
2137 DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
2138 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
2139 StringRef Res = "Unknown";
2140
2141#define WASM_RELOC(name, value) \
2142 case wasm::name: \
2143 Res = #name; \
2144 break;
2145
2146 switch (Rel.Type) {
2147#include "llvm/BinaryFormat/WasmRelocs.def"
2148 }
2149
2150#undef WASM_RELOC
2151
2152 Result.append(in_start: Res.begin(), in_end: Res.end());
2153}
2154
2155section_iterator WasmObjectFile::section_begin() const {
2156 DataRefImpl Ref;
2157 Ref.d.a = 0;
2158 return section_iterator(SectionRef(Ref, this));
2159}
2160
2161section_iterator WasmObjectFile::section_end() const {
2162 DataRefImpl Ref;
2163 Ref.d.a = Sections.size();
2164 return section_iterator(SectionRef(Ref, this));
2165}
2166
2167uint8_t WasmObjectFile::getBytesInAddress() const {
2168 return HasMemory64 ? 8 : 4;
2169}
2170
2171StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
2172
2173Triple::ArchType WasmObjectFile::getArch() const {
2174 return HasMemory64 ? Triple::wasm64 : Triple::wasm32;
2175}
2176
2177Expected<SubtargetFeatures> WasmObjectFile::getFeatures() const {
2178 return SubtargetFeatures();
2179}
2180
2181bool WasmObjectFile::isRelocatableObject() const { return HasLinkingSection; }
2182
2183bool WasmObjectFile::isSharedObject() const { return HasDylinkSection; }
2184
2185const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
2186 assert(Ref.d.a < Sections.size());
2187 return Sections[Ref.d.a];
2188}
2189
2190const WasmSection &
2191WasmObjectFile::getWasmSection(const SectionRef &Section) const {
2192 return getWasmSection(Ref: Section.getRawDataRefImpl());
2193}
2194
2195const wasm::WasmRelocation &
2196WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
2197 return getWasmRelocation(Ref: Ref.getRawDataRefImpl());
2198}
2199
2200const wasm::WasmRelocation &
2201WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
2202 assert(Ref.d.a < Sections.size());
2203 const WasmSection &Sec = Sections[Ref.d.a];
2204 assert(Ref.d.b < Sec.Relocations.size());
2205 return Sec.Relocations[Ref.d.b];
2206}
2207
2208int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
2209 StringRef CustomSectionName) {
2210 switch (ID) {
2211 case wasm::WASM_SEC_CUSTOM:
2212 return StringSwitch<unsigned>(CustomSectionName)
2213 .Case(S: "dylink", Value: WASM_SEC_ORDER_DYLINK)
2214 .Case(S: "dylink.0", Value: WASM_SEC_ORDER_DYLINK)
2215 .Case(S: "linking", Value: WASM_SEC_ORDER_LINKING)
2216 .StartsWith(S: "reloc.", Value: WASM_SEC_ORDER_RELOC)
2217 .Case(S: "name", Value: WASM_SEC_ORDER_NAME)
2218 .Case(S: "producers", Value: WASM_SEC_ORDER_PRODUCERS)
2219 .Case(S: "target_features", Value: WASM_SEC_ORDER_TARGET_FEATURES)
2220 .Default(Value: WASM_SEC_ORDER_NONE);
2221 case wasm::WASM_SEC_TYPE:
2222 return WASM_SEC_ORDER_TYPE;
2223 case wasm::WASM_SEC_IMPORT:
2224 return WASM_SEC_ORDER_IMPORT;
2225 case wasm::WASM_SEC_FUNCTION:
2226 return WASM_SEC_ORDER_FUNCTION;
2227 case wasm::WASM_SEC_TABLE:
2228 return WASM_SEC_ORDER_TABLE;
2229 case wasm::WASM_SEC_MEMORY:
2230 return WASM_SEC_ORDER_MEMORY;
2231 case wasm::WASM_SEC_GLOBAL:
2232 return WASM_SEC_ORDER_GLOBAL;
2233 case wasm::WASM_SEC_EXPORT:
2234 return WASM_SEC_ORDER_EXPORT;
2235 case wasm::WASM_SEC_START:
2236 return WASM_SEC_ORDER_START;
2237 case wasm::WASM_SEC_ELEM:
2238 return WASM_SEC_ORDER_ELEM;
2239 case wasm::WASM_SEC_CODE:
2240 return WASM_SEC_ORDER_CODE;
2241 case wasm::WASM_SEC_DATA:
2242 return WASM_SEC_ORDER_DATA;
2243 case wasm::WASM_SEC_DATACOUNT:
2244 return WASM_SEC_ORDER_DATACOUNT;
2245 case wasm::WASM_SEC_TAG:
2246 return WASM_SEC_ORDER_TAG;
2247 default:
2248 return WASM_SEC_ORDER_NONE;
2249 }
2250}
2251
2252// Represents the edges in a directed graph where any node B reachable from node
2253// A is not allowed to appear before A in the section ordering, but may appear
2254// afterward.
2255int WasmSectionOrderChecker::DisallowedPredecessors
2256 [WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
2257 // WASM_SEC_ORDER_NONE
2258 {},
2259 // WASM_SEC_ORDER_TYPE
2260 {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT},
2261 // WASM_SEC_ORDER_IMPORT
2262 {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION},
2263 // WASM_SEC_ORDER_FUNCTION
2264 {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE},
2265 // WASM_SEC_ORDER_TABLE
2266 {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY},
2267 // WASM_SEC_ORDER_MEMORY
2268 {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_TAG},
2269 // WASM_SEC_ORDER_TAG
2270 {WASM_SEC_ORDER_TAG, WASM_SEC_ORDER_GLOBAL},
2271 // WASM_SEC_ORDER_GLOBAL
2272 {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EXPORT},
2273 // WASM_SEC_ORDER_EXPORT
2274 {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START},
2275 // WASM_SEC_ORDER_START
2276 {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM},
2277 // WASM_SEC_ORDER_ELEM
2278 {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT},
2279 // WASM_SEC_ORDER_DATACOUNT
2280 {WASM_SEC_ORDER_DATACOUNT, WASM_SEC_ORDER_CODE},
2281 // WASM_SEC_ORDER_CODE
2282 {WASM_SEC_ORDER_CODE, WASM_SEC_ORDER_DATA},
2283 // WASM_SEC_ORDER_DATA
2284 {WASM_SEC_ORDER_DATA, WASM_SEC_ORDER_LINKING},
2285
2286 // Custom Sections
2287 // WASM_SEC_ORDER_DYLINK
2288 {WASM_SEC_ORDER_DYLINK, WASM_SEC_ORDER_TYPE},
2289 // WASM_SEC_ORDER_LINKING
2290 {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC, WASM_SEC_ORDER_NAME},
2291 // WASM_SEC_ORDER_RELOC (can be repeated)
2292 {},
2293 // WASM_SEC_ORDER_NAME
2294 {WASM_SEC_ORDER_NAME, WASM_SEC_ORDER_PRODUCERS},
2295 // WASM_SEC_ORDER_PRODUCERS
2296 {WASM_SEC_ORDER_PRODUCERS, WASM_SEC_ORDER_TARGET_FEATURES},
2297 // WASM_SEC_ORDER_TARGET_FEATURES
2298 {WASM_SEC_ORDER_TARGET_FEATURES}};
2299
2300bool WasmSectionOrderChecker::isValidSectionOrder(unsigned ID,
2301 StringRef CustomSectionName) {
2302 int Order = getSectionOrder(ID, CustomSectionName);
2303 if (Order == WASM_SEC_ORDER_NONE)
2304 return true;
2305
2306 // Disallowed predecessors we need to check for
2307 SmallVector<int, WASM_NUM_SEC_ORDERS> WorkList;
2308
2309 // Keep track of completed checks to avoid repeating work
2310 bool Checked[WASM_NUM_SEC_ORDERS] = {};
2311
2312 int Curr = Order;
2313 while (true) {
2314 // Add new disallowed predecessors to work list
2315 for (size_t I = 0;; ++I) {
2316 int Next = DisallowedPredecessors[Curr][I];
2317 if (Next == WASM_SEC_ORDER_NONE)
2318 break;
2319 if (Checked[Next])
2320 continue;
2321 WorkList.push_back(Elt: Next);
2322 Checked[Next] = true;
2323 }
2324
2325 if (WorkList.empty())
2326 break;
2327
2328 // Consider next disallowed predecessor
2329 Curr = WorkList.pop_back_val();
2330 if (Seen[Curr])
2331 return false;
2332 }
2333
2334 // Have not seen any disallowed predecessors
2335 Seen[Order] = true;
2336 return true;
2337}
2338