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