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