1 //===- WasmYAML.cpp - Wasm YAMLIO 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 // This file defines classes for handling the YAML representation of wasm. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ObjectYAML/WasmYAML.h" 14 #include "llvm/ADT/StringRef.h" 15 #include "llvm/Support/Casting.h" 16 #include "llvm/Support/ErrorHandling.h" 17 #include "llvm/Support/YAMLTraits.h" 18 19 namespace llvm { 20 21 namespace WasmYAML { 22 23 // Declared here rather than in the header to comply with: 24 // http://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers 25 Section::~Section() = default; 26 27 } // end namespace WasmYAML 28 29 namespace yaml { 30 31 void MappingTraits<WasmYAML::FileHeader>::mapping( 32 IO &IO, WasmYAML::FileHeader &FileHdr) { 33 IO.mapRequired("Version", FileHdr.Version); 34 } 35 36 void MappingTraits<WasmYAML::Object>::mapping(IO &IO, 37 WasmYAML::Object &Object) { 38 IO.setContext(&Object); 39 IO.mapTag("!WASM", true); 40 IO.mapRequired("FileHeader", Object.Header); 41 IO.mapOptional("Sections", Object.Sections); 42 IO.setContext(nullptr); 43 } 44 45 static void commonSectionMapping(IO &IO, WasmYAML::Section &Section) { 46 IO.mapRequired("Type", Section.Type); 47 IO.mapOptional("Relocations", Section.Relocations); 48 } 49 50 static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) { 51 commonSectionMapping(IO, Section); 52 IO.mapRequired("Name", Section.Name); 53 IO.mapRequired("MemorySize", Section.MemorySize); 54 IO.mapRequired("MemoryAlignment", Section.MemoryAlignment); 55 IO.mapRequired("TableSize", Section.TableSize); 56 IO.mapRequired("TableAlignment", Section.TableAlignment); 57 IO.mapRequired("Needed", Section.Needed); 58 } 59 60 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) { 61 commonSectionMapping(IO, Section); 62 IO.mapRequired("Name", Section.Name); 63 IO.mapOptional("FunctionNames", Section.FunctionNames); 64 } 65 66 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) { 67 commonSectionMapping(IO, Section); 68 IO.mapRequired("Name", Section.Name); 69 IO.mapRequired("Version", Section.Version); 70 IO.mapOptional("SymbolTable", Section.SymbolTable); 71 IO.mapOptional("SegmentInfo", Section.SegmentInfos); 72 IO.mapOptional("InitFunctions", Section.InitFunctions); 73 IO.mapOptional("Comdats", Section.Comdats); 74 } 75 76 static void sectionMapping(IO &IO, WasmYAML::ProducersSection &Section) { 77 commonSectionMapping(IO, Section); 78 IO.mapRequired("Name", Section.Name); 79 IO.mapOptional("Languages", Section.Languages); 80 IO.mapOptional("Tools", Section.Tools); 81 IO.mapOptional("SDKs", Section.SDKs); 82 } 83 84 static void sectionMapping(IO &IO, WasmYAML::TargetFeaturesSection &Section) { 85 commonSectionMapping(IO, Section); 86 IO.mapRequired("Name", Section.Name); 87 IO.mapRequired("Features", Section.Features); 88 } 89 90 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) { 91 commonSectionMapping(IO, Section); 92 IO.mapRequired("Name", Section.Name); 93 IO.mapRequired("Payload", Section.Payload); 94 } 95 96 static void sectionMapping(IO &IO, WasmYAML::TypeSection &Section) { 97 commonSectionMapping(IO, Section); 98 IO.mapOptional("Signatures", Section.Signatures); 99 } 100 101 static void sectionMapping(IO &IO, WasmYAML::ImportSection &Section) { 102 commonSectionMapping(IO, Section); 103 IO.mapOptional("Imports", Section.Imports); 104 } 105 106 static void sectionMapping(IO &IO, WasmYAML::FunctionSection &Section) { 107 commonSectionMapping(IO, Section); 108 IO.mapOptional("FunctionTypes", Section.FunctionTypes); 109 } 110 111 static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) { 112 commonSectionMapping(IO, Section); 113 IO.mapOptional("Tables", Section.Tables); 114 } 115 116 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) { 117 commonSectionMapping(IO, Section); 118 IO.mapOptional("Memories", Section.Memories); 119 } 120 121 static void sectionMapping(IO &IO, WasmYAML::EventSection &Section) { 122 commonSectionMapping(IO, Section); 123 IO.mapOptional("Events", Section.Events); 124 } 125 126 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) { 127 commonSectionMapping(IO, Section); 128 IO.mapOptional("Globals", Section.Globals); 129 } 130 131 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) { 132 commonSectionMapping(IO, Section); 133 IO.mapOptional("Exports", Section.Exports); 134 } 135 136 static void sectionMapping(IO &IO, WasmYAML::StartSection &Section) { 137 commonSectionMapping(IO, Section); 138 IO.mapOptional("StartFunction", Section.StartFunction); 139 } 140 141 static void sectionMapping(IO &IO, WasmYAML::ElemSection &Section) { 142 commonSectionMapping(IO, Section); 143 IO.mapOptional("Segments", Section.Segments); 144 } 145 146 static void sectionMapping(IO &IO, WasmYAML::CodeSection &Section) { 147 commonSectionMapping(IO, Section); 148 IO.mapRequired("Functions", Section.Functions); 149 } 150 151 static void sectionMapping(IO &IO, WasmYAML::DataSection &Section) { 152 commonSectionMapping(IO, Section); 153 IO.mapRequired("Segments", Section.Segments); 154 } 155 156 static void sectionMapping(IO &IO, WasmYAML::DataCountSection &Section) { 157 commonSectionMapping(IO, Section); 158 IO.mapRequired("Count", Section.Count); 159 } 160 161 void MappingTraits<std::unique_ptr<WasmYAML::Section>>::mapping( 162 IO &IO, std::unique_ptr<WasmYAML::Section> &Section) { 163 WasmYAML::SectionType SectionType; 164 if (IO.outputting()) 165 SectionType = Section->Type; 166 else 167 IO.mapRequired("Type", SectionType); 168 169 switch (SectionType) { 170 case wasm::WASM_SEC_CUSTOM: { 171 StringRef SectionName; 172 if (IO.outputting()) { 173 auto CustomSection = cast<WasmYAML::CustomSection>(Section.get()); 174 SectionName = CustomSection->Name; 175 } else { 176 IO.mapRequired("Name", SectionName); 177 } 178 if (SectionName == "dylink") { 179 if (!IO.outputting()) 180 Section.reset(new WasmYAML::DylinkSection()); 181 sectionMapping(IO, *cast<WasmYAML::DylinkSection>(Section.get())); 182 } else if (SectionName == "linking") { 183 if (!IO.outputting()) 184 Section.reset(new WasmYAML::LinkingSection()); 185 sectionMapping(IO, *cast<WasmYAML::LinkingSection>(Section.get())); 186 } else if (SectionName == "name") { 187 if (!IO.outputting()) 188 Section.reset(new WasmYAML::NameSection()); 189 sectionMapping(IO, *cast<WasmYAML::NameSection>(Section.get())); 190 } else if (SectionName == "producers") { 191 if (!IO.outputting()) 192 Section.reset(new WasmYAML::ProducersSection()); 193 sectionMapping(IO, *cast<WasmYAML::ProducersSection>(Section.get())); 194 } else if (SectionName == "target_features") { 195 if (!IO.outputting()) 196 Section.reset(new WasmYAML::TargetFeaturesSection()); 197 sectionMapping(IO, *cast<WasmYAML::TargetFeaturesSection>(Section.get())); 198 } else { 199 if (!IO.outputting()) 200 Section.reset(new WasmYAML::CustomSection(SectionName)); 201 sectionMapping(IO, *cast<WasmYAML::CustomSection>(Section.get())); 202 } 203 break; 204 } 205 case wasm::WASM_SEC_TYPE: 206 if (!IO.outputting()) 207 Section.reset(new WasmYAML::TypeSection()); 208 sectionMapping(IO, *cast<WasmYAML::TypeSection>(Section.get())); 209 break; 210 case wasm::WASM_SEC_IMPORT: 211 if (!IO.outputting()) 212 Section.reset(new WasmYAML::ImportSection()); 213 sectionMapping(IO, *cast<WasmYAML::ImportSection>(Section.get())); 214 break; 215 case wasm::WASM_SEC_FUNCTION: 216 if (!IO.outputting()) 217 Section.reset(new WasmYAML::FunctionSection()); 218 sectionMapping(IO, *cast<WasmYAML::FunctionSection>(Section.get())); 219 break; 220 case wasm::WASM_SEC_TABLE: 221 if (!IO.outputting()) 222 Section.reset(new WasmYAML::TableSection()); 223 sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get())); 224 break; 225 case wasm::WASM_SEC_MEMORY: 226 if (!IO.outputting()) 227 Section.reset(new WasmYAML::MemorySection()); 228 sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get())); 229 break; 230 case wasm::WASM_SEC_EVENT: 231 if (!IO.outputting()) 232 Section.reset(new WasmYAML::EventSection()); 233 sectionMapping(IO, *cast<WasmYAML::EventSection>(Section.get())); 234 break; 235 case wasm::WASM_SEC_GLOBAL: 236 if (!IO.outputting()) 237 Section.reset(new WasmYAML::GlobalSection()); 238 sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get())); 239 break; 240 case wasm::WASM_SEC_EXPORT: 241 if (!IO.outputting()) 242 Section.reset(new WasmYAML::ExportSection()); 243 sectionMapping(IO, *cast<WasmYAML::ExportSection>(Section.get())); 244 break; 245 case wasm::WASM_SEC_START: 246 if (!IO.outputting()) 247 Section.reset(new WasmYAML::StartSection()); 248 sectionMapping(IO, *cast<WasmYAML::StartSection>(Section.get())); 249 break; 250 case wasm::WASM_SEC_ELEM: 251 if (!IO.outputting()) 252 Section.reset(new WasmYAML::ElemSection()); 253 sectionMapping(IO, *cast<WasmYAML::ElemSection>(Section.get())); 254 break; 255 case wasm::WASM_SEC_CODE: 256 if (!IO.outputting()) 257 Section.reset(new WasmYAML::CodeSection()); 258 sectionMapping(IO, *cast<WasmYAML::CodeSection>(Section.get())); 259 break; 260 case wasm::WASM_SEC_DATA: 261 if (!IO.outputting()) 262 Section.reset(new WasmYAML::DataSection()); 263 sectionMapping(IO, *cast<WasmYAML::DataSection>(Section.get())); 264 break; 265 case wasm::WASM_SEC_DATACOUNT: 266 if (!IO.outputting()) 267 Section.reset(new WasmYAML::DataCountSection()); 268 sectionMapping(IO, *cast<WasmYAML::DataCountSection>(Section.get())); 269 break; 270 default: 271 llvm_unreachable("Unknown section type"); 272 } 273 } 274 275 void ScalarEnumerationTraits<WasmYAML::SectionType>::enumeration( 276 IO &IO, WasmYAML::SectionType &Type) { 277 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X); 278 ECase(CUSTOM); 279 ECase(TYPE); 280 ECase(IMPORT); 281 ECase(FUNCTION); 282 ECase(TABLE); 283 ECase(MEMORY); 284 ECase(GLOBAL); 285 ECase(EVENT); 286 ECase(EXPORT); 287 ECase(START); 288 ECase(ELEM); 289 ECase(CODE); 290 ECase(DATA); 291 ECase(DATACOUNT); 292 #undef ECase 293 } 294 295 void MappingTraits<WasmYAML::Signature>::mapping( 296 IO &IO, WasmYAML::Signature &Signature) { 297 IO.mapRequired("Index", Signature.Index); 298 IO.mapRequired("ParamTypes", Signature.ParamTypes); 299 IO.mapRequired("ReturnTypes", Signature.ReturnTypes); 300 } 301 302 void MappingTraits<WasmYAML::Table>::mapping(IO &IO, WasmYAML::Table &Table) { 303 IO.mapRequired("ElemType", Table.ElemType); 304 IO.mapRequired("Limits", Table.TableLimits); 305 } 306 307 void MappingTraits<WasmYAML::Function>::mapping(IO &IO, 308 WasmYAML::Function &Function) { 309 IO.mapRequired("Index", Function.Index); 310 IO.mapRequired("Locals", Function.Locals); 311 IO.mapRequired("Body", Function.Body); 312 } 313 314 void MappingTraits<WasmYAML::Relocation>::mapping( 315 IO &IO, WasmYAML::Relocation &Relocation) { 316 IO.mapRequired("Type", Relocation.Type); 317 IO.mapRequired("Index", Relocation.Index); 318 IO.mapRequired("Offset", Relocation.Offset); 319 IO.mapOptional("Addend", Relocation.Addend, 0); 320 } 321 322 void MappingTraits<WasmYAML::NameEntry>::mapping( 323 IO &IO, WasmYAML::NameEntry &NameEntry) { 324 IO.mapRequired("Index", NameEntry.Index); 325 IO.mapRequired("Name", NameEntry.Name); 326 } 327 328 void MappingTraits<WasmYAML::ProducerEntry>::mapping( 329 IO &IO, WasmYAML::ProducerEntry &ProducerEntry) { 330 IO.mapRequired("Name", ProducerEntry.Name); 331 IO.mapRequired("Version", ProducerEntry.Version); 332 } 333 334 void ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix>::enumeration( 335 IO &IO, WasmYAML::FeaturePolicyPrefix &Kind) { 336 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_FEATURE_PREFIX_##X); 337 ECase(USED); 338 ECase(REQUIRED); 339 ECase(DISALLOWED); 340 #undef ECase 341 } 342 343 void MappingTraits<WasmYAML::FeatureEntry>::mapping( 344 IO &IO, WasmYAML::FeatureEntry &FeatureEntry) { 345 IO.mapRequired("Prefix", FeatureEntry.Prefix); 346 IO.mapRequired("Name", FeatureEntry.Name); 347 } 348 349 void MappingTraits<WasmYAML::SegmentInfo>::mapping( 350 IO &IO, WasmYAML::SegmentInfo &SegmentInfo) { 351 IO.mapRequired("Index", SegmentInfo.Index); 352 IO.mapRequired("Name", SegmentInfo.Name); 353 IO.mapRequired("Alignment", SegmentInfo.Alignment); 354 IO.mapRequired("Flags", SegmentInfo.Flags); 355 } 356 357 void MappingTraits<WasmYAML::LocalDecl>::mapping( 358 IO &IO, WasmYAML::LocalDecl &LocalDecl) { 359 IO.mapRequired("Type", LocalDecl.Type); 360 IO.mapRequired("Count", LocalDecl.Count); 361 } 362 363 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO, 364 WasmYAML::Limits &Limits) { 365 if (!IO.outputting() || Limits.Flags) 366 IO.mapOptional("Flags", Limits.Flags); 367 IO.mapRequired("Initial", Limits.Initial); 368 if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) 369 IO.mapOptional("Maximum", Limits.Maximum); 370 } 371 372 void MappingTraits<WasmYAML::ElemSegment>::mapping( 373 IO &IO, WasmYAML::ElemSegment &Segment) { 374 IO.mapRequired("Offset", Segment.Offset); 375 IO.mapRequired("Functions", Segment.Functions); 376 } 377 378 void MappingTraits<WasmYAML::Import>::mapping(IO &IO, 379 WasmYAML::Import &Import) { 380 IO.mapRequired("Module", Import.Module); 381 IO.mapRequired("Field", Import.Field); 382 IO.mapRequired("Kind", Import.Kind); 383 if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) { 384 IO.mapRequired("SigIndex", Import.SigIndex); 385 } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) { 386 IO.mapRequired("GlobalType", Import.GlobalImport.Type); 387 IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable); 388 } else if (Import.Kind == wasm::WASM_EXTERNAL_EVENT) { 389 IO.mapRequired("EventAttribute", Import.EventImport.Attribute); 390 IO.mapRequired("EventSigIndex", Import.EventImport.SigIndex); 391 } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) { 392 IO.mapRequired("Table", Import.TableImport); 393 } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) { 394 IO.mapRequired("Memory", Import.Memory); 395 } else { 396 llvm_unreachable("unhandled import type"); 397 } 398 } 399 400 void MappingTraits<WasmYAML::Export>::mapping(IO &IO, 401 WasmYAML::Export &Export) { 402 IO.mapRequired("Name", Export.Name); 403 IO.mapRequired("Kind", Export.Kind); 404 IO.mapRequired("Index", Export.Index); 405 } 406 407 void MappingTraits<WasmYAML::Global>::mapping(IO &IO, 408 WasmYAML::Global &Global) { 409 IO.mapRequired("Index", Global.Index); 410 IO.mapRequired("Type", Global.Type); 411 IO.mapRequired("Mutable", Global.Mutable); 412 IO.mapRequired("InitExpr", Global.InitExpr); 413 } 414 415 void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO, 416 wasm::WasmInitExpr &Expr) { 417 WasmYAML::Opcode Op = Expr.Opcode; 418 IO.mapRequired("Opcode", Op); 419 Expr.Opcode = Op; 420 switch (Expr.Opcode) { 421 case wasm::WASM_OPCODE_I32_CONST: 422 IO.mapRequired("Value", Expr.Value.Int32); 423 break; 424 case wasm::WASM_OPCODE_I64_CONST: 425 IO.mapRequired("Value", Expr.Value.Int64); 426 break; 427 case wasm::WASM_OPCODE_F32_CONST: 428 IO.mapRequired("Value", Expr.Value.Float32); 429 break; 430 case wasm::WASM_OPCODE_F64_CONST: 431 IO.mapRequired("Value", Expr.Value.Float64); 432 break; 433 case wasm::WASM_OPCODE_GLOBAL_GET: 434 IO.mapRequired("Index", Expr.Value.Global); 435 break; 436 case wasm::WASM_OPCODE_REF_NULL: { 437 WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF; 438 IO.mapRequired("Type", Ty); 439 break; 440 } 441 } 442 } 443 444 void MappingTraits<WasmYAML::DataSegment>::mapping( 445 IO &IO, WasmYAML::DataSegment &Segment) { 446 IO.mapOptional("SectionOffset", Segment.SectionOffset); 447 IO.mapRequired("InitFlags", Segment.InitFlags); 448 if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX) { 449 IO.mapRequired("MemoryIndex", Segment.MemoryIndex); 450 } else { 451 Segment.MemoryIndex = 0; 452 } 453 if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) { 454 IO.mapRequired("Offset", Segment.Offset); 455 } else { 456 Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST; 457 Segment.Offset.Value.Int32 = 0; 458 } 459 IO.mapRequired("Content", Segment.Content); 460 } 461 462 void MappingTraits<WasmYAML::InitFunction>::mapping( 463 IO &IO, WasmYAML::InitFunction &Init) { 464 IO.mapRequired("Priority", Init.Priority); 465 IO.mapRequired("Symbol", Init.Symbol); 466 } 467 468 void ScalarEnumerationTraits<WasmYAML::ComdatKind>::enumeration( 469 IO &IO, WasmYAML::ComdatKind &Kind) { 470 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_COMDAT_##X); 471 ECase(FUNCTION); 472 ECase(DATA); 473 #undef ECase 474 } 475 476 void MappingTraits<WasmYAML::ComdatEntry>::mapping( 477 IO &IO, WasmYAML::ComdatEntry &ComdatEntry) { 478 IO.mapRequired("Kind", ComdatEntry.Kind); 479 IO.mapRequired("Index", ComdatEntry.Index); 480 } 481 482 void MappingTraits<WasmYAML::Comdat>::mapping(IO &IO, 483 WasmYAML::Comdat &Comdat) { 484 IO.mapRequired("Name", Comdat.Name); 485 IO.mapRequired("Entries", Comdat.Entries); 486 } 487 488 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO, 489 WasmYAML::SymbolInfo &Info) { 490 IO.mapRequired("Index", Info.Index); 491 IO.mapRequired("Kind", Info.Kind); 492 if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION) 493 IO.mapRequired("Name", Info.Name); 494 IO.mapRequired("Flags", Info.Flags); 495 if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) { 496 IO.mapRequired("Function", Info.ElementIndex); 497 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) { 498 IO.mapRequired("Global", Info.ElementIndex); 499 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_EVENT) { 500 IO.mapRequired("Event", Info.ElementIndex); 501 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) { 502 if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) { 503 IO.mapRequired("Segment", Info.DataRef.Segment); 504 IO.mapOptional("Offset", Info.DataRef.Offset, 0u); 505 IO.mapRequired("Size", Info.DataRef.Size); 506 } 507 } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) { 508 IO.mapRequired("Section", Info.ElementIndex); 509 } else { 510 llvm_unreachable("unsupported symbol kind"); 511 } 512 } 513 514 void MappingTraits<WasmYAML::Event>::mapping(IO &IO, WasmYAML::Event &Event) { 515 IO.mapRequired("Index", Event.Index); 516 IO.mapRequired("Attribute", Event.Attribute); 517 IO.mapRequired("SigIndex", Event.SigIndex); 518 } 519 520 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset( 521 IO &IO, WasmYAML::LimitFlags &Value) { 522 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X) 523 BCase(HAS_MAX); 524 BCase(IS_SHARED); 525 BCase(IS_64); 526 #undef BCase 527 } 528 529 void ScalarBitSetTraits<WasmYAML::SegmentFlags>::bitset( 530 IO &IO, WasmYAML::SegmentFlags &Value) {} 531 532 void ScalarBitSetTraits<WasmYAML::SymbolFlags>::bitset( 533 IO &IO, WasmYAML::SymbolFlags &Value) { 534 #define BCaseMask(M, X) \ 535 IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M) 536 // BCaseMask(BINDING_MASK, BINDING_GLOBAL); 537 BCaseMask(BINDING_MASK, BINDING_WEAK); 538 BCaseMask(BINDING_MASK, BINDING_LOCAL); 539 // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT); 540 BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN); 541 BCaseMask(UNDEFINED, UNDEFINED); 542 BCaseMask(EXPORTED, EXPORTED); 543 BCaseMask(EXPLICIT_NAME, EXPLICIT_NAME); 544 BCaseMask(NO_STRIP, NO_STRIP); 545 #undef BCaseMask 546 } 547 548 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration( 549 IO &IO, WasmYAML::SymbolKind &Kind) { 550 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X); 551 ECase(FUNCTION); 552 ECase(DATA); 553 ECase(GLOBAL); 554 ECase(SECTION); 555 ECase(EVENT); 556 #undef ECase 557 } 558 559 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration( 560 IO &IO, WasmYAML::ValueType &Type) { 561 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X); 562 ECase(I32); 563 ECase(I64); 564 ECase(F32); 565 ECase(F64); 566 ECase(V128); 567 ECase(FUNCREF); 568 ECase(EXNREF); 569 ECase(EXTERNREF); 570 ECase(FUNC); 571 #undef ECase 572 } 573 574 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration( 575 IO &IO, WasmYAML::ExportKind &Kind) { 576 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X); 577 ECase(FUNCTION); 578 ECase(TABLE); 579 ECase(MEMORY); 580 ECase(GLOBAL); 581 ECase(EVENT); 582 #undef ECase 583 } 584 585 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration( 586 IO &IO, WasmYAML::Opcode &Code) { 587 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X); 588 ECase(END); 589 ECase(I32_CONST); 590 ECase(I64_CONST); 591 ECase(F64_CONST); 592 ECase(F32_CONST); 593 ECase(GLOBAL_GET); 594 ECase(REF_NULL); 595 #undef ECase 596 } 597 598 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration( 599 IO &IO, WasmYAML::TableType &Type) { 600 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X); 601 ECase(FUNCREF); 602 #undef ECase 603 } 604 605 void ScalarEnumerationTraits<WasmYAML::RelocType>::enumeration( 606 IO &IO, WasmYAML::RelocType &Type) { 607 #define WASM_RELOC(name, value) IO.enumCase(Type, #name, wasm::name); 608 #include "llvm/BinaryFormat/WasmRelocs.def" 609 #undef WASM_RELOC 610 } 611 612 } // end namespace yaml 613 614 } // end namespace llvm 615