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