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