xref: /llvm-project/llvm/lib/Object/WasmObjectFile.cpp (revision 86b4a09a99b689f9717bd17cabd850857a53388d) 
1 //===- WasmObjectFile.cpp - Wasm object file implementation ---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/ArrayRef.h"
11 #include "llvm/ADT/DenseSet.h"
12 #include "llvm/ADT/STLExtras.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/StringSet.h"
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/BinaryFormat/Wasm.h"
17 #include "llvm/MC/SubtargetFeature.h"
18 #include "llvm/Object/Binary.h"
19 #include "llvm/Object/Error.h"
20 #include "llvm/Object/ObjectFile.h"
21 #include "llvm/Object/SymbolicFile.h"
22 #include "llvm/Object/Wasm.h"
23 #include "llvm/Support/Endian.h"
24 #include "llvm/Support/Error.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/LEB128.h"
27 #include <algorithm>
28 #include <cassert>
29 #include <cstdint>
30 #include <cstring>
31 #include <system_error>
32 
33 #define DEBUG_TYPE "wasm-object"
34 
35 using namespace llvm;
36 using namespace object;
37 
38 Expected<std::unique_ptr<WasmObjectFile>>
39 ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
40   Error Err = Error::success();
41   auto ObjectFile = llvm::make_unique<WasmObjectFile>(Buffer, Err);
42   if (Err)
43     return std::move(Err);
44 
45   return std::move(ObjectFile);
46 }
47 
48 #define VARINT7_MAX ((1<<7)-1)
49 #define VARINT7_MIN (-(1<<7))
50 #define VARUINT7_MAX (1<<7)
51 #define VARUINT1_MAX (1)
52 
53 static uint8_t readUint8(const uint8_t *&Ptr) { return *Ptr++; }
54 
55 static uint32_t readUint32(const uint8_t *&Ptr) {
56   uint32_t Result = support::endian::read32le(Ptr);
57   Ptr += sizeof(Result);
58   return Result;
59 }
60 
61 static int32_t readFloat32(const uint8_t *&Ptr) {
62   int32_t Result = 0;
63   memcpy(&Result, Ptr, sizeof(Result));
64   Ptr += sizeof(Result);
65   return Result;
66 }
67 
68 static int64_t readFloat64(const uint8_t *&Ptr) {
69   int64_t Result = 0;
70   memcpy(&Result, Ptr, sizeof(Result));
71   Ptr += sizeof(Result);
72   return Result;
73 }
74 
75 static uint64_t readULEB128(const uint8_t *&Ptr) {
76   unsigned Count;
77   uint64_t Result = decodeULEB128(Ptr, &Count);
78   Ptr += Count;
79   return Result;
80 }
81 
82 static StringRef readString(const uint8_t *&Ptr) {
83   uint32_t StringLen = readULEB128(Ptr);
84   StringRef Return = StringRef(reinterpret_cast<const char *>(Ptr), StringLen);
85   Ptr += StringLen;
86   return Return;
87 }
88 
89 static int64_t readLEB128(const uint8_t *&Ptr) {
90   unsigned Count;
91   uint64_t Result = decodeSLEB128(Ptr, &Count);
92   Ptr += Count;
93   return Result;
94 }
95 
96 static uint8_t readVaruint1(const uint8_t *&Ptr) {
97   int64_t result = readLEB128(Ptr);
98   assert(result <= VARUINT1_MAX && result >= 0);
99   return result;
100 }
101 
102 static int8_t readVarint7(const uint8_t *&Ptr) {
103   int64_t result = readLEB128(Ptr);
104   assert(result <= VARINT7_MAX && result >= VARINT7_MIN);
105   return result;
106 }
107 
108 static uint8_t readVaruint7(const uint8_t *&Ptr) {
109   uint64_t result = readULEB128(Ptr);
110   assert(result <= VARUINT7_MAX);
111   return result;
112 }
113 
114 static int32_t readVarint32(const uint8_t *&Ptr) {
115   int64_t result = readLEB128(Ptr);
116   assert(result <= INT32_MAX && result >= INT32_MIN);
117   return result;
118 }
119 
120 static uint32_t readVaruint32(const uint8_t *&Ptr) {
121   uint64_t result = readULEB128(Ptr);
122   assert(result <= UINT32_MAX);
123   return result;
124 }
125 
126 static int64_t readVarint64(const uint8_t *&Ptr) {
127   return readLEB128(Ptr);
128 }
129 
130 static uint8_t readOpcode(const uint8_t *&Ptr) {
131   return readUint8(Ptr);
132 }
133 
134 static Error readInitExpr(wasm::WasmInitExpr &Expr, const uint8_t *&Ptr) {
135   Expr.Opcode = readOpcode(Ptr);
136 
137   switch (Expr.Opcode) {
138   case wasm::WASM_OPCODE_I32_CONST:
139     Expr.Value.Int32 = readVarint32(Ptr);
140     break;
141   case wasm::WASM_OPCODE_I64_CONST:
142     Expr.Value.Int64 = readVarint64(Ptr);
143     break;
144   case wasm::WASM_OPCODE_F32_CONST:
145     Expr.Value.Float32 = readFloat32(Ptr);
146     break;
147   case wasm::WASM_OPCODE_F64_CONST:
148     Expr.Value.Float64 = readFloat64(Ptr);
149     break;
150   case wasm::WASM_OPCODE_GET_GLOBAL:
151     Expr.Value.Global = readULEB128(Ptr);
152     break;
153   default:
154     return make_error<GenericBinaryError>("Invalid opcode in init_expr",
155                                           object_error::parse_failed);
156   }
157 
158   uint8_t EndOpcode = readOpcode(Ptr);
159   if (EndOpcode != wasm::WASM_OPCODE_END) {
160     return make_error<GenericBinaryError>("Invalid init_expr",
161                                           object_error::parse_failed);
162   }
163   return Error::success();
164 }
165 
166 static wasm::WasmLimits readLimits(const uint8_t *&Ptr) {
167   wasm::WasmLimits Result;
168   Result.Flags = readVaruint1(Ptr);
169   Result.Initial = readVaruint32(Ptr);
170   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
171     Result.Maximum = readVaruint32(Ptr);
172   return Result;
173 }
174 
175 static wasm::WasmTable readTable(const uint8_t *&Ptr) {
176   wasm::WasmTable Table;
177   Table.ElemType = readVarint7(Ptr);
178   Table.Limits = readLimits(Ptr);
179   return Table;
180 }
181 
182 static Error readSection(WasmSection &Section, const uint8_t *&Ptr,
183                          const uint8_t *Start, const uint8_t *Eof) {
184   Section.Offset = Ptr - Start;
185   Section.Type = readVaruint7(Ptr);
186   uint32_t Size = readVaruint32(Ptr);
187   if (Size == 0)
188     return make_error<StringError>("Zero length section",
189                                    object_error::parse_failed);
190   if (Ptr + Size > Eof)
191     return make_error<StringError>("Section too large",
192                                    object_error::parse_failed);
193   Section.Content = ArrayRef<uint8_t>(Ptr, Size);
194   Ptr += Size;
195   return Error::success();
196 }
197 
198 WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
199     : ObjectFile(Binary::ID_Wasm, Buffer) {
200   ErrorAsOutParameter ErrAsOutParam(&Err);
201   Header.Magic = getData().substr(0, 4);
202   if (Header.Magic != StringRef("\0asm", 4)) {
203     Err = make_error<StringError>("Bad magic number",
204                                   object_error::parse_failed);
205     return;
206   }
207 
208   const uint8_t *Eof = getPtr(getData().size());
209   const uint8_t *Ptr = getPtr(4);
210 
211   if (Ptr + 4 > Eof) {
212     Err = make_error<StringError>("Missing version number",
213                                   object_error::parse_failed);
214     return;
215   }
216 
217   Header.Version = readUint32(Ptr);
218   if (Header.Version != wasm::WasmVersion) {
219     Err = make_error<StringError>("Bad version number",
220                                   object_error::parse_failed);
221     return;
222   }
223 
224   WasmSection Sec;
225   while (Ptr < Eof) {
226     if ((Err = readSection(Sec, Ptr, getPtr(0), Eof)))
227       return;
228     if ((Err = parseSection(Sec)))
229       return;
230 
231     Sections.push_back(Sec);
232   }
233 }
234 
235 Error WasmObjectFile::parseSection(WasmSection &Sec) {
236   const uint8_t* Start = Sec.Content.data();
237   const uint8_t* End = Start + Sec.Content.size();
238   switch (Sec.Type) {
239   case wasm::WASM_SEC_CUSTOM:
240     return parseCustomSection(Sec, Start, End);
241   case wasm::WASM_SEC_TYPE:
242     return parseTypeSection(Start, End);
243   case wasm::WASM_SEC_IMPORT:
244     return parseImportSection(Start, End);
245   case wasm::WASM_SEC_FUNCTION:
246     return parseFunctionSection(Start, End);
247   case wasm::WASM_SEC_TABLE:
248     return parseTableSection(Start, End);
249   case wasm::WASM_SEC_MEMORY:
250     return parseMemorySection(Start, End);
251   case wasm::WASM_SEC_GLOBAL:
252     return parseGlobalSection(Start, End);
253   case wasm::WASM_SEC_EXPORT:
254     return parseExportSection(Start, End);
255   case wasm::WASM_SEC_START:
256     return parseStartSection(Start, End);
257   case wasm::WASM_SEC_ELEM:
258     return parseElemSection(Start, End);
259   case wasm::WASM_SEC_CODE:
260     return parseCodeSection(Start, End);
261   case wasm::WASM_SEC_DATA:
262     return parseDataSection(Start, End);
263   default:
264     return make_error<GenericBinaryError>("Bad section type",
265                                           object_error::parse_failed);
266   }
267 }
268 
269 Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
270   llvm::DenseSet<uint64_t> Seen;
271   if (Functions.size() != FunctionTypes.size()) {
272     return make_error<GenericBinaryError>("Names must come after code section",
273                                           object_error::parse_failed);
274   }
275 
276   while (Ptr < End) {
277     uint8_t Type = readVarint7(Ptr);
278     uint32_t Size = readVaruint32(Ptr);
279     const uint8_t *SubSectionEnd = Ptr + Size;
280     switch (Type) {
281     case wasm::WASM_NAMES_FUNCTION: {
282       uint32_t Count = readVaruint32(Ptr);
283       while (Count--) {
284         uint32_t Index = readVaruint32(Ptr);
285         if (!Seen.insert(Index).second)
286           return make_error<GenericBinaryError>("Function named more than once",
287                                                 object_error::parse_failed);
288         StringRef Name = readString(Ptr);
289         if (!isValidFunctionIndex(Index) || Name.empty())
290           return make_error<GenericBinaryError>("Invalid name entry",
291                                                 object_error::parse_failed);
292         DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
293         if (isDefinedFunctionIndex(Index)) {
294           // Override any existing name; the name specified by the "names"
295           // section is the Function's canonical name.
296           getDefinedFunction(Index).Name = Name;
297         }
298       }
299       break;
300     }
301     // Ignore local names for now
302     case wasm::WASM_NAMES_LOCAL:
303     default:
304       Ptr += Size;
305       break;
306     }
307     if (Ptr != SubSectionEnd)
308       return make_error<GenericBinaryError>("Name sub-section ended prematurely",
309                                             object_error::parse_failed);
310   }
311 
312   if (Ptr != End)
313     return make_error<GenericBinaryError>("Name section ended prematurely",
314                                           object_error::parse_failed);
315   return Error::success();
316 }
317 
318 Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
319                                           const uint8_t *End) {
320   HasLinkingSection = true;
321   if (Functions.size() != FunctionTypes.size()) {
322     return make_error<GenericBinaryError>(
323         "Linking data must come after code section", object_error::parse_failed);
324   }
325 
326   while (Ptr < End) {
327     uint8_t Type = readVarint7(Ptr);
328     uint32_t Size = readVaruint32(Ptr);
329     const uint8_t *SubSectionEnd = Ptr + Size;
330     switch (Type) {
331     case wasm::WASM_SYMBOL_TABLE:
332       if (Error Err = parseLinkingSectionSymtab(Ptr, SubSectionEnd))
333         return Err;
334       break;
335     case wasm::WASM_SEGMENT_INFO: {
336       uint32_t Count = readVaruint32(Ptr);
337       if (Count > DataSegments.size())
338         return make_error<GenericBinaryError>("Too many segment names",
339                                               object_error::parse_failed);
340       for (uint32_t i = 0; i < Count; i++) {
341         DataSegments[i].Data.Name = readString(Ptr);
342         DataSegments[i].Data.Alignment = readVaruint32(Ptr);
343         DataSegments[i].Data.Flags = readVaruint32(Ptr);
344       }
345       break;
346     }
347     case wasm::WASM_INIT_FUNCS: {
348       uint32_t Count = readVaruint32(Ptr);
349       LinkingData.InitFunctions.reserve(Count);
350       for (uint32_t i = 0; i < Count; i++) {
351         wasm::WasmInitFunc Init;
352         Init.Priority = readVaruint32(Ptr);
353         Init.Symbol = readVaruint32(Ptr);
354         if (!isValidFunctionSymbolIndex(Init.Symbol))
355           return make_error<GenericBinaryError>("Invalid function symbol: " +
356                                                     Twine(Init.Symbol),
357                                                 object_error::parse_failed);
358         LinkingData.InitFunctions.emplace_back(Init);
359       }
360       break;
361     }
362     case wasm::WASM_COMDAT_INFO:
363       if (Error Err = parseLinkingSectionComdat(Ptr, SubSectionEnd))
364         return Err;
365       break;
366     default:
367       Ptr += Size;
368       break;
369     }
370     if (Ptr != SubSectionEnd)
371       return make_error<GenericBinaryError>(
372           "Linking sub-section ended prematurely", object_error::parse_failed);
373   }
374   if (Ptr != End)
375     return make_error<GenericBinaryError>("Linking section ended prematurely",
376                                           object_error::parse_failed);
377   return Error::success();
378 }
379 
380 Error WasmObjectFile::parseLinkingSectionSymtab(const uint8_t *&Ptr,
381                                                 const uint8_t *End) {
382   uint32_t Count = readVaruint32(Ptr);
383   LinkingData.SymbolTable.reserve(Count);
384   Symbols.reserve(Count);
385   StringSet<> SymbolNames;
386 
387   std::vector<wasm::WasmImport *> ImportedGlobals;
388   std::vector<wasm::WasmImport *> ImportedFunctions;
389   ImportedGlobals.reserve(Imports.size());
390   ImportedFunctions.reserve(Imports.size());
391   for (auto &I : Imports) {
392     if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
393       ImportedFunctions.emplace_back(&I);
394     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
395       ImportedGlobals.emplace_back(&I);
396   }
397 
398   while (Count--) {
399     wasm::WasmSymbolInfo Info;
400     const wasm::WasmSignature *FunctionType = nullptr;
401     const wasm::WasmGlobalType *GlobalType = nullptr;
402 
403     Info.Kind = readUint8(Ptr);
404     Info.Flags = readVaruint32(Ptr);
405     bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
406 
407     switch (Info.Kind) {
408     case wasm::WASM_SYMBOL_TYPE_FUNCTION:
409       Info.ElementIndex = readVaruint32(Ptr);
410       if (!isValidFunctionIndex(Info.ElementIndex) ||
411           IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
412         return make_error<GenericBinaryError>("invalid function symbol index",
413                                               object_error::parse_failed);
414       if (IsDefined) {
415         Info.Name = readString(Ptr);
416         unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
417         FunctionType = &Signatures[FunctionTypes[FuncIndex]];
418         auto &Function = Functions[FuncIndex];
419         if (Function.Name.empty()) {
420           // Use the symbol's name to set a name for the Function, but only if
421           // one hasn't already been set.
422           Function.Name = Info.Name;
423         }
424       } else {
425         wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
426         FunctionType = &Signatures[Import.SigIndex];
427         Info.Name = Import.Field;
428       }
429       break;
430 
431     case wasm::WASM_SYMBOL_TYPE_GLOBAL:
432       Info.ElementIndex = readVaruint32(Ptr);
433       if (!isValidGlobalIndex(Info.ElementIndex) ||
434           IsDefined != isDefinedGlobalIndex(Info.ElementIndex))
435         return make_error<GenericBinaryError>("invalid global symbol index",
436                                               object_error::parse_failed);
437       if (IsDefined) {
438         Info.Name = readString(Ptr);
439         unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
440         GlobalType = &Globals[GlobalIndex].Type;
441       } else {
442         wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
443         Info.Name = Import.Field;
444         GlobalType = &Import.Global;
445       }
446       break;
447 
448     case wasm::WASM_SYMBOL_TYPE_DATA:
449       Info.Name = readString(Ptr);
450       if (IsDefined) {
451         uint32_t Index = readVaruint32(Ptr);
452         if (Index >= DataSegments.size())
453           return make_error<GenericBinaryError>("invalid data symbol index",
454                                                 object_error::parse_failed);
455         uint32_t Offset = readVaruint32(Ptr);
456         uint32_t Size = readVaruint32(Ptr);
457         if (Offset + Size > DataSegments[Index].Data.Content.size())
458           return make_error<GenericBinaryError>("invalid data symbol index",
459                                                 object_error::parse_failed);
460         Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
461       }
462       break;
463 
464     default:
465       return make_error<GenericBinaryError>("Invalid symbol type",
466                                             object_error::parse_failed);
467     }
468 
469     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
470             wasm::WASM_SYMBOL_BINDING_LOCAL &&
471         !SymbolNames.insert(Info.Name).second)
472       return make_error<GenericBinaryError>("Duplicate symbol name " +
473                                                 Twine(Info.Name),
474                                             object_error::parse_failed);
475     LinkingData.SymbolTable.emplace_back(Info);
476     Symbols.emplace_back(LinkingData.SymbolTable.back(), FunctionType,
477                          GlobalType);
478     DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
479   }
480 
481   return Error::success();
482 }
483 
484 Error WasmObjectFile::parseLinkingSectionComdat(const uint8_t *&Ptr,
485                                                 const uint8_t *End)
486 {
487   uint32_t ComdatCount = readVaruint32(Ptr);
488   StringSet<> ComdatSet;
489   while (ComdatCount--) {
490     StringRef Name = readString(Ptr);
491     if (Name.empty() || !ComdatSet.insert(Name).second)
492       return make_error<GenericBinaryError>("Bad/duplicate COMDAT name " + Twine(Name),
493                                             object_error::parse_failed);
494     Comdats.emplace_back(Name);
495     uint32_t Flags = readVaruint32(Ptr);
496     if (Flags != 0)
497       return make_error<GenericBinaryError>("Unsupported COMDAT flags",
498                                             object_error::parse_failed);
499 
500     uint32_t EntryCount = readVaruint32(Ptr);
501     while (EntryCount--) {
502       unsigned Kind = readVaruint32(Ptr);
503       unsigned Index = readVaruint32(Ptr);
504       switch (Kind) {
505       default:
506         return make_error<GenericBinaryError>("Invalid COMDAT entry type",
507                                               object_error::parse_failed);
508       case wasm::WASM_COMDAT_DATA:
509         if (Index >= DataSegments.size())
510           return make_error<GenericBinaryError>("COMDAT data index out of range",
511                                                 object_error::parse_failed);
512         if (!DataSegments[Index].Data.Comdat.empty())
513           return make_error<GenericBinaryError>("Data segment in two COMDATs",
514                                                 object_error::parse_failed);
515         DataSegments[Index].Data.Comdat = Name;
516         break;
517       case wasm::WASM_COMDAT_FUNCTION:
518         if (!isDefinedFunctionIndex(Index))
519           return make_error<GenericBinaryError>("COMDAT function index out of range",
520                                                 object_error::parse_failed);
521         if (!getDefinedFunction(Index).Comdat.empty())
522           return make_error<GenericBinaryError>("Function in two COMDATs",
523                                                 object_error::parse_failed);
524         getDefinedFunction(Index).Comdat = Name;
525         break;
526       }
527     }
528   }
529   return Error::success();
530 }
531 
532 WasmSection* WasmObjectFile::findCustomSectionByName(StringRef Name) {
533   for (WasmSection& Section : Sections) {
534     if (Section.Type == wasm::WASM_SEC_CUSTOM && Section.Name == Name)
535       return &Section;
536   }
537   return nullptr;
538 }
539 
540 WasmSection* WasmObjectFile::findSectionByType(uint32_t Type) {
541   assert(Type != wasm::WASM_SEC_CUSTOM);
542   for (WasmSection& Section : Sections) {
543     if (Section.Type == Type)
544       return &Section;
545   }
546   return nullptr;
547 }
548 
549 Error WasmObjectFile::parseRelocSection(StringRef Name, const uint8_t *Ptr,
550                                         const uint8_t *End) {
551   uint8_t SectionCode = readVarint7(Ptr);
552   WasmSection* Section = nullptr;
553   if (SectionCode == wasm::WASM_SEC_CUSTOM) {
554     StringRef Name = readString(Ptr);
555     Section = findCustomSectionByName(Name);
556   } else {
557     Section = findSectionByType(SectionCode);
558   }
559   if (!Section)
560     return make_error<GenericBinaryError>("Invalid section code",
561                                           object_error::parse_failed);
562   uint32_t RelocCount = readVaruint32(Ptr);
563   while (RelocCount--) {
564     wasm::WasmRelocation Reloc;
565     memset(&Reloc, 0, sizeof(Reloc));
566     Reloc.Type = readVaruint32(Ptr);
567     Reloc.Offset = readVaruint32(Ptr);
568     Reloc.Index = readVaruint32(Ptr);
569     switch (Reloc.Type) {
570     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
571     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
572     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
573     case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
574     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
575       break;
576     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
577     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
578     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
579       Reloc.Addend = readVarint32(Ptr);
580       break;
581     default:
582       return make_error<GenericBinaryError>("Bad relocation type: " +
583                                                 Twine(Reloc.Type),
584                                             object_error::parse_failed);
585     }
586     Section->Relocations.push_back(Reloc);
587   }
588   if (Ptr != End)
589     return make_error<GenericBinaryError>("Reloc section ended prematurely",
590                                           object_error::parse_failed);
591   return Error::success();
592 }
593 
594 Error WasmObjectFile::parseCustomSection(WasmSection &Sec,
595                                          const uint8_t *Ptr, const uint8_t *End) {
596   Sec.Name = readString(Ptr);
597   if (Sec.Name == "name") {
598     if (Error Err = parseNameSection(Ptr, End))
599       return Err;
600   } else if (Sec.Name == "linking") {
601     if (Error Err = parseLinkingSection(Ptr, End))
602       return Err;
603   } else if (Sec.Name.startswith("reloc.")) {
604     if (Error Err = parseRelocSection(Sec.Name, Ptr, End))
605       return Err;
606   }
607   return Error::success();
608 }
609 
610 Error WasmObjectFile::parseTypeSection(const uint8_t *Ptr, const uint8_t *End) {
611   uint32_t Count = readVaruint32(Ptr);
612   Signatures.reserve(Count);
613   while (Count--) {
614     wasm::WasmSignature Sig;
615     Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
616     int8_t Form = readVarint7(Ptr);
617     if (Form != wasm::WASM_TYPE_FUNC) {
618       return make_error<GenericBinaryError>("Invalid signature type",
619                                             object_error::parse_failed);
620     }
621     uint32_t ParamCount = readVaruint32(Ptr);
622     Sig.ParamTypes.reserve(ParamCount);
623     while (ParamCount--) {
624       uint32_t ParamType = readVarint7(Ptr);
625       Sig.ParamTypes.push_back(ParamType);
626     }
627     uint32_t ReturnCount = readVaruint32(Ptr);
628     if (ReturnCount) {
629       if (ReturnCount != 1) {
630         return make_error<GenericBinaryError>(
631             "Multiple return types not supported", object_error::parse_failed);
632       }
633       Sig.ReturnType = readVarint7(Ptr);
634     }
635     Signatures.push_back(Sig);
636   }
637   if (Ptr != End)
638     return make_error<GenericBinaryError>("Type section ended prematurely",
639                                           object_error::parse_failed);
640   return Error::success();
641 }
642 
643 Error WasmObjectFile::parseImportSection(const uint8_t *Ptr, const uint8_t *End) {
644   uint32_t Count = readVaruint32(Ptr);
645   Imports.reserve(Count);
646   for (uint32_t i = 0; i < Count; i++) {
647     wasm::WasmImport Im;
648     Im.Module = readString(Ptr);
649     Im.Field = readString(Ptr);
650     Im.Kind = readUint8(Ptr);
651     switch (Im.Kind) {
652     case wasm::WASM_EXTERNAL_FUNCTION:
653       NumImportedFunctions++;
654       Im.SigIndex = readVaruint32(Ptr);
655       break;
656     case wasm::WASM_EXTERNAL_GLOBAL:
657       NumImportedGlobals++;
658       Im.Global.Type = readVarint7(Ptr);
659       Im.Global.Mutable = readVaruint1(Ptr);
660       break;
661     case wasm::WASM_EXTERNAL_MEMORY:
662       Im.Memory = readLimits(Ptr);
663       break;
664     case wasm::WASM_EXTERNAL_TABLE:
665       Im.Table = readTable(Ptr);
666       if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC)
667         return make_error<GenericBinaryError>("Invalid table element type",
668                                               object_error::parse_failed);
669       break;
670     default:
671       return make_error<GenericBinaryError>(
672           "Unexpected import kind", object_error::parse_failed);
673     }
674     Imports.push_back(Im);
675   }
676   if (Ptr != End)
677     return make_error<GenericBinaryError>("Import section ended prematurely",
678                                           object_error::parse_failed);
679   return Error::success();
680 }
681 
682 Error WasmObjectFile::parseFunctionSection(const uint8_t *Ptr, const uint8_t *End) {
683   uint32_t Count = readVaruint32(Ptr);
684   FunctionTypes.reserve(Count);
685   while (Count--) {
686     FunctionTypes.push_back(readVaruint32(Ptr));
687   }
688   if (Ptr != End)
689     return make_error<GenericBinaryError>("Function section ended prematurely",
690                                           object_error::parse_failed);
691   return Error::success();
692 }
693 
694 Error WasmObjectFile::parseTableSection(const uint8_t *Ptr, const uint8_t *End) {
695   uint32_t Count = readVaruint32(Ptr);
696   Tables.reserve(Count);
697   while (Count--) {
698     Tables.push_back(readTable(Ptr));
699     if (Tables.back().ElemType != wasm::WASM_TYPE_ANYFUNC) {
700       return make_error<GenericBinaryError>("Invalid table element type",
701                                             object_error::parse_failed);
702     }
703   }
704   if (Ptr != End)
705     return make_error<GenericBinaryError>("Table section ended prematurely",
706                                           object_error::parse_failed);
707   return Error::success();
708 }
709 
710 Error WasmObjectFile::parseMemorySection(const uint8_t *Ptr, const uint8_t *End) {
711   uint32_t Count = readVaruint32(Ptr);
712   Memories.reserve(Count);
713   while (Count--) {
714     Memories.push_back(readLimits(Ptr));
715   }
716   if (Ptr != End)
717     return make_error<GenericBinaryError>("Memory section ended prematurely",
718                                           object_error::parse_failed);
719   return Error::success();
720 }
721 
722 Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, const uint8_t *End) {
723   GlobalSection = Sections.size();
724   uint32_t Count = readVaruint32(Ptr);
725   Globals.reserve(Count);
726   while (Count--) {
727     wasm::WasmGlobal Global;
728     Global.Index = NumImportedGlobals + Globals.size();
729     Global.Type.Type = readVarint7(Ptr);
730     Global.Type.Mutable = readVaruint1(Ptr);
731     if (Error Err = readInitExpr(Global.InitExpr, Ptr))
732       return Err;
733     Globals.push_back(Global);
734   }
735   if (Ptr != End)
736     return make_error<GenericBinaryError>("Global section ended prematurely",
737                                           object_error::parse_failed);
738   return Error::success();
739 }
740 
741 Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
742   uint32_t Count = readVaruint32(Ptr);
743   Exports.reserve(Count);
744   for (uint32_t i = 0; i < Count; i++) {
745     wasm::WasmExport Ex;
746     Ex.Name = readString(Ptr);
747     Ex.Kind = readUint8(Ptr);
748     Ex.Index = readVaruint32(Ptr);
749     switch (Ex.Kind) {
750     case wasm::WASM_EXTERNAL_FUNCTION:
751       if (!isValidFunctionIndex(Ex.Index))
752         return make_error<GenericBinaryError>("Invalid function export",
753                                               object_error::parse_failed);
754       break;
755     case wasm::WASM_EXTERNAL_GLOBAL:
756       if (!isValidGlobalIndex(Ex.Index))
757         return make_error<GenericBinaryError>("Invalid global export",
758                                               object_error::parse_failed);
759       break;
760     case wasm::WASM_EXTERNAL_MEMORY:
761     case wasm::WASM_EXTERNAL_TABLE:
762       break;
763     default:
764       return make_error<GenericBinaryError>(
765           "Unexpected export kind", object_error::parse_failed);
766     }
767     Exports.push_back(Ex);
768   }
769   if (Ptr != End)
770     return make_error<GenericBinaryError>("Export section ended prematurely",
771                                           object_error::parse_failed);
772   return Error::success();
773 }
774 
775 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
776   return Index < NumImportedFunctions + FunctionTypes.size();
777 }
778 
779 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
780   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
781 }
782 
783 bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
784   return Index < NumImportedGlobals + Globals.size();
785 }
786 
787 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
788   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
789 }
790 
791 bool WasmObjectFile::isValidFunctionSymbolIndex(uint32_t Index) const {
792   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
793 }
794 
795 wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
796   assert(isDefinedFunctionIndex(Index));
797   return Functions[Index - NumImportedFunctions];
798 }
799 
800 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
801   assert(isDefinedGlobalIndex(Index));
802   return Globals[Index - NumImportedGlobals];
803 }
804 
805 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
806   StartFunction = readVaruint32(Ptr);
807   if (!isValidFunctionIndex(StartFunction))
808     return make_error<GenericBinaryError>("Invalid start function",
809                                           object_error::parse_failed);
810   return Error::success();
811 }
812 
813 Error WasmObjectFile::parseCodeSection(const uint8_t *Ptr, const uint8_t *End) {
814   CodeSection = Sections.size();
815   const uint8_t *CodeSectionStart = Ptr;
816   uint32_t FunctionCount = readVaruint32(Ptr);
817   if (FunctionCount != FunctionTypes.size()) {
818     return make_error<GenericBinaryError>("Invalid function count",
819                                           object_error::parse_failed);
820   }
821 
822   while (FunctionCount--) {
823     wasm::WasmFunction Function;
824     const uint8_t *FunctionStart = Ptr;
825     uint32_t Size = readVaruint32(Ptr);
826     const uint8_t *FunctionEnd = Ptr + Size;
827 
828     Function.Index = NumImportedFunctions + Functions.size();
829     Function.CodeSectionOffset = FunctionStart - CodeSectionStart;
830     Function.Size = FunctionEnd - FunctionStart;
831 
832     uint32_t NumLocalDecls = readVaruint32(Ptr);
833     Function.Locals.reserve(NumLocalDecls);
834     while (NumLocalDecls--) {
835       wasm::WasmLocalDecl Decl;
836       Decl.Count = readVaruint32(Ptr);
837       Decl.Type = readVarint7(Ptr);
838       Function.Locals.push_back(Decl);
839     }
840 
841     uint32_t BodySize = FunctionEnd - Ptr;
842     Function.Body = ArrayRef<uint8_t>(Ptr, BodySize);
843     Ptr += BodySize;
844     assert(Ptr == FunctionEnd);
845     Functions.push_back(Function);
846   }
847   if (Ptr != End)
848     return make_error<GenericBinaryError>("Code section ended prematurely",
849                                           object_error::parse_failed);
850   return Error::success();
851 }
852 
853 Error WasmObjectFile::parseElemSection(const uint8_t *Ptr, const uint8_t *End) {
854   uint32_t Count = readVaruint32(Ptr);
855   ElemSegments.reserve(Count);
856   while (Count--) {
857     wasm::WasmElemSegment Segment;
858     Segment.TableIndex = readVaruint32(Ptr);
859     if (Segment.TableIndex != 0) {
860       return make_error<GenericBinaryError>("Invalid TableIndex",
861                                             object_error::parse_failed);
862     }
863     if (Error Err = readInitExpr(Segment.Offset, Ptr))
864       return Err;
865     uint32_t NumElems = readVaruint32(Ptr);
866     while (NumElems--) {
867       Segment.Functions.push_back(readVaruint32(Ptr));
868     }
869     ElemSegments.push_back(Segment);
870   }
871   if (Ptr != End)
872     return make_error<GenericBinaryError>("Elem section ended prematurely",
873                                           object_error::parse_failed);
874   return Error::success();
875 }
876 
877 Error WasmObjectFile::parseDataSection(const uint8_t *Ptr, const uint8_t *End) {
878   DataSection = Sections.size();
879   const uint8_t *Start = Ptr;
880   uint32_t Count = readVaruint32(Ptr);
881   DataSegments.reserve(Count);
882   while (Count--) {
883     WasmSegment Segment;
884     Segment.Data.MemoryIndex = readVaruint32(Ptr);
885     if (Error Err = readInitExpr(Segment.Data.Offset, Ptr))
886       return Err;
887     uint32_t Size = readVaruint32(Ptr);
888     Segment.Data.Content = ArrayRef<uint8_t>(Ptr, Size);
889     Segment.Data.Alignment = 0;
890     Segment.Data.Flags = 0;
891     Segment.SectionOffset = Ptr - Start;
892     Ptr += Size;
893     DataSegments.push_back(Segment);
894   }
895   if (Ptr != End)
896     return make_error<GenericBinaryError>("Data section ended prematurely",
897                                           object_error::parse_failed);
898   return Error::success();
899 }
900 
901 const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
902   return reinterpret_cast<const uint8_t *>(getData().substr(Offset, 1).data());
903 }
904 
905 const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
906   return Header;
907 }
908 
909 void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.a++; }
910 
911 uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
912   uint32_t Result = SymbolRef::SF_None;
913   const WasmSymbol &Sym = getWasmSymbol(Symb);
914 
915   DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
916   if (Sym.isBindingWeak())
917     Result |= SymbolRef::SF_Weak;
918   if (!Sym.isBindingLocal())
919     Result |= SymbolRef::SF_Global;
920   if (Sym.isHidden())
921     Result |= SymbolRef::SF_Hidden;
922   if (!Sym.isDefined())
923     Result |= SymbolRef::SF_Undefined;
924   if (Sym.isTypeFunction())
925     Result |= SymbolRef::SF_Executable;
926   return Result;
927 }
928 
929 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
930   DataRefImpl Ref;
931   Ref.d.a = 0;
932   return BasicSymbolRef(Ref, this);
933 }
934 
935 basic_symbol_iterator WasmObjectFile::symbol_end() const {
936   DataRefImpl Ref;
937   Ref.d.a = Symbols.size();
938   return BasicSymbolRef(Ref, this);
939 }
940 
941 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
942   return Symbols[Symb.d.a];
943 }
944 
945 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
946   return getWasmSymbol(Symb.getRawDataRefImpl());
947 }
948 
949 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
950   return getWasmSymbol(Symb).Info.Name;
951 }
952 
953 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
954   return getSymbolValue(Symb);
955 }
956 
957 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
958   switch (Sym.Info.Kind) {
959   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
960   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
961     return Sym.Info.ElementIndex;
962   case wasm::WASM_SYMBOL_TYPE_DATA: {
963     // The value of a data symbol is the segment offset, plus the symbol
964     // offset within the segment.
965     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
966     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
967     assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST);
968     return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
969   }
970   }
971   llvm_unreachable("invalid symbol type");
972 }
973 
974 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
975   return getWasmSymbolValue(getWasmSymbol(Symb));
976 }
977 
978 uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
979   llvm_unreachable("not yet implemented");
980   return 0;
981 }
982 
983 uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
984   llvm_unreachable("not yet implemented");
985   return 0;
986 }
987 
988 Expected<SymbolRef::Type>
989 WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
990   const WasmSymbol &Sym = getWasmSymbol(Symb);
991 
992   switch (Sym.Info.Kind) {
993   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
994     return SymbolRef::ST_Function;
995   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
996     return SymbolRef::ST_Other;
997   case wasm::WASM_SYMBOL_TYPE_DATA:
998     return SymbolRef::ST_Data;
999   }
1000 
1001   llvm_unreachable("Unknown WasmSymbol::SymbolType");
1002   return SymbolRef::ST_Other;
1003 }
1004 
1005 Expected<section_iterator>
1006 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1007   const WasmSymbol& Sym = getWasmSymbol(Symb);
1008   if (Sym.isUndefined())
1009     return section_end();
1010 
1011   DataRefImpl Ref;
1012   switch (Sym.Info.Kind) {
1013   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1014     Ref.d.a = CodeSection;
1015     break;
1016   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1017     Ref.d.a = GlobalSection;
1018     break;
1019   case wasm::WASM_SYMBOL_TYPE_DATA:
1020     Ref.d.a = DataSection;
1021     break;
1022   default:
1023     llvm_unreachable("Unknown WasmSymbol::SymbolType");
1024   }
1025   return section_iterator(SectionRef(Ref, this));
1026 }
1027 
1028 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
1029 
1030 std::error_code WasmObjectFile::getSectionName(DataRefImpl Sec,
1031                                                StringRef &Res) const {
1032   const WasmSection &S = Sections[Sec.d.a];
1033 #define ECase(X)                                                               \
1034   case wasm::WASM_SEC_##X:                                                     \
1035     Res = #X;                                                                  \
1036     break
1037   switch (S.Type) {
1038     ECase(TYPE);
1039     ECase(IMPORT);
1040     ECase(FUNCTION);
1041     ECase(TABLE);
1042     ECase(MEMORY);
1043     ECase(GLOBAL);
1044     ECase(EXPORT);
1045     ECase(START);
1046     ECase(ELEM);
1047     ECase(CODE);
1048     ECase(DATA);
1049   case wasm::WASM_SEC_CUSTOM:
1050     Res = S.Name;
1051     break;
1052   default:
1053     return object_error::invalid_section_index;
1054   }
1055 #undef ECase
1056   return std::error_code();
1057 }
1058 
1059 uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
1060 
1061 uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
1062   return Sec.d.a;
1063 }
1064 
1065 uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
1066   const WasmSection &S = Sections[Sec.d.a];
1067   return S.Content.size();
1068 }
1069 
1070 std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
1071                                                    StringRef &Res) const {
1072   const WasmSection &S = Sections[Sec.d.a];
1073   // This will never fail since wasm sections can never be empty (user-sections
1074   // must have a name and non-user sections each have a defined structure).
1075   Res = StringRef(reinterpret_cast<const char *>(S.Content.data()),
1076                   S.Content.size());
1077   return std::error_code();
1078 }
1079 
1080 uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1081   return 1;
1082 }
1083 
1084 bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
1085   return false;
1086 }
1087 
1088 bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
1089   return getWasmSection(Sec).Type == wasm::WASM_SEC_CODE;
1090 }
1091 
1092 bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
1093   return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
1094 }
1095 
1096 bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
1097 
1098 bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
1099 
1100 bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const { return false; }
1101 
1102 relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
1103   DataRefImpl RelocRef;
1104   RelocRef.d.a = Ref.d.a;
1105   RelocRef.d.b = 0;
1106   return relocation_iterator(RelocationRef(RelocRef, this));
1107 }
1108 
1109 relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
1110   const WasmSection &Sec = getWasmSection(Ref);
1111   DataRefImpl RelocRef;
1112   RelocRef.d.a = Ref.d.a;
1113   RelocRef.d.b = Sec.Relocations.size();
1114   return relocation_iterator(RelocationRef(RelocRef, this));
1115 }
1116 
1117 void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
1118   Rel.d.b++;
1119 }
1120 
1121 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
1122   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1123   return Rel.Offset;
1124 }
1125 
1126 symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
1127   llvm_unreachable("not yet implemented");
1128   SymbolRef Ref;
1129   return symbol_iterator(Ref);
1130 }
1131 
1132 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
1133   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1134   return Rel.Type;
1135 }
1136 
1137 void WasmObjectFile::getRelocationTypeName(
1138     DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
1139   const wasm::WasmRelocation& Rel = getWasmRelocation(Ref);
1140   StringRef Res = "Unknown";
1141 
1142 #define WASM_RELOC(name, value)  \
1143   case wasm::name:              \
1144     Res = #name;               \
1145     break;
1146 
1147   switch (Rel.Type) {
1148 #include "llvm/BinaryFormat/WasmRelocs.def"
1149   }
1150 
1151 #undef WASM_RELOC
1152 
1153   Result.append(Res.begin(), Res.end());
1154 }
1155 
1156 section_iterator WasmObjectFile::section_begin() const {
1157   DataRefImpl Ref;
1158   Ref.d.a = 0;
1159   return section_iterator(SectionRef(Ref, this));
1160 }
1161 
1162 section_iterator WasmObjectFile::section_end() const {
1163   DataRefImpl Ref;
1164   Ref.d.a = Sections.size();
1165   return section_iterator(SectionRef(Ref, this));
1166 }
1167 
1168 uint8_t WasmObjectFile::getBytesInAddress() const { return 4; }
1169 
1170 StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
1171 
1172 Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
1173 
1174 SubtargetFeatures WasmObjectFile::getFeatures() const {
1175   return SubtargetFeatures();
1176 }
1177 
1178 bool WasmObjectFile::isRelocatableObject() const {
1179   return HasLinkingSection;
1180 }
1181 
1182 const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
1183   assert(Ref.d.a < Sections.size());
1184   return Sections[Ref.d.a];
1185 }
1186 
1187 const WasmSection &
1188 WasmObjectFile::getWasmSection(const SectionRef &Section) const {
1189   return getWasmSection(Section.getRawDataRefImpl());
1190 }
1191 
1192 const wasm::WasmRelocation &
1193 WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
1194   return getWasmRelocation(Ref.getRawDataRefImpl());
1195 }
1196 
1197 const wasm::WasmRelocation &
1198 WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
1199   assert(Ref.d.a < Sections.size());
1200   const WasmSection& Sec = Sections[Ref.d.a];
1201   assert(Ref.d.b < Sec.Relocations.size());
1202   return Sec.Relocations[Ref.d.b];
1203 }
1204