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/STLExtras.h"
12 #include "llvm/ADT/SmallSet.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/StringSet.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/ADT/Triple.h"
17 #include "llvm/BinaryFormat/Wasm.h"
18 #include "llvm/MC/SubtargetFeature.h"
19 #include "llvm/Object/Binary.h"
20 #include "llvm/Object/Error.h"
21 #include "llvm/Object/ObjectFile.h"
22 #include "llvm/Object/SymbolicFile.h"
23 #include "llvm/Object/Wasm.h"
24 #include "llvm/Support/Endian.h"
25 #include "llvm/Support/Error.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/LEB128.h"
28 #include "llvm/Support/ScopedPrinter.h"
29 #include <algorithm>
30 #include <cassert>
31 #include <cstdint>
32 #include <cstring>
33 #include <system_error>
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   if (!isTypeData()) {
45     Out << ", ElemIndex=" << Info.ElementIndex;
46   } else if (isDefined()) {
47     Out << ", Segment=" << Info.DataRef.Segment;
48     Out << ", Offset=" << Info.DataRef.Offset;
49     Out << ", Size=" << Info.DataRef.Size;
50   }
51 }
52 
53 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
dump() const54 LLVM_DUMP_METHOD void WasmSymbol::dump() const { print(dbgs()); }
55 #endif
56 
57 Expected<std::unique_ptr<WasmObjectFile>>
createWasmObjectFile(MemoryBufferRef Buffer)58 ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
59   Error Err = Error::success();
60   auto ObjectFile = std::make_unique<WasmObjectFile>(Buffer, Err);
61   if (Err)
62     return std::move(Err);
63 
64   return std::move(ObjectFile);
65 }
66 
67 #define VARINT7_MAX ((1 << 7) - 1)
68 #define VARINT7_MIN (-(1 << 7))
69 #define VARUINT7_MAX (1 << 7)
70 #define VARUINT1_MAX (1)
71 
readUint8(WasmObjectFile::ReadContext & Ctx)72 static uint8_t readUint8(WasmObjectFile::ReadContext &Ctx) {
73   if (Ctx.Ptr == Ctx.End)
74     report_fatal_error("EOF while reading uint8");
75   return *Ctx.Ptr++;
76 }
77 
readUint32(WasmObjectFile::ReadContext & Ctx)78 static uint32_t readUint32(WasmObjectFile::ReadContext &Ctx) {
79   if (Ctx.Ptr + 4 > Ctx.End)
80     report_fatal_error("EOF while reading uint32");
81   uint32_t Result = support::endian::read32le(Ctx.Ptr);
82   Ctx.Ptr += 4;
83   return Result;
84 }
85 
readFloat32(WasmObjectFile::ReadContext & Ctx)86 static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
87   if (Ctx.Ptr + 4 > Ctx.End)
88     report_fatal_error("EOF while reading float64");
89   int32_t Result = 0;
90   memcpy(&Result, Ctx.Ptr, sizeof(Result));
91   Ctx.Ptr += sizeof(Result);
92   return Result;
93 }
94 
readFloat64(WasmObjectFile::ReadContext & Ctx)95 static int64_t readFloat64(WasmObjectFile::ReadContext &Ctx) {
96   if (Ctx.Ptr + 8 > Ctx.End)
97     report_fatal_error("EOF while reading float64");
98   int64_t Result = 0;
99   memcpy(&Result, Ctx.Ptr, sizeof(Result));
100   Ctx.Ptr += sizeof(Result);
101   return Result;
102 }
103 
readULEB128(WasmObjectFile::ReadContext & Ctx)104 static uint64_t readULEB128(WasmObjectFile::ReadContext &Ctx) {
105   unsigned Count;
106   const char *Error = nullptr;
107   uint64_t Result = decodeULEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
108   if (Error)
109     report_fatal_error(Error);
110   Ctx.Ptr += Count;
111   return Result;
112 }
113 
readString(WasmObjectFile::ReadContext & Ctx)114 static StringRef readString(WasmObjectFile::ReadContext &Ctx) {
115   uint32_t StringLen = readULEB128(Ctx);
116   if (Ctx.Ptr + StringLen > Ctx.End)
117     report_fatal_error("EOF while reading string");
118   StringRef Return =
119       StringRef(reinterpret_cast<const char *>(Ctx.Ptr), StringLen);
120   Ctx.Ptr += StringLen;
121   return Return;
122 }
123 
readLEB128(WasmObjectFile::ReadContext & Ctx)124 static int64_t readLEB128(WasmObjectFile::ReadContext &Ctx) {
125   unsigned Count;
126   const char *Error = nullptr;
127   uint64_t Result = decodeSLEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
128   if (Error)
129     report_fatal_error(Error);
130   Ctx.Ptr += Count;
131   return Result;
132 }
133 
readVaruint1(WasmObjectFile::ReadContext & Ctx)134 static uint8_t readVaruint1(WasmObjectFile::ReadContext &Ctx) {
135   int64_t Result = readLEB128(Ctx);
136   if (Result > VARUINT1_MAX || Result < 0)
137     report_fatal_error("LEB is outside Varuint1 range");
138   return Result;
139 }
140 
readVarint32(WasmObjectFile::ReadContext & Ctx)141 static int32_t readVarint32(WasmObjectFile::ReadContext &Ctx) {
142   int64_t Result = readLEB128(Ctx);
143   if (Result > INT32_MAX || Result < INT32_MIN)
144     report_fatal_error("LEB is outside Varint32 range");
145   return Result;
146 }
147 
readVaruint32(WasmObjectFile::ReadContext & Ctx)148 static uint32_t readVaruint32(WasmObjectFile::ReadContext &Ctx) {
149   uint64_t Result = readULEB128(Ctx);
150   if (Result > UINT32_MAX)
151     report_fatal_error("LEB is outside Varuint32 range");
152   return Result;
153 }
154 
readVarint64(WasmObjectFile::ReadContext & Ctx)155 static int64_t readVarint64(WasmObjectFile::ReadContext &Ctx) {
156   return readLEB128(Ctx);
157 }
158 
readVaruint64(WasmObjectFile::ReadContext & Ctx)159 static uint64_t readVaruint64(WasmObjectFile::ReadContext &Ctx) {
160   return readULEB128(Ctx);
161 }
162 
readOpcode(WasmObjectFile::ReadContext & Ctx)163 static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
164   return readUint8(Ctx);
165 }
166 
readInitExpr(wasm::WasmInitExpr & Expr,WasmObjectFile::ReadContext & Ctx)167 static Error readInitExpr(wasm::WasmInitExpr &Expr,
168                           WasmObjectFile::ReadContext &Ctx) {
169   Expr.Opcode = readOpcode(Ctx);
170 
171   switch (Expr.Opcode) {
172   case wasm::WASM_OPCODE_I32_CONST:
173     Expr.Value.Int32 = readVarint32(Ctx);
174     break;
175   case wasm::WASM_OPCODE_I64_CONST:
176     Expr.Value.Int64 = readVarint64(Ctx);
177     break;
178   case wasm::WASM_OPCODE_F32_CONST:
179     Expr.Value.Float32 = readFloat32(Ctx);
180     break;
181   case wasm::WASM_OPCODE_F64_CONST:
182     Expr.Value.Float64 = readFloat64(Ctx);
183     break;
184   case wasm::WASM_OPCODE_GLOBAL_GET:
185     Expr.Value.Global = readULEB128(Ctx);
186     break;
187   case wasm::WASM_OPCODE_REF_NULL: {
188     wasm::ValType Ty = static_cast<wasm::ValType>(readULEB128(Ctx));
189     if (Ty != wasm::ValType::EXTERNREF) {
190       return make_error<GenericBinaryError>("invalid type for ref.null",
191                                             object_error::parse_failed);
192     }
193     break;
194   }
195   default:
196     return make_error<GenericBinaryError>("invalid opcode in init_expr",
197                                           object_error::parse_failed);
198   }
199 
200   uint8_t EndOpcode = readOpcode(Ctx);
201   if (EndOpcode != wasm::WASM_OPCODE_END) {
202     return make_error<GenericBinaryError>("invalid init_expr",
203                                           object_error::parse_failed);
204   }
205   return Error::success();
206 }
207 
readLimits(WasmObjectFile::ReadContext & Ctx)208 static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
209   wasm::WasmLimits Result;
210   Result.Flags = readVaruint32(Ctx);
211   Result.Minimum = readVaruint64(Ctx);
212   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
213     Result.Maximum = readVaruint64(Ctx);
214   return Result;
215 }
216 
readTableType(WasmObjectFile::ReadContext & Ctx)217 static wasm::WasmTableType readTableType(WasmObjectFile::ReadContext &Ctx) {
218   wasm::WasmTableType TableType;
219   TableType.ElemType = readUint8(Ctx);
220   TableType.Limits = readLimits(Ctx);
221   return TableType;
222 }
223 
readSection(WasmSection & Section,WasmObjectFile::ReadContext & Ctx,WasmSectionOrderChecker & Checker)224 static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
225                          WasmSectionOrderChecker &Checker) {
226   Section.Offset = Ctx.Ptr - Ctx.Start;
227   Section.Type = readUint8(Ctx);
228   LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n");
229   uint32_t Size = readVaruint32(Ctx);
230   if (Size == 0)
231     return make_error<StringError>("zero length section",
232                                    object_error::parse_failed);
233   if (Ctx.Ptr + Size > Ctx.End)
234     return make_error<StringError>("section too large",
235                                    object_error::parse_failed);
236   if (Section.Type == wasm::WASM_SEC_CUSTOM) {
237     WasmObjectFile::ReadContext SectionCtx;
238     SectionCtx.Start = Ctx.Ptr;
239     SectionCtx.Ptr = Ctx.Ptr;
240     SectionCtx.End = Ctx.Ptr + Size;
241 
242     Section.Name = readString(SectionCtx);
243 
244     uint32_t SectionNameSize = SectionCtx.Ptr - SectionCtx.Start;
245     Ctx.Ptr += SectionNameSize;
246     Size -= SectionNameSize;
247   }
248 
249   if (!Checker.isValidSectionOrder(Section.Type, Section.Name)) {
250     return make_error<StringError>("out of order section type: " +
251                                        llvm::to_string(Section.Type),
252                                    object_error::parse_failed);
253   }
254 
255   Section.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
256   Ctx.Ptr += Size;
257   return Error::success();
258 }
259 
WasmObjectFile(MemoryBufferRef Buffer,Error & Err)260 WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
261     : ObjectFile(Binary::ID_Wasm, Buffer) {
262   ErrorAsOutParameter ErrAsOutParam(&Err);
263   Header.Magic = getData().substr(0, 4);
264   if (Header.Magic != StringRef("\0asm", 4)) {
265     Err = make_error<StringError>("invalid magic number",
266                                   object_error::parse_failed);
267     return;
268   }
269 
270   ReadContext Ctx;
271   Ctx.Start = getData().bytes_begin();
272   Ctx.Ptr = Ctx.Start + 4;
273   Ctx.End = Ctx.Start + getData().size();
274 
275   if (Ctx.Ptr + 4 > Ctx.End) {
276     Err = make_error<StringError>("missing version number",
277                                   object_error::parse_failed);
278     return;
279   }
280 
281   Header.Version = readUint32(Ctx);
282   if (Header.Version != wasm::WasmVersion) {
283     Err = make_error<StringError>("invalid version number: " +
284                                       Twine(Header.Version),
285                                   object_error::parse_failed);
286     return;
287   }
288 
289   WasmSection Sec;
290   WasmSectionOrderChecker Checker;
291   while (Ctx.Ptr < Ctx.End) {
292     if ((Err = readSection(Sec, Ctx, Checker)))
293       return;
294     if ((Err = parseSection(Sec)))
295       return;
296 
297     Sections.push_back(Sec);
298   }
299 }
300 
parseSection(WasmSection & Sec)301 Error WasmObjectFile::parseSection(WasmSection &Sec) {
302   ReadContext Ctx;
303   Ctx.Start = Sec.Content.data();
304   Ctx.End = Ctx.Start + Sec.Content.size();
305   Ctx.Ptr = Ctx.Start;
306   switch (Sec.Type) {
307   case wasm::WASM_SEC_CUSTOM:
308     return parseCustomSection(Sec, Ctx);
309   case wasm::WASM_SEC_TYPE:
310     return parseTypeSection(Ctx);
311   case wasm::WASM_SEC_IMPORT:
312     return parseImportSection(Ctx);
313   case wasm::WASM_SEC_FUNCTION:
314     return parseFunctionSection(Ctx);
315   case wasm::WASM_SEC_TABLE:
316     return parseTableSection(Ctx);
317   case wasm::WASM_SEC_MEMORY:
318     return parseMemorySection(Ctx);
319   case wasm::WASM_SEC_TAG:
320     return parseTagSection(Ctx);
321   case wasm::WASM_SEC_GLOBAL:
322     return parseGlobalSection(Ctx);
323   case wasm::WASM_SEC_EXPORT:
324     return parseExportSection(Ctx);
325   case wasm::WASM_SEC_START:
326     return parseStartSection(Ctx);
327   case wasm::WASM_SEC_ELEM:
328     return parseElemSection(Ctx);
329   case wasm::WASM_SEC_CODE:
330     return parseCodeSection(Ctx);
331   case wasm::WASM_SEC_DATA:
332     return parseDataSection(Ctx);
333   case wasm::WASM_SEC_DATACOUNT:
334     return parseDataCountSection(Ctx);
335   default:
336     return make_error<GenericBinaryError>(
337         "invalid section type: " + Twine(Sec.Type), object_error::parse_failed);
338   }
339 }
340 
parseDylinkSection(ReadContext & Ctx)341 Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
342   // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
343   HasDylinkSection = true;
344   DylinkInfo.MemorySize = readVaruint32(Ctx);
345   DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
346   DylinkInfo.TableSize = readVaruint32(Ctx);
347   DylinkInfo.TableAlignment = readVaruint32(Ctx);
348   uint32_t Count = readVaruint32(Ctx);
349   while (Count--) {
350     DylinkInfo.Needed.push_back(readString(Ctx));
351   }
352   if (Ctx.Ptr != Ctx.End)
353     return make_error<GenericBinaryError>("dylink section ended prematurely",
354                                           object_error::parse_failed);
355   return Error::success();
356 }
357 
parseNameSection(ReadContext & Ctx)358 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
359   llvm::DenseSet<uint64_t> SeenFunctions;
360   llvm::DenseSet<uint64_t> SeenGlobals;
361   llvm::DenseSet<uint64_t> SeenSegments;
362   if (FunctionTypes.size() && !SeenCodeSection) {
363     return make_error<GenericBinaryError>("names must come after code section",
364                                           object_error::parse_failed);
365   }
366 
367   while (Ctx.Ptr < Ctx.End) {
368     uint8_t Type = readUint8(Ctx);
369     uint32_t Size = readVaruint32(Ctx);
370     const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
371     switch (Type) {
372     case wasm::WASM_NAMES_FUNCTION:
373     case wasm::WASM_NAMES_GLOBAL:
374     case wasm::WASM_NAMES_DATA_SEGMENT: {
375       uint32_t Count = readVaruint32(Ctx);
376       while (Count--) {
377         uint32_t Index = readVaruint32(Ctx);
378         StringRef Name = readString(Ctx);
379         wasm::NameType nameType = wasm::NameType::FUNCTION;
380         if (Type == wasm::WASM_NAMES_FUNCTION) {
381           if (!SeenFunctions.insert(Index).second)
382             return make_error<GenericBinaryError>(
383                 "function named more than once", object_error::parse_failed);
384           if (!isValidFunctionIndex(Index) || Name.empty())
385             return make_error<GenericBinaryError>("invalid name entry",
386                                                   object_error::parse_failed);
387 
388           if (isDefinedFunctionIndex(Index))
389             getDefinedFunction(Index).DebugName = Name;
390         } else if (Type == wasm::WASM_NAMES_GLOBAL) {
391           nameType = wasm::NameType::GLOBAL;
392           if (!SeenGlobals.insert(Index).second)
393             return make_error<GenericBinaryError>("global named more than once",
394                                                   object_error::parse_failed);
395           if (!isValidGlobalIndex(Index) || Name.empty())
396             return make_error<GenericBinaryError>("invalid name entry",
397                                                   object_error::parse_failed);
398         } else {
399           nameType = wasm::NameType::DATA_SEGMENT;
400           if (!SeenSegments.insert(Index).second)
401             return make_error<GenericBinaryError>(
402                 "segment named more than once", object_error::parse_failed);
403           if (Index > DataSegments.size())
404             return make_error<GenericBinaryError>("invalid named data segment",
405                                                   object_error::parse_failed);
406         }
407         DebugNames.push_back(wasm::WasmDebugName{nameType, Index, Name});
408       }
409       break;
410     }
411     // Ignore local names for now
412     case wasm::WASM_NAMES_LOCAL:
413     default:
414       Ctx.Ptr += Size;
415       break;
416     }
417     if (Ctx.Ptr != SubSectionEnd)
418       return make_error<GenericBinaryError>(
419           "name sub-section ended prematurely", object_error::parse_failed);
420   }
421 
422   if (Ctx.Ptr != Ctx.End)
423     return make_error<GenericBinaryError>("name section ended prematurely",
424                                           object_error::parse_failed);
425   return Error::success();
426 }
427 
parseLinkingSection(ReadContext & Ctx)428 Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
429   HasLinkingSection = true;
430   if (FunctionTypes.size() && !SeenCodeSection) {
431     return make_error<GenericBinaryError>(
432         "linking data must come after code section",
433         object_error::parse_failed);
434   }
435 
436   LinkingData.Version = readVaruint32(Ctx);
437   if (LinkingData.Version != wasm::WasmMetadataVersion) {
438     return make_error<GenericBinaryError>(
439         "unexpected metadata version: " + Twine(LinkingData.Version) +
440             " (Expected: " + Twine(wasm::WasmMetadataVersion) + ")",
441         object_error::parse_failed);
442   }
443 
444   const uint8_t *OrigEnd = Ctx.End;
445   while (Ctx.Ptr < OrigEnd) {
446     Ctx.End = OrigEnd;
447     uint8_t Type = readUint8(Ctx);
448     uint32_t Size = readVaruint32(Ctx);
449     LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Size
450                       << "\n");
451     Ctx.End = Ctx.Ptr + Size;
452     switch (Type) {
453     case wasm::WASM_SYMBOL_TABLE:
454       if (Error Err = parseLinkingSectionSymtab(Ctx))
455         return Err;
456       break;
457     case wasm::WASM_SEGMENT_INFO: {
458       uint32_t Count = readVaruint32(Ctx);
459       if (Count > DataSegments.size())
460         return make_error<GenericBinaryError>("too many segment names",
461                                               object_error::parse_failed);
462       for (uint32_t I = 0; I < Count; I++) {
463         DataSegments[I].Data.Name = readString(Ctx);
464         DataSegments[I].Data.Alignment = readVaruint32(Ctx);
465         DataSegments[I].Data.LinkingFlags = readVaruint32(Ctx);
466       }
467       break;
468     }
469     case wasm::WASM_INIT_FUNCS: {
470       uint32_t Count = readVaruint32(Ctx);
471       LinkingData.InitFunctions.reserve(Count);
472       for (uint32_t I = 0; I < Count; I++) {
473         wasm::WasmInitFunc Init;
474         Init.Priority = readVaruint32(Ctx);
475         Init.Symbol = readVaruint32(Ctx);
476         if (!isValidFunctionSymbol(Init.Symbol))
477           return make_error<GenericBinaryError>("invalid function symbol: " +
478                                                     Twine(Init.Symbol),
479                                                 object_error::parse_failed);
480         LinkingData.InitFunctions.emplace_back(Init);
481       }
482       break;
483     }
484     case wasm::WASM_COMDAT_INFO:
485       if (Error Err = parseLinkingSectionComdat(Ctx))
486         return Err;
487       break;
488     default:
489       Ctx.Ptr += Size;
490       break;
491     }
492     if (Ctx.Ptr != Ctx.End)
493       return make_error<GenericBinaryError>(
494           "linking sub-section ended prematurely", object_error::parse_failed);
495   }
496   if (Ctx.Ptr != OrigEnd)
497     return make_error<GenericBinaryError>("linking section ended prematurely",
498                                           object_error::parse_failed);
499   return Error::success();
500 }
501 
parseLinkingSectionSymtab(ReadContext & Ctx)502 Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
503   uint32_t Count = readVaruint32(Ctx);
504   LinkingData.SymbolTable.reserve(Count);
505   Symbols.reserve(Count);
506   StringSet<> SymbolNames;
507 
508   std::vector<wasm::WasmImport *> ImportedGlobals;
509   std::vector<wasm::WasmImport *> ImportedFunctions;
510   std::vector<wasm::WasmImport *> ImportedTags;
511   std::vector<wasm::WasmImport *> ImportedTables;
512   ImportedGlobals.reserve(Imports.size());
513   ImportedFunctions.reserve(Imports.size());
514   ImportedTags.reserve(Imports.size());
515   ImportedTables.reserve(Imports.size());
516   for (auto &I : Imports) {
517     if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
518       ImportedFunctions.emplace_back(&I);
519     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
520       ImportedGlobals.emplace_back(&I);
521     else if (I.Kind == wasm::WASM_EXTERNAL_TAG)
522       ImportedTags.emplace_back(&I);
523     else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
524       ImportedTables.emplace_back(&I);
525   }
526 
527   while (Count--) {
528     wasm::WasmSymbolInfo Info;
529     const wasm::WasmSignature *Signature = nullptr;
530     const wasm::WasmGlobalType *GlobalType = nullptr;
531     const wasm::WasmTableType *TableType = nullptr;
532     const wasm::WasmTagType *TagType = nullptr;
533 
534     Info.Kind = readUint8(Ctx);
535     Info.Flags = readVaruint32(Ctx);
536     bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
537 
538     switch (Info.Kind) {
539     case wasm::WASM_SYMBOL_TYPE_FUNCTION:
540       Info.ElementIndex = readVaruint32(Ctx);
541       if (!isValidFunctionIndex(Info.ElementIndex) ||
542           IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
543         return make_error<GenericBinaryError>("invalid function symbol index",
544                                               object_error::parse_failed);
545       if (IsDefined) {
546         Info.Name = readString(Ctx);
547         unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
548         Signature = &Signatures[FunctionTypes[FuncIndex]];
549         wasm::WasmFunction &Function = Functions[FuncIndex];
550         if (Function.SymbolName.empty())
551           Function.SymbolName = Info.Name;
552       } else {
553         wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
554         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
555           Info.Name = readString(Ctx);
556           Info.ImportName = Import.Field;
557         } else {
558           Info.Name = Import.Field;
559         }
560         Signature = &Signatures[Import.SigIndex];
561         if (!Import.Module.empty()) {
562           Info.ImportModule = Import.Module;
563         }
564       }
565       break;
566 
567     case wasm::WASM_SYMBOL_TYPE_GLOBAL:
568       Info.ElementIndex = readVaruint32(Ctx);
569       if (!isValidGlobalIndex(Info.ElementIndex) ||
570           IsDefined != isDefinedGlobalIndex(Info.ElementIndex))
571         return make_error<GenericBinaryError>("invalid global symbol index",
572                                               object_error::parse_failed);
573       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
574                             wasm::WASM_SYMBOL_BINDING_WEAK)
575         return make_error<GenericBinaryError>("undefined weak global symbol",
576                                               object_error::parse_failed);
577       if (IsDefined) {
578         Info.Name = readString(Ctx);
579         unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
580         wasm::WasmGlobal &Global = Globals[GlobalIndex];
581         GlobalType = &Global.Type;
582         if (Global.SymbolName.empty())
583           Global.SymbolName = Info.Name;
584       } else {
585         wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
586         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
587           Info.Name = readString(Ctx);
588           Info.ImportName = Import.Field;
589         } else {
590           Info.Name = Import.Field;
591         }
592         GlobalType = &Import.Global;
593         if (!Import.Module.empty()) {
594           Info.ImportModule = Import.Module;
595         }
596       }
597       break;
598 
599     case wasm::WASM_SYMBOL_TYPE_TABLE:
600       Info.ElementIndex = readVaruint32(Ctx);
601       if (!isValidTableNumber(Info.ElementIndex) ||
602           IsDefined != isDefinedTableNumber(Info.ElementIndex))
603         return make_error<GenericBinaryError>("invalid table symbol index",
604                                               object_error::parse_failed);
605       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
606                             wasm::WASM_SYMBOL_BINDING_WEAK)
607         return make_error<GenericBinaryError>("undefined weak table symbol",
608                                               object_error::parse_failed);
609       if (IsDefined) {
610         Info.Name = readString(Ctx);
611         unsigned TableNumber = Info.ElementIndex - NumImportedTables;
612         wasm::WasmTable &Table = Tables[TableNumber];
613         TableType = &Table.Type;
614         if (Table.SymbolName.empty())
615           Table.SymbolName = Info.Name;
616       } else {
617         wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
618         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
619           Info.Name = readString(Ctx);
620           Info.ImportName = Import.Field;
621         } else {
622           Info.Name = Import.Field;
623         }
624         TableType = &Import.Table;
625         if (!Import.Module.empty()) {
626           Info.ImportModule = Import.Module;
627         }
628       }
629       break;
630 
631     case wasm::WASM_SYMBOL_TYPE_DATA:
632       Info.Name = readString(Ctx);
633       if (IsDefined) {
634         auto Index = readVaruint32(Ctx);
635         if (Index >= DataSegments.size())
636           return make_error<GenericBinaryError>("invalid data symbol index",
637                                                 object_error::parse_failed);
638         auto Offset = readVaruint64(Ctx);
639         auto Size = readVaruint64(Ctx);
640         size_t SegmentSize = DataSegments[Index].Data.Content.size();
641         if (Offset > SegmentSize)
642           return make_error<GenericBinaryError>(
643               "invalid data symbol offset: `" + Info.Name + "` (offset: " +
644                   Twine(Offset) + " segment size: " + Twine(SegmentSize) + ")",
645               object_error::parse_failed);
646         Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
647       }
648       break;
649 
650     case wasm::WASM_SYMBOL_TYPE_SECTION: {
651       if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
652           wasm::WASM_SYMBOL_BINDING_LOCAL)
653         return make_error<GenericBinaryError>(
654             "section symbols must have local binding",
655             object_error::parse_failed);
656       Info.ElementIndex = readVaruint32(Ctx);
657       // Use somewhat unique section name as symbol name.
658       StringRef SectionName = Sections[Info.ElementIndex].Name;
659       Info.Name = SectionName;
660       break;
661     }
662 
663     case wasm::WASM_SYMBOL_TYPE_TAG: {
664       Info.ElementIndex = readVaruint32(Ctx);
665       if (!isValidTagIndex(Info.ElementIndex) ||
666           IsDefined != isDefinedTagIndex(Info.ElementIndex))
667         return make_error<GenericBinaryError>("invalid tag symbol index",
668                                               object_error::parse_failed);
669       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
670                             wasm::WASM_SYMBOL_BINDING_WEAK)
671         return make_error<GenericBinaryError>("undefined weak global symbol",
672                                               object_error::parse_failed);
673       if (IsDefined) {
674         Info.Name = readString(Ctx);
675         unsigned TagIndex = Info.ElementIndex - NumImportedTags;
676         wasm::WasmTag &Tag = Tags[TagIndex];
677         Signature = &Signatures[Tag.Type.SigIndex];
678         TagType = &Tag.Type;
679         if (Tag.SymbolName.empty())
680           Tag.SymbolName = Info.Name;
681 
682       } else {
683         wasm::WasmImport &Import = *ImportedTags[Info.ElementIndex];
684         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
685           Info.Name = readString(Ctx);
686           Info.ImportName = Import.Field;
687         } else {
688           Info.Name = Import.Field;
689         }
690         TagType = &Import.Tag;
691         Signature = &Signatures[TagType->SigIndex];
692         if (!Import.Module.empty()) {
693           Info.ImportModule = Import.Module;
694         }
695       }
696       break;
697     }
698 
699     default:
700       return make_error<GenericBinaryError>("invalid symbol type: " +
701                                                 Twine(unsigned(Info.Kind)),
702                                             object_error::parse_failed);
703     }
704 
705     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
706             wasm::WASM_SYMBOL_BINDING_LOCAL &&
707         !SymbolNames.insert(Info.Name).second)
708       return make_error<GenericBinaryError>("duplicate symbol name " +
709                                                 Twine(Info.Name),
710                                             object_error::parse_failed);
711     LinkingData.SymbolTable.emplace_back(Info);
712     Symbols.emplace_back(LinkingData.SymbolTable.back(), GlobalType, TableType,
713                          TagType, Signature);
714     LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
715   }
716 
717   return Error::success();
718 }
719 
parseLinkingSectionComdat(ReadContext & Ctx)720 Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
721   uint32_t ComdatCount = readVaruint32(Ctx);
722   StringSet<> ComdatSet;
723   for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
724     StringRef Name = readString(Ctx);
725     if (Name.empty() || !ComdatSet.insert(Name).second)
726       return make_error<GenericBinaryError>("bad/duplicate COMDAT name " +
727                                                 Twine(Name),
728                                             object_error::parse_failed);
729     LinkingData.Comdats.emplace_back(Name);
730     uint32_t Flags = readVaruint32(Ctx);
731     if (Flags != 0)
732       return make_error<GenericBinaryError>("unsupported COMDAT flags",
733                                             object_error::parse_failed);
734 
735     uint32_t EntryCount = readVaruint32(Ctx);
736     while (EntryCount--) {
737       unsigned Kind = readVaruint32(Ctx);
738       unsigned Index = readVaruint32(Ctx);
739       switch (Kind) {
740       default:
741         return make_error<GenericBinaryError>("invalid COMDAT entry type",
742                                               object_error::parse_failed);
743       case wasm::WASM_COMDAT_DATA:
744         if (Index >= DataSegments.size())
745           return make_error<GenericBinaryError>(
746               "COMDAT data index out of range", object_error::parse_failed);
747         if (DataSegments[Index].Data.Comdat != UINT32_MAX)
748           return make_error<GenericBinaryError>("data segment in two COMDATs",
749                                                 object_error::parse_failed);
750         DataSegments[Index].Data.Comdat = ComdatIndex;
751         break;
752       case wasm::WASM_COMDAT_FUNCTION:
753         if (!isDefinedFunctionIndex(Index))
754           return make_error<GenericBinaryError>(
755               "COMDAT function index out of range", object_error::parse_failed);
756         if (getDefinedFunction(Index).Comdat != UINT32_MAX)
757           return make_error<GenericBinaryError>("function in two COMDATs",
758                                                 object_error::parse_failed);
759         getDefinedFunction(Index).Comdat = ComdatIndex;
760         break;
761       case wasm::WASM_COMDAT_SECTION:
762         if (Index >= Sections.size())
763           return make_error<GenericBinaryError>(
764               "COMDAT section index out of range", object_error::parse_failed);
765         if (Sections[Index].Type != wasm::WASM_SEC_CUSTOM)
766           return make_error<GenericBinaryError>(
767               "non-custom section in a COMDAT", object_error::parse_failed);
768         Sections[Index].Comdat = ComdatIndex;
769         break;
770       }
771     }
772   }
773   return Error::success();
774 }
775 
parseProducersSection(ReadContext & Ctx)776 Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
777   llvm::SmallSet<StringRef, 3> FieldsSeen;
778   uint32_t Fields = readVaruint32(Ctx);
779   for (size_t I = 0; I < Fields; ++I) {
780     StringRef FieldName = readString(Ctx);
781     if (!FieldsSeen.insert(FieldName).second)
782       return make_error<GenericBinaryError>(
783           "producers section does not have unique fields",
784           object_error::parse_failed);
785     std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
786     if (FieldName == "language") {
787       ProducerVec = &ProducerInfo.Languages;
788     } else if (FieldName == "processed-by") {
789       ProducerVec = &ProducerInfo.Tools;
790     } else if (FieldName == "sdk") {
791       ProducerVec = &ProducerInfo.SDKs;
792     } else {
793       return make_error<GenericBinaryError>(
794           "producers section field is not named one of language, processed-by, "
795           "or sdk",
796           object_error::parse_failed);
797     }
798     uint32_t ValueCount = readVaruint32(Ctx);
799     llvm::SmallSet<StringRef, 8> ProducersSeen;
800     for (size_t J = 0; J < ValueCount; ++J) {
801       StringRef Name = readString(Ctx);
802       StringRef Version = readString(Ctx);
803       if (!ProducersSeen.insert(Name).second) {
804         return make_error<GenericBinaryError>(
805             "producers section contains repeated producer",
806             object_error::parse_failed);
807       }
808       ProducerVec->emplace_back(std::string(Name), std::string(Version));
809     }
810   }
811   if (Ctx.Ptr != Ctx.End)
812     return make_error<GenericBinaryError>("producers section ended prematurely",
813                                           object_error::parse_failed);
814   return Error::success();
815 }
816 
parseTargetFeaturesSection(ReadContext & Ctx)817 Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
818   llvm::SmallSet<std::string, 8> FeaturesSeen;
819   uint32_t FeatureCount = readVaruint32(Ctx);
820   for (size_t I = 0; I < FeatureCount; ++I) {
821     wasm::WasmFeatureEntry Feature;
822     Feature.Prefix = readUint8(Ctx);
823     switch (Feature.Prefix) {
824     case wasm::WASM_FEATURE_PREFIX_USED:
825     case wasm::WASM_FEATURE_PREFIX_REQUIRED:
826     case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
827       break;
828     default:
829       return make_error<GenericBinaryError>("unknown feature policy prefix",
830                                             object_error::parse_failed);
831     }
832     Feature.Name = std::string(readString(Ctx));
833     if (!FeaturesSeen.insert(Feature.Name).second)
834       return make_error<GenericBinaryError>(
835           "target features section contains repeated feature \"" +
836               Feature.Name + "\"",
837           object_error::parse_failed);
838     TargetFeatures.push_back(Feature);
839   }
840   if (Ctx.Ptr != Ctx.End)
841     return make_error<GenericBinaryError>(
842         "target features section ended prematurely",
843         object_error::parse_failed);
844   return Error::success();
845 }
846 
parseRelocSection(StringRef Name,ReadContext & Ctx)847 Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
848   uint32_t SectionIndex = readVaruint32(Ctx);
849   if (SectionIndex >= Sections.size())
850     return make_error<GenericBinaryError>("invalid section index",
851                                           object_error::parse_failed);
852   WasmSection &Section = Sections[SectionIndex];
853   uint32_t RelocCount = readVaruint32(Ctx);
854   uint32_t EndOffset = Section.Content.size();
855   uint32_t PreviousOffset = 0;
856   while (RelocCount--) {
857     wasm::WasmRelocation Reloc = {};
858     uint32_t type = readVaruint32(Ctx);
859     Reloc.Type = type;
860     Reloc.Offset = readVaruint32(Ctx);
861     if (Reloc.Offset < PreviousOffset)
862       return make_error<GenericBinaryError>("relocations not in offset order",
863                                             object_error::parse_failed);
864     PreviousOffset = Reloc.Offset;
865     Reloc.Index = readVaruint32(Ctx);
866     switch (type) {
867     case wasm::R_WASM_FUNCTION_INDEX_LEB:
868     case wasm::R_WASM_TABLE_INDEX_SLEB:
869     case wasm::R_WASM_TABLE_INDEX_SLEB64:
870     case wasm::R_WASM_TABLE_INDEX_I32:
871     case wasm::R_WASM_TABLE_INDEX_I64:
872     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
873     case wasm::R_WASM_TABLE_INDEX_REL_SLEB64:
874       if (!isValidFunctionSymbol(Reloc.Index))
875         return make_error<GenericBinaryError>(
876             "invalid relocation function index", object_error::parse_failed);
877       break;
878     case wasm::R_WASM_TABLE_NUMBER_LEB:
879       if (!isValidTableSymbol(Reloc.Index))
880         return make_error<GenericBinaryError>("invalid relocation table index",
881                                               object_error::parse_failed);
882       break;
883     case wasm::R_WASM_TYPE_INDEX_LEB:
884       if (Reloc.Index >= Signatures.size())
885         return make_error<GenericBinaryError>("invalid relocation type index",
886                                               object_error::parse_failed);
887       break;
888     case wasm::R_WASM_GLOBAL_INDEX_LEB:
889       // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
890       // symbols to refer to their GOT entries.
891       if (!isValidGlobalSymbol(Reloc.Index) &&
892           !isValidDataSymbol(Reloc.Index) &&
893           !isValidFunctionSymbol(Reloc.Index))
894         return make_error<GenericBinaryError>("invalid relocation global index",
895                                               object_error::parse_failed);
896       break;
897     case wasm::R_WASM_GLOBAL_INDEX_I32:
898       if (!isValidGlobalSymbol(Reloc.Index))
899         return make_error<GenericBinaryError>("invalid relocation global index",
900                                               object_error::parse_failed);
901       break;
902     case wasm::R_WASM_TAG_INDEX_LEB:
903       if (!isValidTagSymbol(Reloc.Index))
904         return make_error<GenericBinaryError>("invalid relocation tag index",
905                                               object_error::parse_failed);
906       break;
907     case wasm::R_WASM_MEMORY_ADDR_LEB:
908     case wasm::R_WASM_MEMORY_ADDR_SLEB:
909     case wasm::R_WASM_MEMORY_ADDR_I32:
910     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
911     case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
912     case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
913       if (!isValidDataSymbol(Reloc.Index))
914         return make_error<GenericBinaryError>("invalid relocation data index",
915                                               object_error::parse_failed);
916       Reloc.Addend = readVarint32(Ctx);
917       break;
918     case wasm::R_WASM_MEMORY_ADDR_LEB64:
919     case wasm::R_WASM_MEMORY_ADDR_SLEB64:
920     case wasm::R_WASM_MEMORY_ADDR_I64:
921     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
922     case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64:
923       if (!isValidDataSymbol(Reloc.Index))
924         return make_error<GenericBinaryError>("invalid relocation data index",
925                                               object_error::parse_failed);
926       Reloc.Addend = readVarint64(Ctx);
927       break;
928     case wasm::R_WASM_FUNCTION_OFFSET_I32:
929       if (!isValidFunctionSymbol(Reloc.Index))
930         return make_error<GenericBinaryError>(
931             "invalid relocation function index", object_error::parse_failed);
932       Reloc.Addend = readVarint32(Ctx);
933       break;
934     case wasm::R_WASM_FUNCTION_OFFSET_I64:
935       if (!isValidFunctionSymbol(Reloc.Index))
936         return make_error<GenericBinaryError>(
937             "invalid relocation function index", object_error::parse_failed);
938       Reloc.Addend = readVarint64(Ctx);
939       break;
940     case wasm::R_WASM_SECTION_OFFSET_I32:
941       if (!isValidSectionSymbol(Reloc.Index))
942         return make_error<GenericBinaryError>(
943             "invalid relocation section index", object_error::parse_failed);
944       Reloc.Addend = readVarint32(Ctx);
945       break;
946     default:
947       return make_error<GenericBinaryError>("invalid relocation type: " +
948                                                 Twine(type),
949                                             object_error::parse_failed);
950     }
951 
952     // Relocations must fit inside the section, and must appear in order.  They
953     // also shouldn't overlap a function/element boundary, but we don't bother
954     // to check that.
955     uint64_t Size = 5;
956     if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LEB64 ||
957         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_SLEB64 ||
958         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_REL_SLEB64)
959       Size = 10;
960     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
961         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
962         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LOCREL_I32 ||
963         Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
964         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
965         Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
966       Size = 4;
967     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I64 ||
968         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64 ||
969         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I64)
970       Size = 8;
971     if (Reloc.Offset + Size > EndOffset)
972       return make_error<GenericBinaryError>("invalid relocation offset",
973                                             object_error::parse_failed);
974 
975     Section.Relocations.push_back(Reloc);
976   }
977   if (Ctx.Ptr != Ctx.End)
978     return make_error<GenericBinaryError>("reloc section ended prematurely",
979                                           object_error::parse_failed);
980   return Error::success();
981 }
982 
parseCustomSection(WasmSection & Sec,ReadContext & Ctx)983 Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
984   if (Sec.Name == "dylink") {
985     if (Error Err = parseDylinkSection(Ctx))
986       return Err;
987   } else if (Sec.Name == "name") {
988     if (Error Err = parseNameSection(Ctx))
989       return Err;
990   } else if (Sec.Name == "linking") {
991     if (Error Err = parseLinkingSection(Ctx))
992       return Err;
993   } else if (Sec.Name == "producers") {
994     if (Error Err = parseProducersSection(Ctx))
995       return Err;
996   } else if (Sec.Name == "target_features") {
997     if (Error Err = parseTargetFeaturesSection(Ctx))
998       return Err;
999   } else if (Sec.Name.startswith("reloc.")) {
1000     if (Error Err = parseRelocSection(Sec.Name, Ctx))
1001       return Err;
1002   }
1003   return Error::success();
1004 }
1005 
parseTypeSection(ReadContext & Ctx)1006 Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
1007   uint32_t Count = readVaruint32(Ctx);
1008   Signatures.reserve(Count);
1009   while (Count--) {
1010     wasm::WasmSignature Sig;
1011     uint8_t Form = readUint8(Ctx);
1012     if (Form != wasm::WASM_TYPE_FUNC) {
1013       return make_error<GenericBinaryError>("invalid signature type",
1014                                             object_error::parse_failed);
1015     }
1016     uint32_t ParamCount = readVaruint32(Ctx);
1017     Sig.Params.reserve(ParamCount);
1018     while (ParamCount--) {
1019       uint32_t ParamType = readUint8(Ctx);
1020       Sig.Params.push_back(wasm::ValType(ParamType));
1021     }
1022     uint32_t ReturnCount = readVaruint32(Ctx);
1023     while (ReturnCount--) {
1024       uint32_t ReturnType = readUint8(Ctx);
1025       Sig.Returns.push_back(wasm::ValType(ReturnType));
1026     }
1027     Signatures.push_back(std::move(Sig));
1028   }
1029   if (Ctx.Ptr != Ctx.End)
1030     return make_error<GenericBinaryError>("type section ended prematurely",
1031                                           object_error::parse_failed);
1032   return Error::success();
1033 }
1034 
parseImportSection(ReadContext & Ctx)1035 Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
1036   uint32_t Count = readVaruint32(Ctx);
1037   Imports.reserve(Count);
1038   for (uint32_t I = 0; I < Count; I++) {
1039     wasm::WasmImport Im;
1040     Im.Module = readString(Ctx);
1041     Im.Field = readString(Ctx);
1042     Im.Kind = readUint8(Ctx);
1043     switch (Im.Kind) {
1044     case wasm::WASM_EXTERNAL_FUNCTION:
1045       NumImportedFunctions++;
1046       Im.SigIndex = readVaruint32(Ctx);
1047       break;
1048     case wasm::WASM_EXTERNAL_GLOBAL:
1049       NumImportedGlobals++;
1050       Im.Global.Type = readUint8(Ctx);
1051       Im.Global.Mutable = readVaruint1(Ctx);
1052       break;
1053     case wasm::WASM_EXTERNAL_MEMORY:
1054       Im.Memory = readLimits(Ctx);
1055       if (Im.Memory.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1056         HasMemory64 = true;
1057       break;
1058     case wasm::WASM_EXTERNAL_TABLE: {
1059       Im.Table = readTableType(Ctx);
1060       NumImportedTables++;
1061       auto ElemType = Im.Table.ElemType;
1062       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
1063           ElemType != wasm::WASM_TYPE_EXTERNREF)
1064         return make_error<GenericBinaryError>("invalid table element type",
1065                                               object_error::parse_failed);
1066       break;
1067     }
1068     case wasm::WASM_EXTERNAL_TAG:
1069       NumImportedTags++;
1070       Im.Tag.Attribute = readUint8(Ctx);
1071       Im.Tag.SigIndex = readVarint32(Ctx);
1072       break;
1073     default:
1074       return make_error<GenericBinaryError>("unexpected import kind",
1075                                             object_error::parse_failed);
1076     }
1077     Imports.push_back(Im);
1078   }
1079   if (Ctx.Ptr != Ctx.End)
1080     return make_error<GenericBinaryError>("import section ended prematurely",
1081                                           object_error::parse_failed);
1082   return Error::success();
1083 }
1084 
parseFunctionSection(ReadContext & Ctx)1085 Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
1086   uint32_t Count = readVaruint32(Ctx);
1087   FunctionTypes.reserve(Count);
1088   Functions.resize(Count);
1089   uint32_t NumTypes = Signatures.size();
1090   while (Count--) {
1091     uint32_t Type = readVaruint32(Ctx);
1092     if (Type >= NumTypes)
1093       return make_error<GenericBinaryError>("invalid function type",
1094                                             object_error::parse_failed);
1095     FunctionTypes.push_back(Type);
1096   }
1097   if (Ctx.Ptr != Ctx.End)
1098     return make_error<GenericBinaryError>("function section ended prematurely",
1099                                           object_error::parse_failed);
1100   return Error::success();
1101 }
1102 
parseTableSection(ReadContext & Ctx)1103 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
1104   TableSection = Sections.size();
1105   uint32_t Count = readVaruint32(Ctx);
1106   Tables.reserve(Count);
1107   while (Count--) {
1108     wasm::WasmTable T;
1109     T.Type = readTableType(Ctx);
1110     T.Index = NumImportedTables + Tables.size();
1111     Tables.push_back(T);
1112     auto ElemType = Tables.back().Type.ElemType;
1113     if (ElemType != wasm::WASM_TYPE_FUNCREF &&
1114         ElemType != wasm::WASM_TYPE_EXTERNREF) {
1115       return make_error<GenericBinaryError>("invalid table element type",
1116                                             object_error::parse_failed);
1117     }
1118   }
1119   if (Ctx.Ptr != Ctx.End)
1120     return make_error<GenericBinaryError>("table section ended prematurely",
1121                                           object_error::parse_failed);
1122   return Error::success();
1123 }
1124 
parseMemorySection(ReadContext & Ctx)1125 Error WasmObjectFile::parseMemorySection(ReadContext &Ctx) {
1126   uint32_t Count = readVaruint32(Ctx);
1127   Memories.reserve(Count);
1128   while (Count--) {
1129     auto Limits = readLimits(Ctx);
1130     if (Limits.Flags & wasm::WASM_LIMITS_FLAG_IS_64)
1131       HasMemory64 = true;
1132     Memories.push_back(Limits);
1133   }
1134   if (Ctx.Ptr != Ctx.End)
1135     return make_error<GenericBinaryError>("memory section ended prematurely",
1136                                           object_error::parse_failed);
1137   return Error::success();
1138 }
1139 
parseTagSection(ReadContext & Ctx)1140 Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
1141   TagSection = Sections.size();
1142   uint32_t Count = readVaruint32(Ctx);
1143   Tags.reserve(Count);
1144   while (Count--) {
1145     wasm::WasmTag Tag;
1146     Tag.Index = NumImportedTags + Tags.size();
1147     Tag.Type.Attribute = readUint8(Ctx);
1148     Tag.Type.SigIndex = readVaruint32(Ctx);
1149     Tags.push_back(Tag);
1150   }
1151 
1152   if (Ctx.Ptr != Ctx.End)
1153     return make_error<GenericBinaryError>("tag section ended prematurely",
1154                                           object_error::parse_failed);
1155   return Error::success();
1156 }
1157 
parseGlobalSection(ReadContext & Ctx)1158 Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
1159   GlobalSection = Sections.size();
1160   uint32_t Count = readVaruint32(Ctx);
1161   Globals.reserve(Count);
1162   while (Count--) {
1163     wasm::WasmGlobal Global;
1164     Global.Index = NumImportedGlobals + Globals.size();
1165     Global.Type.Type = readUint8(Ctx);
1166     Global.Type.Mutable = readVaruint1(Ctx);
1167     if (Error Err = readInitExpr(Global.InitExpr, Ctx))
1168       return Err;
1169     Globals.push_back(Global);
1170   }
1171   if (Ctx.Ptr != Ctx.End)
1172     return make_error<GenericBinaryError>("global section ended prematurely",
1173                                           object_error::parse_failed);
1174   return Error::success();
1175 }
1176 
parseExportSection(ReadContext & Ctx)1177 Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
1178   uint32_t Count = readVaruint32(Ctx);
1179   Exports.reserve(Count);
1180   for (uint32_t I = 0; I < Count; I++) {
1181     wasm::WasmExport Ex;
1182     Ex.Name = readString(Ctx);
1183     Ex.Kind = readUint8(Ctx);
1184     Ex.Index = readVaruint32(Ctx);
1185     switch (Ex.Kind) {
1186     case wasm::WASM_EXTERNAL_FUNCTION:
1187 
1188       if (!isDefinedFunctionIndex(Ex.Index))
1189         return make_error<GenericBinaryError>("invalid function export",
1190                                               object_error::parse_failed);
1191       getDefinedFunction(Ex.Index).ExportName = Ex.Name;
1192       break;
1193     case wasm::WASM_EXTERNAL_GLOBAL:
1194       if (!isValidGlobalIndex(Ex.Index))
1195         return make_error<GenericBinaryError>("invalid global export",
1196                                               object_error::parse_failed);
1197       break;
1198     case wasm::WASM_EXTERNAL_TAG:
1199       if (!isValidTagIndex(Ex.Index))
1200         return make_error<GenericBinaryError>("invalid tag export",
1201                                               object_error::parse_failed);
1202       break;
1203     case wasm::WASM_EXTERNAL_MEMORY:
1204     case wasm::WASM_EXTERNAL_TABLE:
1205       break;
1206     default:
1207       return make_error<GenericBinaryError>("unexpected export kind",
1208                                             object_error::parse_failed);
1209     }
1210     Exports.push_back(Ex);
1211   }
1212   if (Ctx.Ptr != Ctx.End)
1213     return make_error<GenericBinaryError>("export section ended prematurely",
1214                                           object_error::parse_failed);
1215   return Error::success();
1216 }
1217 
isValidFunctionIndex(uint32_t Index) const1218 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
1219   return Index < NumImportedFunctions + FunctionTypes.size();
1220 }
1221 
isDefinedFunctionIndex(uint32_t Index) const1222 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
1223   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
1224 }
1225 
isValidGlobalIndex(uint32_t Index) const1226 bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
1227   return Index < NumImportedGlobals + Globals.size();
1228 }
1229 
isValidTableNumber(uint32_t Index) const1230 bool WasmObjectFile::isValidTableNumber(uint32_t Index) const {
1231   return Index < NumImportedTables + Tables.size();
1232 }
1233 
isDefinedGlobalIndex(uint32_t Index) const1234 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
1235   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
1236 }
1237 
isDefinedTableNumber(uint32_t Index) const1238 bool WasmObjectFile::isDefinedTableNumber(uint32_t Index) const {
1239   return Index >= NumImportedTables && isValidTableNumber(Index);
1240 }
1241 
isValidTagIndex(uint32_t Index) const1242 bool WasmObjectFile::isValidTagIndex(uint32_t Index) const {
1243   return Index < NumImportedTags + Tags.size();
1244 }
1245 
isDefinedTagIndex(uint32_t Index) const1246 bool WasmObjectFile::isDefinedTagIndex(uint32_t Index) const {
1247   return Index >= NumImportedTags && isValidTagIndex(Index);
1248 }
1249 
isValidFunctionSymbol(uint32_t Index) const1250 bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
1251   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
1252 }
1253 
isValidTableSymbol(uint32_t Index) const1254 bool WasmObjectFile::isValidTableSymbol(uint32_t Index) const {
1255   return Index < Symbols.size() && Symbols[Index].isTypeTable();
1256 }
1257 
isValidGlobalSymbol(uint32_t Index) const1258 bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
1259   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
1260 }
1261 
isValidTagSymbol(uint32_t Index) const1262 bool WasmObjectFile::isValidTagSymbol(uint32_t Index) const {
1263   return Index < Symbols.size() && Symbols[Index].isTypeTag();
1264 }
1265 
isValidDataSymbol(uint32_t Index) const1266 bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
1267   return Index < Symbols.size() && Symbols[Index].isTypeData();
1268 }
1269 
isValidSectionSymbol(uint32_t Index) const1270 bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
1271   return Index < Symbols.size() && Symbols[Index].isTypeSection();
1272 }
1273 
getDefinedFunction(uint32_t Index)1274 wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
1275   assert(isDefinedFunctionIndex(Index));
1276   return Functions[Index - NumImportedFunctions];
1277 }
1278 
1279 const wasm::WasmFunction &
getDefinedFunction(uint32_t Index) const1280 WasmObjectFile::getDefinedFunction(uint32_t Index) const {
1281   assert(isDefinedFunctionIndex(Index));
1282   return Functions[Index - NumImportedFunctions];
1283 }
1284 
getDefinedGlobal(uint32_t Index)1285 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
1286   assert(isDefinedGlobalIndex(Index));
1287   return Globals[Index - NumImportedGlobals];
1288 }
1289 
getDefinedTag(uint32_t Index)1290 wasm::WasmTag &WasmObjectFile::getDefinedTag(uint32_t Index) {
1291   assert(isDefinedTagIndex(Index));
1292   return Tags[Index - NumImportedTags];
1293 }
1294 
parseStartSection(ReadContext & Ctx)1295 Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
1296   StartFunction = readVaruint32(Ctx);
1297   if (!isValidFunctionIndex(StartFunction))
1298     return make_error<GenericBinaryError>("invalid start function",
1299                                           object_error::parse_failed);
1300   return Error::success();
1301 }
1302 
parseCodeSection(ReadContext & Ctx)1303 Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
1304   SeenCodeSection = true;
1305   CodeSection = Sections.size();
1306   uint32_t FunctionCount = readVaruint32(Ctx);
1307   if (FunctionCount != FunctionTypes.size()) {
1308     return make_error<GenericBinaryError>("invalid function count",
1309                                           object_error::parse_failed);
1310   }
1311 
1312   for (uint32_t i = 0; i < FunctionCount; i++) {
1313     wasm::WasmFunction& Function = Functions[i];
1314     const uint8_t *FunctionStart = Ctx.Ptr;
1315     uint32_t Size = readVaruint32(Ctx);
1316     const uint8_t *FunctionEnd = Ctx.Ptr + Size;
1317 
1318     Function.CodeOffset = Ctx.Ptr - FunctionStart;
1319     Function.Index = NumImportedFunctions + i;
1320     Function.CodeSectionOffset = FunctionStart - Ctx.Start;
1321     Function.Size = FunctionEnd - FunctionStart;
1322 
1323     uint32_t NumLocalDecls = readVaruint32(Ctx);
1324     Function.Locals.reserve(NumLocalDecls);
1325     while (NumLocalDecls--) {
1326       wasm::WasmLocalDecl Decl;
1327       Decl.Count = readVaruint32(Ctx);
1328       Decl.Type = readUint8(Ctx);
1329       Function.Locals.push_back(Decl);
1330     }
1331 
1332     uint32_t BodySize = FunctionEnd - Ctx.Ptr;
1333     Function.Body = ArrayRef<uint8_t>(Ctx.Ptr, BodySize);
1334     // This will be set later when reading in the linking metadata section.
1335     Function.Comdat = UINT32_MAX;
1336     Ctx.Ptr += BodySize;
1337     assert(Ctx.Ptr == FunctionEnd);
1338   }
1339   if (Ctx.Ptr != Ctx.End)
1340     return make_error<GenericBinaryError>("code section ended prematurely",
1341                                           object_error::parse_failed);
1342   return Error::success();
1343 }
1344 
parseElemSection(ReadContext & Ctx)1345 Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
1346   uint32_t Count = readVaruint32(Ctx);
1347   ElemSegments.reserve(Count);
1348   while (Count--) {
1349     wasm::WasmElemSegment Segment;
1350     Segment.Flags = readVaruint32(Ctx);
1351 
1352     uint32_t SupportedFlags = wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER |
1353                               wasm::WASM_ELEM_SEGMENT_IS_PASSIVE |
1354                               wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS;
1355     if (Segment.Flags & ~SupportedFlags)
1356       return make_error<GenericBinaryError>(
1357           "Unsupported flags for element segment", object_error::parse_failed);
1358 
1359     if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
1360       Segment.TableNumber = readVaruint32(Ctx);
1361     else
1362       Segment.TableNumber = 0;
1363     if (!isValidTableNumber(Segment.TableNumber))
1364       return make_error<GenericBinaryError>("invalid TableNumber",
1365                                             object_error::parse_failed);
1366 
1367     if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_PASSIVE) {
1368       Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
1369       Segment.Offset.Value.Int32 = 0;
1370     } else {
1371       if (Error Err = readInitExpr(Segment.Offset, Ctx))
1372         return Err;
1373     }
1374 
1375     if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND) {
1376       Segment.ElemKind = readUint8(Ctx);
1377       if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS) {
1378         if (Segment.ElemKind != uint8_t(wasm::ValType::FUNCREF) &&
1379             Segment.ElemKind != uint8_t(wasm::ValType::EXTERNREF)) {
1380           return make_error<GenericBinaryError>("invalid reference type",
1381                                                 object_error::parse_failed);
1382         }
1383       } else {
1384         if (Segment.ElemKind != 0)
1385           return make_error<GenericBinaryError>("invalid elemtype",
1386                                                 object_error::parse_failed);
1387         Segment.ElemKind = uint8_t(wasm::ValType::FUNCREF);
1388       }
1389     } else {
1390       Segment.ElemKind = uint8_t(wasm::ValType::FUNCREF);
1391     }
1392 
1393     if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS)
1394       return make_error<GenericBinaryError>(
1395           "elem segment init expressions not yet implemented",
1396           object_error::parse_failed);
1397 
1398     uint32_t NumElems = readVaruint32(Ctx);
1399     while (NumElems--) {
1400       Segment.Functions.push_back(readVaruint32(Ctx));
1401     }
1402     ElemSegments.push_back(Segment);
1403   }
1404   if (Ctx.Ptr != Ctx.End)
1405     return make_error<GenericBinaryError>("elem section ended prematurely",
1406                                           object_error::parse_failed);
1407   return Error::success();
1408 }
1409 
parseDataSection(ReadContext & Ctx)1410 Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
1411   DataSection = Sections.size();
1412   uint32_t Count = readVaruint32(Ctx);
1413   if (DataCount && Count != DataCount.getValue())
1414     return make_error<GenericBinaryError>(
1415         "number of data segments does not match DataCount section");
1416   DataSegments.reserve(Count);
1417   while (Count--) {
1418     WasmSegment Segment;
1419     Segment.Data.InitFlags = readVaruint32(Ctx);
1420     Segment.Data.MemoryIndex =
1421         (Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
1422             ? readVaruint32(Ctx)
1423             : 0;
1424     if ((Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
1425       if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
1426         return Err;
1427     } else {
1428       Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
1429       Segment.Data.Offset.Value.Int32 = 0;
1430     }
1431     uint32_t Size = readVaruint32(Ctx);
1432     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
1433       return make_error<GenericBinaryError>("invalid segment size",
1434                                             object_error::parse_failed);
1435     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
1436     // The rest of these Data fields are set later, when reading in the linking
1437     // metadata section.
1438     Segment.Data.Alignment = 0;
1439     Segment.Data.LinkingFlags = 0;
1440     Segment.Data.Comdat = UINT32_MAX;
1441     Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
1442     Ctx.Ptr += Size;
1443     DataSegments.push_back(Segment);
1444   }
1445   if (Ctx.Ptr != Ctx.End)
1446     return make_error<GenericBinaryError>("data section ended prematurely",
1447                                           object_error::parse_failed);
1448   return Error::success();
1449 }
1450 
parseDataCountSection(ReadContext & Ctx)1451 Error WasmObjectFile::parseDataCountSection(ReadContext &Ctx) {
1452   DataCount = readVaruint32(Ctx);
1453   return Error::success();
1454 }
1455 
getHeader() const1456 const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
1457   return Header;
1458 }
1459 
moveSymbolNext(DataRefImpl & Symb) const1460 void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.b++; }
1461 
getSymbolFlags(DataRefImpl Symb) const1462 Expected<uint32_t> WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
1463   uint32_t Result = SymbolRef::SF_None;
1464   const WasmSymbol &Sym = getWasmSymbol(Symb);
1465 
1466   LLVM_DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
1467   if (Sym.isBindingWeak())
1468     Result |= SymbolRef::SF_Weak;
1469   if (!Sym.isBindingLocal())
1470     Result |= SymbolRef::SF_Global;
1471   if (Sym.isHidden())
1472     Result |= SymbolRef::SF_Hidden;
1473   if (!Sym.isDefined())
1474     Result |= SymbolRef::SF_Undefined;
1475   if (Sym.isTypeFunction())
1476     Result |= SymbolRef::SF_Executable;
1477   return Result;
1478 }
1479 
symbol_begin() const1480 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
1481   DataRefImpl Ref;
1482   Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1483   Ref.d.b = 0; // Symbol index
1484   return BasicSymbolRef(Ref, this);
1485 }
1486 
symbol_end() const1487 basic_symbol_iterator WasmObjectFile::symbol_end() const {
1488   DataRefImpl Ref;
1489   Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1490   Ref.d.b = Symbols.size(); // Symbol index
1491   return BasicSymbolRef(Ref, this);
1492 }
1493 
getWasmSymbol(const DataRefImpl & Symb) const1494 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
1495   return Symbols[Symb.d.b];
1496 }
1497 
getWasmSymbol(const SymbolRef & Symb) const1498 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
1499   return getWasmSymbol(Symb.getRawDataRefImpl());
1500 }
1501 
getSymbolName(DataRefImpl Symb) const1502 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
1503   return getWasmSymbol(Symb).Info.Name;
1504 }
1505 
getSymbolAddress(DataRefImpl Symb) const1506 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
1507   auto &Sym = getWasmSymbol(Symb);
1508   if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION &&
1509       isDefinedFunctionIndex(Sym.Info.ElementIndex))
1510     return getDefinedFunction(Sym.Info.ElementIndex).CodeSectionOffset;
1511   else
1512     return getSymbolValue(Symb);
1513 }
1514 
getWasmSymbolValue(const WasmSymbol & Sym) const1515 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
1516   switch (Sym.Info.Kind) {
1517   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1518   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1519   case wasm::WASM_SYMBOL_TYPE_TAG:
1520   case wasm::WASM_SYMBOL_TYPE_TABLE:
1521     return Sym.Info.ElementIndex;
1522   case wasm::WASM_SYMBOL_TYPE_DATA: {
1523     // The value of a data symbol is the segment offset, plus the symbol
1524     // offset within the segment.
1525     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
1526     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
1527     if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST) {
1528       return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
1529     } else if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I64_CONST) {
1530       return Segment.Offset.Value.Int64 + Sym.Info.DataRef.Offset;
1531     } else {
1532       llvm_unreachable("unknown init expr opcode");
1533     }
1534   }
1535   case wasm::WASM_SYMBOL_TYPE_SECTION:
1536     return 0;
1537   }
1538   llvm_unreachable("invalid symbol type");
1539 }
1540 
getSymbolValueImpl(DataRefImpl Symb) const1541 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
1542   return getWasmSymbolValue(getWasmSymbol(Symb));
1543 }
1544 
getSymbolAlignment(DataRefImpl Symb) const1545 uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
1546   llvm_unreachable("not yet implemented");
1547   return 0;
1548 }
1549 
getCommonSymbolSizeImpl(DataRefImpl Symb) const1550 uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
1551   llvm_unreachable("not yet implemented");
1552   return 0;
1553 }
1554 
1555 Expected<SymbolRef::Type>
getSymbolType(DataRefImpl Symb) const1556 WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
1557   const WasmSymbol &Sym = getWasmSymbol(Symb);
1558 
1559   switch (Sym.Info.Kind) {
1560   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1561     return SymbolRef::ST_Function;
1562   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1563     return SymbolRef::ST_Other;
1564   case wasm::WASM_SYMBOL_TYPE_DATA:
1565     return SymbolRef::ST_Data;
1566   case wasm::WASM_SYMBOL_TYPE_SECTION:
1567     return SymbolRef::ST_Debug;
1568   case wasm::WASM_SYMBOL_TYPE_TAG:
1569     return SymbolRef::ST_Other;
1570   case wasm::WASM_SYMBOL_TYPE_TABLE:
1571     return SymbolRef::ST_Other;
1572   }
1573 
1574   llvm_unreachable("unknown WasmSymbol::SymbolType");
1575   return SymbolRef::ST_Other;
1576 }
1577 
1578 Expected<section_iterator>
getSymbolSection(DataRefImpl Symb) const1579 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1580   const WasmSymbol &Sym = getWasmSymbol(Symb);
1581   if (Sym.isUndefined())
1582     return section_end();
1583 
1584   DataRefImpl Ref;
1585   Ref.d.a = getSymbolSectionIdImpl(Sym);
1586   return section_iterator(SectionRef(Ref, this));
1587 }
1588 
getSymbolSectionId(SymbolRef Symb) const1589 uint32_t WasmObjectFile::getSymbolSectionId(SymbolRef Symb) const {
1590   const WasmSymbol &Sym = getWasmSymbol(Symb);
1591   return getSymbolSectionIdImpl(Sym);
1592 }
1593 
getSymbolSectionIdImpl(const WasmSymbol & Sym) const1594 uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
1595   switch (Sym.Info.Kind) {
1596   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1597     return CodeSection;
1598   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1599     return GlobalSection;
1600   case wasm::WASM_SYMBOL_TYPE_DATA:
1601     return DataSection;
1602   case wasm::WASM_SYMBOL_TYPE_SECTION:
1603     return Sym.Info.ElementIndex;
1604   case wasm::WASM_SYMBOL_TYPE_TAG:
1605     return TagSection;
1606   case wasm::WASM_SYMBOL_TYPE_TABLE:
1607     return TableSection;
1608   default:
1609     llvm_unreachable("unknown WasmSymbol::SymbolType");
1610   }
1611 }
1612 
moveSectionNext(DataRefImpl & Sec) const1613 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
1614 
getSectionName(DataRefImpl Sec) const1615 Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
1616   const WasmSection &S = Sections[Sec.d.a];
1617 #define ECase(X)                                                               \
1618   case wasm::WASM_SEC_##X:                                                     \
1619     return #X;
1620   switch (S.Type) {
1621     ECase(TYPE);
1622     ECase(IMPORT);
1623     ECase(FUNCTION);
1624     ECase(TABLE);
1625     ECase(MEMORY);
1626     ECase(GLOBAL);
1627     ECase(TAG);
1628     ECase(EXPORT);
1629     ECase(START);
1630     ECase(ELEM);
1631     ECase(CODE);
1632     ECase(DATA);
1633     ECase(DATACOUNT);
1634   case wasm::WASM_SEC_CUSTOM:
1635     return S.Name;
1636   default:
1637     return createStringError(object_error::invalid_section_index, "");
1638   }
1639 #undef ECase
1640 }
1641 
getSectionAddress(DataRefImpl Sec) const1642 uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
1643 
getSectionIndex(DataRefImpl Sec) const1644 uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
1645   return Sec.d.a;
1646 }
1647 
getSectionSize(DataRefImpl Sec) const1648 uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
1649   const WasmSection &S = Sections[Sec.d.a];
1650   return S.Content.size();
1651 }
1652 
1653 Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const1654 WasmObjectFile::getSectionContents(DataRefImpl Sec) const {
1655   const WasmSection &S = Sections[Sec.d.a];
1656   // This will never fail since wasm sections can never be empty (user-sections
1657   // must have a name and non-user sections each have a defined structure).
1658   return S.Content;
1659 }
1660 
getSectionAlignment(DataRefImpl Sec) const1661 uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1662   return 1;
1663 }
1664 
isSectionCompressed(DataRefImpl Sec) const1665 bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
1666   return false;
1667 }
1668 
isSectionText(DataRefImpl Sec) const1669 bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
1670   return getWasmSection(Sec).Type == wasm::WASM_SEC_CODE;
1671 }
1672 
isSectionData(DataRefImpl Sec) const1673 bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
1674   return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
1675 }
1676 
isSectionBSS(DataRefImpl Sec) const1677 bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
1678 
isSectionVirtual(DataRefImpl Sec) const1679 bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
1680 
section_rel_begin(DataRefImpl Ref) const1681 relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
1682   DataRefImpl RelocRef;
1683   RelocRef.d.a = Ref.d.a;
1684   RelocRef.d.b = 0;
1685   return relocation_iterator(RelocationRef(RelocRef, this));
1686 }
1687 
section_rel_end(DataRefImpl Ref) const1688 relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
1689   const WasmSection &Sec = getWasmSection(Ref);
1690   DataRefImpl RelocRef;
1691   RelocRef.d.a = Ref.d.a;
1692   RelocRef.d.b = Sec.Relocations.size();
1693   return relocation_iterator(RelocationRef(RelocRef, this));
1694 }
1695 
moveRelocationNext(DataRefImpl & Rel) const1696 void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const { Rel.d.b++; }
1697 
getRelocationOffset(DataRefImpl Ref) const1698 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
1699   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1700   return Rel.Offset;
1701 }
1702 
getRelocationSymbol(DataRefImpl Ref) const1703 symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
1704   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1705   if (Rel.Type == wasm::R_WASM_TYPE_INDEX_LEB)
1706     return symbol_end();
1707   DataRefImpl Sym;
1708   Sym.d.a = 1;
1709   Sym.d.b = Rel.Index;
1710   return symbol_iterator(SymbolRef(Sym, this));
1711 }
1712 
getRelocationType(DataRefImpl Ref) const1713 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
1714   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1715   return Rel.Type;
1716 }
1717 
getRelocationTypeName(DataRefImpl Ref,SmallVectorImpl<char> & Result) const1718 void WasmObjectFile::getRelocationTypeName(
1719     DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
1720   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1721   StringRef Res = "Unknown";
1722 
1723 #define WASM_RELOC(name, value)                                                \
1724   case wasm::name:                                                             \
1725     Res = #name;                                                               \
1726     break;
1727 
1728   switch (Rel.Type) {
1729 #include "llvm/BinaryFormat/WasmRelocs.def"
1730   }
1731 
1732 #undef WASM_RELOC
1733 
1734   Result.append(Res.begin(), Res.end());
1735 }
1736 
section_begin() const1737 section_iterator WasmObjectFile::section_begin() const {
1738   DataRefImpl Ref;
1739   Ref.d.a = 0;
1740   return section_iterator(SectionRef(Ref, this));
1741 }
1742 
section_end() const1743 section_iterator WasmObjectFile::section_end() const {
1744   DataRefImpl Ref;
1745   Ref.d.a = Sections.size();
1746   return section_iterator(SectionRef(Ref, this));
1747 }
1748 
getBytesInAddress() const1749 uint8_t WasmObjectFile::getBytesInAddress() const {
1750   return HasMemory64 ? 8 : 4;
1751 }
1752 
getFileFormatName() const1753 StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
1754 
getArch() const1755 Triple::ArchType WasmObjectFile::getArch() const {
1756   return HasMemory64 ? Triple::wasm64 : Triple::wasm32;
1757 }
1758 
getFeatures() const1759 SubtargetFeatures WasmObjectFile::getFeatures() const {
1760   return SubtargetFeatures();
1761 }
1762 
isRelocatableObject() const1763 bool WasmObjectFile::isRelocatableObject() const { return HasLinkingSection; }
1764 
isSharedObject() const1765 bool WasmObjectFile::isSharedObject() const { return HasDylinkSection; }
1766 
getWasmSection(DataRefImpl Ref) const1767 const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
1768   assert(Ref.d.a < Sections.size());
1769   return Sections[Ref.d.a];
1770 }
1771 
1772 const WasmSection &
getWasmSection(const SectionRef & Section) const1773 WasmObjectFile::getWasmSection(const SectionRef &Section) const {
1774   return getWasmSection(Section.getRawDataRefImpl());
1775 }
1776 
1777 const wasm::WasmRelocation &
getWasmRelocation(const RelocationRef & Ref) const1778 WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
1779   return getWasmRelocation(Ref.getRawDataRefImpl());
1780 }
1781 
1782 const wasm::WasmRelocation &
getWasmRelocation(DataRefImpl Ref) const1783 WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
1784   assert(Ref.d.a < Sections.size());
1785   const WasmSection &Sec = Sections[Ref.d.a];
1786   assert(Ref.d.b < Sec.Relocations.size());
1787   return Sec.Relocations[Ref.d.b];
1788 }
1789 
getSectionOrder(unsigned ID,StringRef CustomSectionName)1790 int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
1791                                              StringRef CustomSectionName) {
1792   switch (ID) {
1793   case wasm::WASM_SEC_CUSTOM:
1794     return StringSwitch<unsigned>(CustomSectionName)
1795         .Case("dylink", WASM_SEC_ORDER_DYLINK)
1796         .Case("linking", WASM_SEC_ORDER_LINKING)
1797         .StartsWith("reloc.", WASM_SEC_ORDER_RELOC)
1798         .Case("name", WASM_SEC_ORDER_NAME)
1799         .Case("producers", WASM_SEC_ORDER_PRODUCERS)
1800         .Case("target_features", WASM_SEC_ORDER_TARGET_FEATURES)
1801         .Default(WASM_SEC_ORDER_NONE);
1802   case wasm::WASM_SEC_TYPE:
1803     return WASM_SEC_ORDER_TYPE;
1804   case wasm::WASM_SEC_IMPORT:
1805     return WASM_SEC_ORDER_IMPORT;
1806   case wasm::WASM_SEC_FUNCTION:
1807     return WASM_SEC_ORDER_FUNCTION;
1808   case wasm::WASM_SEC_TABLE:
1809     return WASM_SEC_ORDER_TABLE;
1810   case wasm::WASM_SEC_MEMORY:
1811     return WASM_SEC_ORDER_MEMORY;
1812   case wasm::WASM_SEC_GLOBAL:
1813     return WASM_SEC_ORDER_GLOBAL;
1814   case wasm::WASM_SEC_EXPORT:
1815     return WASM_SEC_ORDER_EXPORT;
1816   case wasm::WASM_SEC_START:
1817     return WASM_SEC_ORDER_START;
1818   case wasm::WASM_SEC_ELEM:
1819     return WASM_SEC_ORDER_ELEM;
1820   case wasm::WASM_SEC_CODE:
1821     return WASM_SEC_ORDER_CODE;
1822   case wasm::WASM_SEC_DATA:
1823     return WASM_SEC_ORDER_DATA;
1824   case wasm::WASM_SEC_DATACOUNT:
1825     return WASM_SEC_ORDER_DATACOUNT;
1826   case wasm::WASM_SEC_TAG:
1827     return WASM_SEC_ORDER_TAG;
1828   default:
1829     return WASM_SEC_ORDER_NONE;
1830   }
1831 }
1832 
1833 // Represents the edges in a directed graph where any node B reachable from node
1834 // A is not allowed to appear before A in the section ordering, but may appear
1835 // afterward.
1836 int WasmSectionOrderChecker::DisallowedPredecessors
1837     [WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
1838         // WASM_SEC_ORDER_NONE
1839         {},
1840         // WASM_SEC_ORDER_TYPE
1841         {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT},
1842         // WASM_SEC_ORDER_IMPORT
1843         {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION},
1844         // WASM_SEC_ORDER_FUNCTION
1845         {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE},
1846         // WASM_SEC_ORDER_TABLE
1847         {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY},
1848         // WASM_SEC_ORDER_MEMORY
1849         {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_TAG},
1850         // WASM_SEC_ORDER_TAG
1851         {WASM_SEC_ORDER_TAG, WASM_SEC_ORDER_GLOBAL},
1852         // WASM_SEC_ORDER_GLOBAL
1853         {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EXPORT},
1854         // WASM_SEC_ORDER_EXPORT
1855         {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START},
1856         // WASM_SEC_ORDER_START
1857         {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM},
1858         // WASM_SEC_ORDER_ELEM
1859         {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT},
1860         // WASM_SEC_ORDER_DATACOUNT
1861         {WASM_SEC_ORDER_DATACOUNT, WASM_SEC_ORDER_CODE},
1862         // WASM_SEC_ORDER_CODE
1863         {WASM_SEC_ORDER_CODE, WASM_SEC_ORDER_DATA},
1864         // WASM_SEC_ORDER_DATA
1865         {WASM_SEC_ORDER_DATA, WASM_SEC_ORDER_LINKING},
1866 
1867         // Custom Sections
1868         // WASM_SEC_ORDER_DYLINK
1869         {WASM_SEC_ORDER_DYLINK, WASM_SEC_ORDER_TYPE},
1870         // WASM_SEC_ORDER_LINKING
1871         {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC, WASM_SEC_ORDER_NAME},
1872         // WASM_SEC_ORDER_RELOC (can be repeated)
1873         {},
1874         // WASM_SEC_ORDER_NAME
1875         {WASM_SEC_ORDER_NAME, WASM_SEC_ORDER_PRODUCERS},
1876         // WASM_SEC_ORDER_PRODUCERS
1877         {WASM_SEC_ORDER_PRODUCERS, WASM_SEC_ORDER_TARGET_FEATURES},
1878         // WASM_SEC_ORDER_TARGET_FEATURES
1879         {WASM_SEC_ORDER_TARGET_FEATURES}};
1880 
isValidSectionOrder(unsigned ID,StringRef CustomSectionName)1881 bool WasmSectionOrderChecker::isValidSectionOrder(unsigned ID,
1882                                                   StringRef CustomSectionName) {
1883   int Order = getSectionOrder(ID, CustomSectionName);
1884   if (Order == WASM_SEC_ORDER_NONE)
1885     return true;
1886 
1887   // Disallowed predecessors we need to check for
1888   SmallVector<int, WASM_NUM_SEC_ORDERS> WorkList;
1889 
1890   // Keep track of completed checks to avoid repeating work
1891   bool Checked[WASM_NUM_SEC_ORDERS] = {};
1892 
1893   int Curr = Order;
1894   while (true) {
1895     // Add new disallowed predecessors to work list
1896     for (size_t I = 0;; ++I) {
1897       int Next = DisallowedPredecessors[Curr][I];
1898       if (Next == WASM_SEC_ORDER_NONE)
1899         break;
1900       if (Checked[Next])
1901         continue;
1902       WorkList.push_back(Next);
1903       Checked[Next] = true;
1904     }
1905 
1906     if (WorkList.empty())
1907       break;
1908 
1909     // Consider next disallowed predecessor
1910     Curr = WorkList.pop_back_val();
1911     if (Seen[Curr])
1912       return false;
1913   }
1914 
1915   // Have not seen any disallowed predecessors
1916   Seen[Order] = true;
1917   return true;
1918 }
1919