lib/Object/WasmObjectFile.cpp

   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       Info.ElementIndex = readVaruint32(Ptr);
 470       // Use somewhat unique section name as symbol name.
 471       StringRef SectionName = Sections[Info.ElementIndex].Name;
 472       Info.Name = SectionName;
 473       break;
 474     }
 475
 476     default:
 477       return make_error<GenericBinaryError>("Invalid symbol type",
 478                                             object_error::parse_failed);
 479     }
 480
 481     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
 482             wasm::WASM_SYMBOL_BINDING_LOCAL &&
 483         !SymbolNames.insert(Info.Name).second)
 484       return make_error<GenericBinaryError>("Duplicate symbol name " +
 485                                                 Twine(Info.Name),
 486                                             object_error::parse_failed);
 487     LinkingData.SymbolTable.emplace_back(Info);
 488     Symbols.emplace_back(LinkingData.SymbolTable.back(), FunctionType,
 489                          GlobalType);
 490     DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
 491   }
 492
 493   return Error::success();
 494 }
 495
 496 Error WasmObjectFile::parseLinkingSectionComdat(const uint8_t *&Ptr,
 497                                                 const uint8_t *End)
 498 {
 499   uint32_t ComdatCount = readVaruint32(Ptr);
 500   StringSet<> ComdatSet;
 501   for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
 502     StringRef Name = readString(Ptr);
 503     if (Name.empty() || !ComdatSet.insert(Name).second)
 504       return make_error<GenericBinaryError>("Bad/duplicate COMDAT name " + Twine(Name),
 505                                             object_error::parse_failed);
 506     LinkingData.Comdats.emplace_back(Name);
 507     uint32_t Flags = readVaruint32(Ptr);
 508     if (Flags != 0)
 509       return make_error<GenericBinaryError>("Unsupported COMDAT flags",
 510                                             object_error::parse_failed);
 511
 512     uint32_t EntryCount = readVaruint32(Ptr);
 513     while (EntryCount--) {
 514       unsigned Kind = readVaruint32(Ptr);
 515       unsigned Index = readVaruint32(Ptr);
 516       switch (Kind) {
 517       default:
 518         return make_error<GenericBinaryError>("Invalid COMDAT entry type",
 519                                               object_error::parse_failed);
 520       case wasm::WASM_COMDAT_DATA:
 521         if (Index >= DataSegments.size())
 522           return make_error<GenericBinaryError>("COMDAT data index out of range",
 523                                                 object_error::parse_failed);
 524         if (DataSegments[Index].Data.Comdat != UINT32_MAX)
 525           return make_error<GenericBinaryError>("Data segment in two COMDATs",
 526                                                 object_error::parse_failed);
 527         DataSegments[Index].Data.Comdat = ComdatIndex;
 528         break;
 529       case wasm::WASM_COMDAT_FUNCTION:
 530         if (!isDefinedFunctionIndex(Index))
 531           return make_error<GenericBinaryError>("COMDAT function index out of range",
 532                                                 object_error::parse_failed);
 533         if (getDefinedFunction(Index).Comdat != UINT32_MAX)
 534           return make_error<GenericBinaryError>("Function in two COMDATs",
 535                                                 object_error::parse_failed);
 536         getDefinedFunction(Index).Comdat = ComdatIndex;
 537         break;
 538       }
 539     }
 540   }
 541   return Error::success();
 542 }
 543
 544 Error WasmObjectFile::parseRelocSection(StringRef Name, const uint8_t *Ptr,
 545                                         const uint8_t *End) {
 546   uint32_t SectionIndex = readVaruint32(Ptr);
 547   if (SectionIndex >= Sections.size())
 548     return make_error<GenericBinaryError>("Invalid section index",
 549                                           object_error::parse_failed);
 550   WasmSection& Section = Sections[SectionIndex];
 551   uint32_t RelocCount = readVaruint32(Ptr);
 552   uint32_t EndOffset = Section.Content.size();
 553   while (RelocCount--) {
 554     wasm::WasmRelocation Reloc = {};
 555     Reloc.Type = readVaruint32(Ptr);
 556     Reloc.Offset = readVaruint32(Ptr);
 557     Reloc.Index = readVaruint32(Ptr);
 558     switch (Reloc.Type) {
 559     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
 560     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
 561     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
 562       if (!isValidFunctionSymbol(Reloc.Index))
 563         return make_error<GenericBinaryError>("Bad relocation function index",
 564                                               object_error::parse_failed);
 565       break;
 566     case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
 567       if (Reloc.Index >= Signatures.size())
 568         return make_error<GenericBinaryError>("Bad relocation type index",
 569                                               object_error::parse_failed);
 570       break;
 571     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
 572       if (!isValidGlobalSymbol(Reloc.Index))
 573         return make_error<GenericBinaryError>("Bad relocation global index",
 574                                               object_error::parse_failed);
 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       if (!isValidDataSymbol(Reloc.Index))
 580         return make_error<GenericBinaryError>("Bad relocation data index",
 581                                               object_error::parse_failed);
 582       Reloc.Addend = readVarint32(Ptr);
 583       break;
 584     case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
 585       if (!isValidFunctionSymbol(Reloc.Index))
 586         return make_error<GenericBinaryError>("Bad relocation function index",
 587                                               object_error::parse_failed);
 588       Reloc.Addend = readVarint32(Ptr);
 589       break;
 590     case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
 591       if (!isValidSectionSymbol(Reloc.Index))
 592         return make_error<GenericBinaryError>("Bad relocation section index",
 593                                               object_error::parse_failed);
 594       Reloc.Addend = readVarint32(Ptr);
 595       break;
 596     default:
 597       return make_error<GenericBinaryError>("Bad relocation type: " +
 598                                                 Twine(Reloc.Type),
 599                                             object_error::parse_failed);
 600     }
 601
 602     // Relocations must fit inside the section, and must appear in order.  They
 603     // also shouldn't overlap a function/element boundary, but we don't bother
 604     // to check that.
 605     uint64_t Size = 5;
 606     if (Reloc.Type == wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 ||
 607         Reloc.Type == wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32 ||
 608         Reloc.Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32 ||
 609         Reloc.Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32)
 610       Size = 4;
 611     if (Reloc.Offset + Size > EndOffset)
 612       return make_error<GenericBinaryError>("Bad relocation offset",
 613                                             object_error::parse_failed);
 614
 615     Section.Relocations.push_back(Reloc);
 616   }
 617   if (Ptr != End)
 618     return make_error<GenericBinaryError>("Reloc section ended prematurely",
 619                                           object_error::parse_failed);
 620   return Error::success();
 621 }
 622
 623 Error WasmObjectFile::parseCustomSection(WasmSection &Sec,
 624                                          const uint8_t *Ptr, const uint8_t *End) {
 625   if (Sec.Name == "name") {
 626     if (Error Err = parseNameSection(Ptr, End))
 627       return Err;
 628   } else if (Sec.Name == "linking") {
 629     if (Error Err = parseLinkingSection(Ptr, End))
 630       return Err;
 631   } else if (Sec.Name.startswith("reloc.")) {
 632     if (Error Err = parseRelocSection(Sec.Name, Ptr, End))
 633       return Err;
 634   }
 635   return Error::success();
 636 }
 637
 638 Error WasmObjectFile::parseTypeSection(const uint8_t *Ptr, const uint8_t *End) {
 639   uint32_t Count = readVaruint32(Ptr);
 640   Signatures.reserve(Count);
 641   while (Count--) {
 642     wasm::WasmSignature Sig;
 643     Sig.ReturnType = wasm::WASM_TYPE_NORESULT;
 644     uint8_t Form = readUint8(Ptr);
 645     if (Form != wasm::WASM_TYPE_FUNC) {
 646       return make_error<GenericBinaryError>("Invalid signature type",
 647                                             object_error::parse_failed);
 648     }
 649     uint32_t ParamCount = readVaruint32(Ptr);
 650     Sig.ParamTypes.reserve(ParamCount);
 651     while (ParamCount--) {
 652       uint32_t ParamType = readUint8(Ptr);
 653       Sig.ParamTypes.push_back(ParamType);
 654     }
 655     uint32_t ReturnCount = readVaruint32(Ptr);
 656     if (ReturnCount) {
 657       if (ReturnCount != 1) {
 658         return make_error<GenericBinaryError>(
 659             "Multiple return types not supported", object_error::parse_failed);
 660       }
 661       Sig.ReturnType = readUint8(Ptr);
 662     }
 663     Signatures.push_back(Sig);
 664   }
 665   if (Ptr != End)
 666     return make_error<GenericBinaryError>("Type section ended prematurely",
 667                                           object_error::parse_failed);
 668   return Error::success();
 669 }
 670
 671 Error WasmObjectFile::parseImportSection(const uint8_t *Ptr, const uint8_t *End) {
 672   uint32_t Count = readVaruint32(Ptr);
 673   Imports.reserve(Count);
 674   for (uint32_t i = 0; i < Count; i++) {
 675     wasm::WasmImport Im;
 676     Im.Module = readString(Ptr);
 677     Im.Field = readString(Ptr);
 678     Im.Kind = readUint8(Ptr);
 679     switch (Im.Kind) {
 680     case wasm::WASM_EXTERNAL_FUNCTION:
 681       NumImportedFunctions++;
 682       Im.SigIndex = readVaruint32(Ptr);
 683       break;
 684     case wasm::WASM_EXTERNAL_GLOBAL:
 685       NumImportedGlobals++;
 686       Im.Global.Type = readUint8(Ptr);
 687       Im.Global.Mutable = readVaruint1(Ptr);
 688       break;
 689     case wasm::WASM_EXTERNAL_MEMORY:
 690       Im.Memory = readLimits(Ptr);
 691       break;
 692     case wasm::WASM_EXTERNAL_TABLE:
 693       Im.Table = readTable(Ptr);
 694       if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC)
 695         return make_error<GenericBinaryError>("Invalid table element type",
 696                                               object_error::parse_failed);
 697       break;
 698     default:
 699       return make_error<GenericBinaryError>(
 700           "Unexpected import kind", object_error::parse_failed);
 701     }
 702     Imports.push_back(Im);
 703   }
 704   if (Ptr != End)
 705     return make_error<GenericBinaryError>("Import section ended prematurely",
 706                                           object_error::parse_failed);
 707   return Error::success();
 708 }
 709
 710 Error WasmObjectFile::parseFunctionSection(const uint8_t *Ptr, const uint8_t *End) {
 711   uint32_t Count = readVaruint32(Ptr);
 712   FunctionTypes.reserve(Count);
 713   uint32_t NumTypes = Signatures.size();
 714   while (Count--) {
 715     uint32_t Type = readVaruint32(Ptr);
 716     if (Type >= NumTypes)
 717       return make_error<GenericBinaryError>("Invalid function type",
 718                                             object_error::parse_failed);
 719     FunctionTypes.push_back(Type);
 720   }
 721   if (Ptr != End)
 722     return make_error<GenericBinaryError>("Function section ended prematurely",
 723                                           object_error::parse_failed);
 724   return Error::success();
 725 }
 726
 727 Error WasmObjectFile::parseTableSection(const uint8_t *Ptr, const uint8_t *End) {
 728   uint32_t Count = readVaruint32(Ptr);
 729   Tables.reserve(Count);
 730   while (Count--) {
 731     Tables.push_back(readTable(Ptr));
 732     if (Tables.back().ElemType != wasm::WASM_TYPE_ANYFUNC) {
 733       return make_error<GenericBinaryError>("Invalid table element type",
 734                                             object_error::parse_failed);
 735     }
 736   }
 737   if (Ptr != End)
 738     return make_error<GenericBinaryError>("Table section ended prematurely",
 739                                           object_error::parse_failed);
 740   return Error::success();
 741 }
 742
 743 Error WasmObjectFile::parseMemorySection(const uint8_t *Ptr, const uint8_t *End) {
 744   uint32_t Count = readVaruint32(Ptr);
 745   Memories.reserve(Count);
 746   while (Count--) {
 747     Memories.push_back(readLimits(Ptr));
 748   }
 749   if (Ptr != End)
 750     return make_error<GenericBinaryError>("Memory section ended prematurely",
 751                                           object_error::parse_failed);
 752   return Error::success();
 753 }
 754
 755 Error WasmObjectFile::parseGlobalSection(const uint8_t *Ptr, const uint8_t *End) {
 756   GlobalSection = Sections.size();
 757   uint32_t Count = readVaruint32(Ptr);
 758   Globals.reserve(Count);
 759   while (Count--) {
 760     wasm::WasmGlobal Global;
 761     Global.Index = NumImportedGlobals + Globals.size();
 762     Global.Type.Type = readUint8(Ptr);
 763     Global.Type.Mutable = readVaruint1(Ptr);
 764     if (Error Err = readInitExpr(Global.InitExpr, Ptr))
 765       return Err;
 766     Globals.push_back(Global);
 767   }
 768   if (Ptr != End)
 769     return make_error<GenericBinaryError>("Global section ended prematurely",
 770                                           object_error::parse_failed);
 771   return Error::success();
 772 }
 773
 774 Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
 775   uint32_t Count = readVaruint32(Ptr);
 776   Exports.reserve(Count);
 777   for (uint32_t i = 0; i < Count; i++) {
 778     wasm::WasmExport Ex;
 779     Ex.Name = readString(Ptr);
 780     Ex.Kind = readUint8(Ptr);
 781     Ex.Index = readVaruint32(Ptr);
 782     switch (Ex.Kind) {
 783     case wasm::WASM_EXTERNAL_FUNCTION:
 784       if (!isValidFunctionIndex(Ex.Index))
 785         return make_error<GenericBinaryError>("Invalid function export",
 786                                               object_error::parse_failed);
 787       break;
 788     case wasm::WASM_EXTERNAL_GLOBAL:
 789       if (!isValidGlobalIndex(Ex.Index))
 790         return make_error<GenericBinaryError>("Invalid global export",
 791                                               object_error::parse_failed);
 792       break;
 793     case wasm::WASM_EXTERNAL_MEMORY:
 794     case wasm::WASM_EXTERNAL_TABLE:
 795       break;
 796     default:
 797       return make_error<GenericBinaryError>(
 798           "Unexpected export kind", object_error::parse_failed);
 799     }
 800     Exports.push_back(Ex);
 801   }
 802   if (Ptr != End)
 803     return make_error<GenericBinaryError>("Export section ended prematurely",
 804                                           object_error::parse_failed);
 805   return Error::success();
 806 }
 807
 808 bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
 809   return Index < NumImportedFunctions + FunctionTypes.size();
 810 }
 811
 812 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
 813   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
 814 }
 815
 816 bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
 817   return Index < NumImportedGlobals + Globals.size();
 818 }
 819
 820 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
 821   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
 822 }
 823
 824 bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
 825   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
 826 }
 827
 828 bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
 829   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
 830 }
 831
 832 bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
 833   return Index < Symbols.size() && Symbols[Index].isTypeData();
 834 }
 835
 836 bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
 837   return Index < Symbols.size() && Symbols[Index].isTypeSection();
 838 }
 839
 840 wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
 841   assert(isDefinedFunctionIndex(Index));
 842   return Functions[Index - NumImportedFunctions];
 843 }
 844
 845 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
 846   assert(isDefinedGlobalIndex(Index));
 847   return Globals[Index - NumImportedGlobals];
 848 }
 849
 850 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
 851   StartFunction = readVaruint32(Ptr);
 852   if (!isValidFunctionIndex(StartFunction))
 853     return make_error<GenericBinaryError>("Invalid start function",
 854                                           object_error::parse_failed);
 855   return Error::success();
 856 }
 857
 858 Error WasmObjectFile::parseCodeSection(const uint8_t *Ptr, const uint8_t *End) {
 859   CodeSection = Sections.size();
 860   const uint8_t *CodeSectionStart = Ptr;
 861   uint32_t FunctionCount = readVaruint32(Ptr);
 862   if (FunctionCount != FunctionTypes.size()) {
 863     return make_error<GenericBinaryError>("Invalid function count",
 864                                           object_error::parse_failed);
 865   }
 866
 867   while (FunctionCount--) {
 868     wasm::WasmFunction Function;
 869     const uint8_t *FunctionStart = Ptr;
 870     uint32_t Size = readVaruint32(Ptr);
 871     const uint8_t *FunctionEnd = Ptr + Size;
 872
 873     Function.Index = NumImportedFunctions + Functions.size();
 874     Function.CodeSectionOffset = FunctionStart - CodeSectionStart;
 875     Function.Size = FunctionEnd - FunctionStart;
 876
 877     uint32_t NumLocalDecls = readVaruint32(Ptr);
 878     Function.Locals.reserve(NumLocalDecls);
 879     while (NumLocalDecls--) {
 880       wasm::WasmLocalDecl Decl;
 881       Decl.Count = readVaruint32(Ptr);
 882       Decl.Type = readUint8(Ptr);
 883       Function.Locals.push_back(Decl);
 884     }
 885
 886     uint32_t BodySize = FunctionEnd - Ptr;
 887     Function.Body = ArrayRef<uint8_t>(Ptr, BodySize);
 888     // This will be set later when reading in the linking metadata section.
 889     Function.Comdat = UINT32_MAX;
 890     Ptr += BodySize;
 891     assert(Ptr == FunctionEnd);
 892     Functions.push_back(Function);
 893   }
 894   if (Ptr != End)
 895     return make_error<GenericBinaryError>("Code section ended prematurely",
 896                                           object_error::parse_failed);
 897   return Error::success();
 898 }
 899
 900 Error WasmObjectFile::parseElemSection(const uint8_t *Ptr, const uint8_t *End) {
 901   uint32_t Count = readVaruint32(Ptr);
 902   ElemSegments.reserve(Count);
 903   while (Count--) {
 904     wasm::WasmElemSegment Segment;
 905     Segment.TableIndex = readVaruint32(Ptr);
 906     if (Segment.TableIndex != 0) {
 907       return make_error<GenericBinaryError>("Invalid TableIndex",
 908                                             object_error::parse_failed);
 909     }
 910     if (Error Err = readInitExpr(Segment.Offset, Ptr))
 911       return Err;
 912     uint32_t NumElems = readVaruint32(Ptr);
 913     while (NumElems--) {
 914       Segment.Functions.push_back(readVaruint32(Ptr));
 915     }
 916     ElemSegments.push_back(Segment);
 917   }
 918   if (Ptr != End)
 919     return make_error<GenericBinaryError>("Elem section ended prematurely",
 920                                           object_error::parse_failed);
 921   return Error::success();
 922 }
 923
 924 Error WasmObjectFile::parseDataSection(const uint8_t *Ptr, const uint8_t *End) {
 925   DataSection = Sections.size();
 926   const uint8_t *Start = Ptr;
 927   uint32_t Count = readVaruint32(Ptr);
 928   DataSegments.reserve(Count);
 929   while (Count--) {
 930     WasmSegment Segment;
 931     Segment.Data.MemoryIndex = readVaruint32(Ptr);
 932     if (Error Err = readInitExpr(Segment.Data.Offset, Ptr))
 933       return Err;
 934     uint32_t Size = readVaruint32(Ptr);
 935     Segment.Data.Content = ArrayRef<uint8_t>(Ptr, Size);
 936     // The rest of these Data fields are set later, when reading in the linking
 937     // metadata section.
 938     Segment.Data.Alignment = 0;
 939     Segment.Data.Flags = 0;
 940     Segment.Data.Comdat = UINT32_MAX;
 941     Segment.SectionOffset = Ptr - Start;
 942     Ptr += Size;
 943     DataSegments.push_back(Segment);
 944   }
 945   if (Ptr != End)
 946     return make_error<GenericBinaryError>("Data section ended prematurely",
 947                                           object_error::parse_failed);
 948   return Error::success();
 949 }
 950
 951 const uint8_t *WasmObjectFile::getPtr(size_t Offset) const {
 952   return reinterpret_cast<const uint8_t *>(getData().substr(Offset, 1).data());
 953 }
 954
 955 const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
 956   return Header;
 957 }
 958
 959 void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.a++; }
 960
 961 uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
 962   uint32_t Result = SymbolRef::SF_None;
 963   const WasmSymbol &Sym = getWasmSymbol(Symb);
 964
 965   DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
 966   if (Sym.isBindingWeak())
 967     Result |= SymbolRef::SF_Weak;
 968   if (!Sym.isBindingLocal())
 969     Result |= SymbolRef::SF_Global;
 970   if (Sym.isHidden())
 971     Result |= SymbolRef::SF_Hidden;
 972   if (!Sym.isDefined())
 973     Result |= SymbolRef::SF_Undefined;
 974   if (Sym.isTypeFunction())
 975     Result |= SymbolRef::SF_Executable;
 976   return Result;
 977 }
 978
 979 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
 980   DataRefImpl Ref;
 981   Ref.d.a = 0;
 982   return BasicSymbolRef(Ref, this);
 983 }
 984
 985 basic_symbol_iterator WasmObjectFile::symbol_end() const {
 986   DataRefImpl Ref;
 987   Ref.d.a = Symbols.size();
 988   return BasicSymbolRef(Ref, this);
 989 }
 990
 991 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
 992   return Symbols[Symb.d.a];
 993 }
 994
 995 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
 996   return getWasmSymbol(Symb.getRawDataRefImpl());
 997 }
 998
 999 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
1000   return getWasmSymbol(Symb).Info.Name;
1001 }
1002
1003 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
1004   return getSymbolValue(Symb);
1005 }
1006
1007 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
1008   switch (Sym.Info.Kind) {
1009   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1010   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1011     return Sym.Info.ElementIndex;
1012   case wasm::WASM_SYMBOL_TYPE_DATA: {
1013     // The value of a data symbol is the segment offset, plus the symbol
1014     // offset within the segment.
1015     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
1016     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
1017     assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST);
1018     return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
1019   }
1020   case wasm::WASM_SYMBOL_TYPE_SECTION:
1021     return 0;
1022   }
1023   llvm_unreachable("invalid symbol type");
1024 }
1025
1026 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
1027   return getWasmSymbolValue(getWasmSymbol(Symb));
1028 }
1029
1030 uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
1031   llvm_unreachable("not yet implemented");
1032   return 0;
1033 }
1034
1035 uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
1036   llvm_unreachable("not yet implemented");
1037   return 0;
1038 }
1039
1040 Expected<SymbolRef::Type>
1041 WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
1042   const WasmSymbol &Sym = getWasmSymbol(Symb);
1043
1044   switch (Sym.Info.Kind) {
1045   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1046     return SymbolRef::ST_Function;
1047   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1048     return SymbolRef::ST_Other;
1049   case wasm::WASM_SYMBOL_TYPE_DATA:
1050     return SymbolRef::ST_Data;
1051   case wasm::WASM_SYMBOL_TYPE_SECTION:
1052     return SymbolRef::ST_Debug;
1053   }
1054
1055   llvm_unreachable("Unknown WasmSymbol::SymbolType");
1056   return SymbolRef::ST_Other;
1057 }
1058
1059 Expected<section_iterator>
1060 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1061   const WasmSymbol& Sym = getWasmSymbol(Symb);
1062   if (Sym.isUndefined())
1063     return section_end();
1064
1065   DataRefImpl Ref;
1066   switch (Sym.Info.Kind) {
1067   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1068     Ref.d.a = CodeSection;
1069     break;
1070   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1071     Ref.d.a = GlobalSection;
1072     break;
1073   case wasm::WASM_SYMBOL_TYPE_DATA:
1074     Ref.d.a = DataSection;
1075     break;
1076   case wasm::WASM_SYMBOL_TYPE_SECTION: {
1077     Ref.d.a = Sym.Info.ElementIndex;
1078     break;
1079   }
1080   default:
1081     llvm_unreachable("Unknown WasmSymbol::SymbolType");
1082   }
1083   return section_iterator(SectionRef(Ref, this));
1084 }
1085
1086 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
1087
1088 std::error_code WasmObjectFile::getSectionName(DataRefImpl Sec,
1089                                                StringRef &Res) const {
1090   const WasmSection &S = Sections[Sec.d.a];
1091 #define ECase(X)                                                               \
1092   case wasm::WASM_SEC_##X:                                                     \
1093     Res = #X;                                                                  \
1094     break
1095   switch (S.Type) {
1096     ECase(TYPE);
1097     ECase(IMPORT);
1098     ECase(FUNCTION);
1099     ECase(TABLE);
1100     ECase(MEMORY);
1101     ECase(GLOBAL);
1102     ECase(EXPORT);
1103     ECase(START);
1104     ECase(ELEM);
1105     ECase(CODE);
1106     ECase(DATA);
1107   case wasm::WASM_SEC_CUSTOM:
1108     Res = S.Name;
1109     break;
1110   default:
1111     return object_error::invalid_section_index;
1112   }
1113 #undef ECase
1114   return std::error_code();
1115 }
1116
1117 uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
1118
1119 uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
1120   return Sec.d.a;
1121 }
1122
1123 uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
1124   const WasmSection &S = Sections[Sec.d.a];
1125   return S.Content.size();
1126 }
1127
1128 std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
1129                                                    StringRef &Res) const {
1130   const WasmSection &S = Sections[Sec.d.a];
1131   // This will never fail since wasm sections can never be empty (user-sections
1132   // must have a name and non-user sections each have a defined structure).
1133   Res = StringRef(reinterpret_cast<const char *>(S.Content.data()),
1134                   S.Content.size());
1135   return std::error_code();
1136 }
1137
1138 uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1139   return 1;
1140 }
1141
1142 bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
1143   return false;
1144 }
1145
1146 bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
1147   return getWasmSection(Sec).Type == wasm::WASM_SEC_CODE;
1148 }
1149
1150 bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
1151   return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
1152 }
1153
1154 bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
1155
1156 bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
1157
1158 bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const { return false; }
1159
1160 relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
1161   DataRefImpl RelocRef;
1162   RelocRef.d.a = Ref.d.a;
1163   RelocRef.d.b = 0;
1164   return relocation_iterator(RelocationRef(RelocRef, this));
1165 }
1166
1167 relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
1168   const WasmSection &Sec = getWasmSection(Ref);
1169   DataRefImpl RelocRef;
1170   RelocRef.d.a = Ref.d.a;
1171   RelocRef.d.b = Sec.Relocations.size();
1172   return relocation_iterator(RelocationRef(RelocRef, this));
1173 }
1174
1175 void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
1176   Rel.d.b++;
1177 }
1178
1179 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
1180   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1181   return Rel.Offset;
1182 }
1183
1184 symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
1185   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1186   if (Rel.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
1187     return symbol_end();
1188   DataRefImpl Sym;
1189   Sym.d.a = Rel.Index;
1190   Sym.d.b = 0;
1191   return symbol_iterator(SymbolRef(Sym, this));
1192 }
1193
1194 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
1195   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1196   return Rel.Type;
1197 }
1198
1199 void WasmObjectFile::getRelocationTypeName(
1200     DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
1201   const wasm::WasmRelocation& Rel = getWasmRelocation(Ref);
1202   StringRef Res = "Unknown";
1203
1204 #define WASM_RELOC(name, value)  \
1205   case wasm::name:              \
1206     Res = #name;               \
1207     break;
1208
1209   switch (Rel.Type) {
1210 #include "llvm/BinaryFormat/WasmRelocs.def"
1211   }
1212
1213 #undef WASM_RELOC
1214
1215   Result.append(Res.begin(), Res.end());
1216 }
1217
1218 section_iterator WasmObjectFile::section_begin() const {
1219   DataRefImpl Ref;
1220   Ref.d.a = 0;
1221   return section_iterator(SectionRef(Ref, this));
1222 }
1223
1224 section_iterator WasmObjectFile::section_end() const {
1225   DataRefImpl Ref;
1226   Ref.d.a = Sections.size();
1227   return section_iterator(SectionRef(Ref, this));
1228 }
1229
1230 uint8_t WasmObjectFile::getBytesInAddress() const { return 4; }
1231
1232 StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
1233
1234 Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
1235
1236 SubtargetFeatures WasmObjectFile::getFeatures() const {
1237   return SubtargetFeatures();
1238 }
1239
1240 bool WasmObjectFile::isRelocatableObject() const {
1241   return HasLinkingSection;
1242 }
1243
1244 const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
1245   assert(Ref.d.a < Sections.size());
1246   return Sections[Ref.d.a];
1247 }
1248
1249 const WasmSection &
1250 WasmObjectFile::getWasmSection(const SectionRef &Section) const {
1251   return getWasmSection(Section.getRawDataRefImpl());
1252 }
1253
1254 const wasm::WasmRelocation &
1255 WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
1256   return getWasmRelocation(Ref.getRawDataRefImpl());
1257 }
1258
1259 const wasm::WasmRelocation &
1260 WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
1261   assert(Ref.d.a < Sections.size());
1262   const WasmSection& Sec = Sections[Ref.d.a];
1263   assert(Ref.d.b < Sec.Relocations.size());
1264   return Sec.Relocations[Ref.d.b];
1265 }