Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | //===- WasmYAML.h - Wasm YAMLIO implementation ------------------*- C++ -*-===// |
| 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 | /// \file |
||
| 10 | /// This file declares classes for handling the YAML representation |
||
| 11 | /// of wasm binaries. |
||
| 12 | /// |
||
| 13 | //===----------------------------------------------------------------------===// |
||
| 14 | |||
| 15 | #ifndef LLVM_OBJECTYAML_WASMYAML_H |
||
| 16 | #define LLVM_OBJECTYAML_WASMYAML_H |
||
| 17 | |||
| 18 | #include "llvm/ADT/StringRef.h" |
||
| 19 | #include "llvm/BinaryFormat/Wasm.h" |
||
| 20 | #include "llvm/ObjectYAML/YAML.h" |
||
| 21 | #include "llvm/Support/Casting.h" |
||
| 22 | #include <cstdint> |
||
| 23 | #include <memory> |
||
| 24 | #include <vector> |
||
| 25 | |||
| 26 | namespace llvm { |
||
| 27 | namespace WasmYAML { |
||
| 28 | |||
| 29 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType) |
||
| 30 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, ValueType) |
||
| 31 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, TableType) |
||
| 32 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, SignatureForm) |
||
| 33 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind) |
||
| 34 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode) |
||
| 35 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType) |
||
| 36 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags) |
||
| 37 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind) |
||
| 38 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags) |
||
| 39 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags) |
||
| 40 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind) |
||
| 41 | LLVM_YAML_STRONG_TYPEDEF(uint32_t, FeaturePolicyPrefix) |
||
| 42 | |||
| 43 | struct FileHeader { |
||
| 44 | yaml::Hex32 Version; |
||
| 45 | }; |
||
| 46 | |||
| 47 | struct Limits { |
||
| 48 | LimitFlags Flags; |
||
| 49 | yaml::Hex32 Minimum; |
||
| 50 | yaml::Hex32 Maximum; |
||
| 51 | }; |
||
| 52 | |||
| 53 | struct Table { |
||
| 54 | TableType ElemType; |
||
| 55 | Limits TableLimits; |
||
| 56 | uint32_t Index; |
||
| 57 | }; |
||
| 58 | |||
| 59 | struct Export { |
||
| 60 | StringRef Name; |
||
| 61 | ExportKind Kind; |
||
| 62 | uint32_t Index; |
||
| 63 | }; |
||
| 64 | |||
| 65 | struct InitExpr { |
||
| 66 | InitExpr() {} |
||
| 67 | bool Extended; |
||
| 68 | union { |
||
| 69 | wasm::WasmInitExprMVP Inst; |
||
| 70 | yaml::BinaryRef Body; |
||
| 71 | }; |
||
| 72 | }; |
||
| 73 | |||
| 74 | struct ElemSegment { |
||
| 75 | uint32_t Flags; |
||
| 76 | uint32_t TableNumber; |
||
| 77 | ValueType ElemKind; |
||
| 78 | InitExpr Offset; |
||
| 79 | std::vector<uint32_t> Functions; |
||
| 80 | }; |
||
| 81 | |||
| 82 | struct Global { |
||
| 83 | uint32_t Index; |
||
| 84 | ValueType Type; |
||
| 85 | bool Mutable; |
||
| 86 | InitExpr Init; |
||
| 87 | }; |
||
| 88 | |||
| 89 | struct Import { |
||
| 90 | Import() {} |
||
| 91 | StringRef Module; |
||
| 92 | StringRef Field; |
||
| 93 | ExportKind Kind; |
||
| 94 | union { |
||
| 95 | uint32_t SigIndex; |
||
| 96 | Table TableImport; |
||
| 97 | Limits Memory; |
||
| 98 | uint32_t TagIndex; |
||
| 99 | Global GlobalImport; |
||
| 100 | }; |
||
| 101 | }; |
||
| 102 | |||
| 103 | struct LocalDecl { |
||
| 104 | ValueType Type; |
||
| 105 | uint32_t Count; |
||
| 106 | }; |
||
| 107 | |||
| 108 | struct Function { |
||
| 109 | uint32_t Index; |
||
| 110 | std::vector<LocalDecl> Locals; |
||
| 111 | yaml::BinaryRef Body; |
||
| 112 | }; |
||
| 113 | |||
| 114 | struct Relocation { |
||
| 115 | RelocType Type; |
||
| 116 | uint32_t Index; |
||
| 117 | // TODO(wvo): this would strictly be better as Hex64, but that will change |
||
| 118 | // all existing obj2yaml output. |
||
| 119 | yaml::Hex32 Offset; |
||
| 120 | int64_t Addend; |
||
| 121 | }; |
||
| 122 | |||
| 123 | struct DataSegment { |
||
| 124 | uint32_t SectionOffset; |
||
| 125 | uint32_t InitFlags; |
||
| 126 | uint32_t MemoryIndex; |
||
| 127 | InitExpr Offset; |
||
| 128 | yaml::BinaryRef Content; |
||
| 129 | }; |
||
| 130 | |||
| 131 | struct NameEntry { |
||
| 132 | uint32_t Index; |
||
| 133 | StringRef Name; |
||
| 134 | }; |
||
| 135 | |||
| 136 | struct ProducerEntry { |
||
| 137 | std::string Name; |
||
| 138 | std::string Version; |
||
| 139 | }; |
||
| 140 | |||
| 141 | struct FeatureEntry { |
||
| 142 | FeaturePolicyPrefix Prefix; |
||
| 143 | std::string Name; |
||
| 144 | }; |
||
| 145 | |||
| 146 | struct SegmentInfo { |
||
| 147 | uint32_t Index; |
||
| 148 | StringRef Name; |
||
| 149 | uint32_t Alignment; |
||
| 150 | SegmentFlags Flags; |
||
| 151 | }; |
||
| 152 | |||
| 153 | struct Signature { |
||
| 154 | uint32_t Index; |
||
| 155 | SignatureForm Form = wasm::WASM_TYPE_FUNC; |
||
| 156 | std::vector<ValueType> ParamTypes; |
||
| 157 | std::vector<ValueType> ReturnTypes; |
||
| 158 | }; |
||
| 159 | |||
| 160 | struct SymbolInfo { |
||
| 161 | uint32_t Index; |
||
| 162 | StringRef Name; |
||
| 163 | SymbolKind Kind; |
||
| 164 | SymbolFlags Flags; |
||
| 165 | union { |
||
| 166 | uint32_t ElementIndex; |
||
| 167 | wasm::WasmDataReference DataRef; |
||
| 168 | }; |
||
| 169 | }; |
||
| 170 | |||
| 171 | struct InitFunction { |
||
| 172 | uint32_t Priority; |
||
| 173 | uint32_t Symbol; |
||
| 174 | }; |
||
| 175 | |||
| 176 | struct ComdatEntry { |
||
| 177 | ComdatKind Kind; |
||
| 178 | uint32_t Index; |
||
| 179 | }; |
||
| 180 | |||
| 181 | struct Comdat { |
||
| 182 | StringRef Name; |
||
| 183 | std::vector<ComdatEntry> Entries; |
||
| 184 | }; |
||
| 185 | |||
| 186 | struct Section { |
||
| 187 | explicit Section(SectionType SecType) : Type(SecType) {} |
||
| 188 | virtual ~Section(); |
||
| 189 | |||
| 190 | SectionType Type; |
||
| 191 | std::vector<Relocation> Relocations; |
||
| 192 | }; |
||
| 193 | |||
| 194 | struct CustomSection : Section { |
||
| 195 | explicit CustomSection(StringRef Name) |
||
| 196 | : Section(wasm::WASM_SEC_CUSTOM), Name(Name) {} |
||
| 197 | |||
| 198 | static bool classof(const Section *S) { |
||
| 199 | return S->Type == wasm::WASM_SEC_CUSTOM; |
||
| 200 | } |
||
| 201 | |||
| 202 | StringRef Name; |
||
| 203 | yaml::BinaryRef Payload; |
||
| 204 | }; |
||
| 205 | |||
| 206 | struct DylinkImportInfo { |
||
| 207 | StringRef Module; |
||
| 208 | StringRef Field; |
||
| 209 | SymbolFlags Flags; |
||
| 210 | }; |
||
| 211 | |||
| 212 | struct DylinkExportInfo { |
||
| 213 | StringRef Name; |
||
| 214 | SymbolFlags Flags; |
||
| 215 | }; |
||
| 216 | |||
| 217 | struct DylinkSection : CustomSection { |
||
| 218 | DylinkSection() : CustomSection("dylink.0") {} |
||
| 219 | |||
| 220 | static bool classof(const Section *S) { |
||
| 221 | auto C = dyn_cast<CustomSection>(S); |
||
| 222 | return C && C->Name == "dylink.0"; |
||
| 223 | } |
||
| 224 | |||
| 225 | uint32_t MemorySize; |
||
| 226 | uint32_t MemoryAlignment; |
||
| 227 | uint32_t TableSize; |
||
| 228 | uint32_t TableAlignment; |
||
| 229 | std::vector<StringRef> Needed; |
||
| 230 | std::vector<DylinkImportInfo> ImportInfo; |
||
| 231 | std::vector<DylinkExportInfo> ExportInfo; |
||
| 232 | }; |
||
| 233 | |||
| 234 | struct NameSection : CustomSection { |
||
| 235 | NameSection() : CustomSection("name") {} |
||
| 236 | |||
| 237 | static bool classof(const Section *S) { |
||
| 238 | auto C = dyn_cast<CustomSection>(S); |
||
| 239 | return C && C->Name == "name"; |
||
| 240 | } |
||
| 241 | |||
| 242 | std::vector<NameEntry> FunctionNames; |
||
| 243 | std::vector<NameEntry> GlobalNames; |
||
| 244 | std::vector<NameEntry> DataSegmentNames; |
||
| 245 | }; |
||
| 246 | |||
| 247 | struct LinkingSection : CustomSection { |
||
| 248 | LinkingSection() : CustomSection("linking") {} |
||
| 249 | |||
| 250 | static bool classof(const Section *S) { |
||
| 251 | auto C = dyn_cast<CustomSection>(S); |
||
| 252 | return C && C->Name == "linking"; |
||
| 253 | } |
||
| 254 | |||
| 255 | uint32_t Version; |
||
| 256 | std::vector<SymbolInfo> SymbolTable; |
||
| 257 | std::vector<SegmentInfo> SegmentInfos; |
||
| 258 | std::vector<InitFunction> InitFunctions; |
||
| 259 | std::vector<Comdat> Comdats; |
||
| 260 | }; |
||
| 261 | |||
| 262 | struct ProducersSection : CustomSection { |
||
| 263 | ProducersSection() : CustomSection("producers") {} |
||
| 264 | |||
| 265 | static bool classof(const Section *S) { |
||
| 266 | auto C = dyn_cast<CustomSection>(S); |
||
| 267 | return C && C->Name == "producers"; |
||
| 268 | } |
||
| 269 | |||
| 270 | std::vector<ProducerEntry> Languages; |
||
| 271 | std::vector<ProducerEntry> Tools; |
||
| 272 | std::vector<ProducerEntry> SDKs; |
||
| 273 | }; |
||
| 274 | |||
| 275 | struct TargetFeaturesSection : CustomSection { |
||
| 276 | TargetFeaturesSection() : CustomSection("target_features") {} |
||
| 277 | |||
| 278 | static bool classof(const Section *S) { |
||
| 279 | auto C = dyn_cast<CustomSection>(S); |
||
| 280 | return C && C->Name == "target_features"; |
||
| 281 | } |
||
| 282 | |||
| 283 | std::vector<FeatureEntry> Features; |
||
| 284 | }; |
||
| 285 | |||
| 286 | struct TypeSection : Section { |
||
| 287 | TypeSection() : Section(wasm::WASM_SEC_TYPE) {} |
||
| 288 | |||
| 289 | static bool classof(const Section *S) { |
||
| 290 | return S->Type == wasm::WASM_SEC_TYPE; |
||
| 291 | } |
||
| 292 | |||
| 293 | std::vector<Signature> Signatures; |
||
| 294 | }; |
||
| 295 | |||
| 296 | struct ImportSection : Section { |
||
| 297 | ImportSection() : Section(wasm::WASM_SEC_IMPORT) {} |
||
| 298 | |||
| 299 | static bool classof(const Section *S) { |
||
| 300 | return S->Type == wasm::WASM_SEC_IMPORT; |
||
| 301 | } |
||
| 302 | |||
| 303 | std::vector<Import> Imports; |
||
| 304 | }; |
||
| 305 | |||
| 306 | struct FunctionSection : Section { |
||
| 307 | FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {} |
||
| 308 | |||
| 309 | static bool classof(const Section *S) { |
||
| 310 | return S->Type == wasm::WASM_SEC_FUNCTION; |
||
| 311 | } |
||
| 312 | |||
| 313 | std::vector<uint32_t> FunctionTypes; |
||
| 314 | }; |
||
| 315 | |||
| 316 | struct TableSection : Section { |
||
| 317 | TableSection() : Section(wasm::WASM_SEC_TABLE) {} |
||
| 318 | |||
| 319 | static bool classof(const Section *S) { |
||
| 320 | return S->Type == wasm::WASM_SEC_TABLE; |
||
| 321 | } |
||
| 322 | |||
| 323 | std::vector<Table> Tables; |
||
| 324 | }; |
||
| 325 | |||
| 326 | struct MemorySection : Section { |
||
| 327 | MemorySection() : Section(wasm::WASM_SEC_MEMORY) {} |
||
| 328 | |||
| 329 | static bool classof(const Section *S) { |
||
| 330 | return S->Type == wasm::WASM_SEC_MEMORY; |
||
| 331 | } |
||
| 332 | |||
| 333 | std::vector<Limits> Memories; |
||
| 334 | }; |
||
| 335 | |||
| 336 | struct TagSection : Section { |
||
| 337 | TagSection() : Section(wasm::WASM_SEC_TAG) {} |
||
| 338 | |||
| 339 | static bool classof(const Section *S) { |
||
| 340 | return S->Type == wasm::WASM_SEC_TAG; |
||
| 341 | } |
||
| 342 | |||
| 343 | std::vector<uint32_t> TagTypes; |
||
| 344 | }; |
||
| 345 | |||
| 346 | struct GlobalSection : Section { |
||
| 347 | GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {} |
||
| 348 | |||
| 349 | static bool classof(const Section *S) { |
||
| 350 | return S->Type == wasm::WASM_SEC_GLOBAL; |
||
| 351 | } |
||
| 352 | |||
| 353 | std::vector<Global> Globals; |
||
| 354 | }; |
||
| 355 | |||
| 356 | struct ExportSection : Section { |
||
| 357 | ExportSection() : Section(wasm::WASM_SEC_EXPORT) {} |
||
| 358 | |||
| 359 | static bool classof(const Section *S) { |
||
| 360 | return S->Type == wasm::WASM_SEC_EXPORT; |
||
| 361 | } |
||
| 362 | |||
| 363 | std::vector<Export> Exports; |
||
| 364 | }; |
||
| 365 | |||
| 366 | struct StartSection : Section { |
||
| 367 | StartSection() : Section(wasm::WASM_SEC_START) {} |
||
| 368 | |||
| 369 | static bool classof(const Section *S) { |
||
| 370 | return S->Type == wasm::WASM_SEC_START; |
||
| 371 | } |
||
| 372 | |||
| 373 | uint32_t StartFunction; |
||
| 374 | }; |
||
| 375 | |||
| 376 | struct ElemSection : Section { |
||
| 377 | ElemSection() : Section(wasm::WASM_SEC_ELEM) {} |
||
| 378 | |||
| 379 | static bool classof(const Section *S) { |
||
| 380 | return S->Type == wasm::WASM_SEC_ELEM; |
||
| 381 | } |
||
| 382 | |||
| 383 | std::vector<ElemSegment> Segments; |
||
| 384 | }; |
||
| 385 | |||
| 386 | struct CodeSection : Section { |
||
| 387 | CodeSection() : Section(wasm::WASM_SEC_CODE) {} |
||
| 388 | |||
| 389 | static bool classof(const Section *S) { |
||
| 390 | return S->Type == wasm::WASM_SEC_CODE; |
||
| 391 | } |
||
| 392 | |||
| 393 | std::vector<Function> Functions; |
||
| 394 | }; |
||
| 395 | |||
| 396 | struct DataSection : Section { |
||
| 397 | DataSection() : Section(wasm::WASM_SEC_DATA) {} |
||
| 398 | |||
| 399 | static bool classof(const Section *S) { |
||
| 400 | return S->Type == wasm::WASM_SEC_DATA; |
||
| 401 | } |
||
| 402 | |||
| 403 | std::vector<DataSegment> Segments; |
||
| 404 | }; |
||
| 405 | |||
| 406 | struct DataCountSection : Section { |
||
| 407 | DataCountSection() : Section(wasm::WASM_SEC_DATACOUNT) {} |
||
| 408 | |||
| 409 | static bool classof(const Section *S) { |
||
| 410 | return S->Type == wasm::WASM_SEC_DATACOUNT; |
||
| 411 | } |
||
| 412 | |||
| 413 | uint32_t Count; |
||
| 414 | }; |
||
| 415 | |||
| 416 | struct Object { |
||
| 417 | FileHeader Header; |
||
| 418 | std::vector<std::unique_ptr<Section>> Sections; |
||
| 419 | }; |
||
| 420 | |||
| 421 | } // end namespace WasmYAML |
||
| 422 | } // end namespace llvm |
||
| 423 | |||
| 424 | LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>) |
||
| 425 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature) |
||
| 426 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType) |
||
| 427 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table) |
||
| 428 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import) |
||
| 429 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export) |
||
| 430 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment) |
||
| 431 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits) |
||
| 432 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment) |
||
| 433 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global) |
||
| 434 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function) |
||
| 435 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl) |
||
| 436 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation) |
||
| 437 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry) |
||
| 438 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry) |
||
| 439 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry) |
||
| 440 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo) |
||
| 441 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo) |
||
| 442 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction) |
||
| 443 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry) |
||
| 444 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat) |
||
| 445 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkImportInfo) |
||
| 446 | LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkExportInfo) |
||
| 447 | |||
| 448 | namespace llvm { |
||
| 449 | namespace yaml { |
||
| 450 | |||
| 451 | template <> struct MappingTraits<WasmYAML::FileHeader> { |
||
| 452 | static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr); |
||
| 453 | }; |
||
| 454 | |||
| 455 | template <> struct MappingTraits<std::unique_ptr<WasmYAML::Section>> { |
||
| 456 | static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section); |
||
| 457 | }; |
||
| 458 | |||
| 459 | template <> struct MappingTraits<WasmYAML::Object> { |
||
| 460 | static void mapping(IO &IO, WasmYAML::Object &Object); |
||
| 461 | }; |
||
| 462 | |||
| 463 | template <> struct MappingTraits<WasmYAML::Import> { |
||
| 464 | static void mapping(IO &IO, WasmYAML::Import &Import); |
||
| 465 | }; |
||
| 466 | |||
| 467 | template <> struct MappingTraits<WasmYAML::Export> { |
||
| 468 | static void mapping(IO &IO, WasmYAML::Export &Export); |
||
| 469 | }; |
||
| 470 | |||
| 471 | template <> struct MappingTraits<WasmYAML::Global> { |
||
| 472 | static void mapping(IO &IO, WasmYAML::Global &Global); |
||
| 473 | }; |
||
| 474 | |||
| 475 | template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> { |
||
| 476 | static void bitset(IO &IO, WasmYAML::LimitFlags &Value); |
||
| 477 | }; |
||
| 478 | |||
| 479 | template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> { |
||
| 480 | static void bitset(IO &IO, WasmYAML::SymbolFlags &Value); |
||
| 481 | }; |
||
| 482 | |||
| 483 | template <> struct ScalarEnumerationTraits<WasmYAML::SymbolKind> { |
||
| 484 | static void enumeration(IO &IO, WasmYAML::SymbolKind &Kind); |
||
| 485 | }; |
||
| 486 | |||
| 487 | template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> { |
||
| 488 | static void bitset(IO &IO, WasmYAML::SegmentFlags &Value); |
||
| 489 | }; |
||
| 490 | |||
| 491 | template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> { |
||
| 492 | static void enumeration(IO &IO, WasmYAML::SectionType &Type); |
||
| 493 | }; |
||
| 494 | |||
| 495 | template <> struct MappingTraits<WasmYAML::Signature> { |
||
| 496 | static void mapping(IO &IO, WasmYAML::Signature &Signature); |
||
| 497 | }; |
||
| 498 | |||
| 499 | template <> struct MappingTraits<WasmYAML::Table> { |
||
| 500 | static void mapping(IO &IO, WasmYAML::Table &Table); |
||
| 501 | }; |
||
| 502 | |||
| 503 | template <> struct MappingTraits<WasmYAML::Limits> { |
||
| 504 | static void mapping(IO &IO, WasmYAML::Limits &Limits); |
||
| 505 | }; |
||
| 506 | |||
| 507 | template <> struct MappingTraits<WasmYAML::Function> { |
||
| 508 | static void mapping(IO &IO, WasmYAML::Function &Function); |
||
| 509 | }; |
||
| 510 | |||
| 511 | template <> struct MappingTraits<WasmYAML::Relocation> { |
||
| 512 | static void mapping(IO &IO, WasmYAML::Relocation &Relocation); |
||
| 513 | }; |
||
| 514 | |||
| 515 | template <> struct MappingTraits<WasmYAML::NameEntry> { |
||
| 516 | static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry); |
||
| 517 | }; |
||
| 518 | |||
| 519 | template <> struct MappingTraits<WasmYAML::ProducerEntry> { |
||
| 520 | static void mapping(IO &IO, WasmYAML::ProducerEntry &ProducerEntry); |
||
| 521 | }; |
||
| 522 | |||
| 523 | template <> struct ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix> { |
||
| 524 | static void enumeration(IO &IO, WasmYAML::FeaturePolicyPrefix &Prefix); |
||
| 525 | }; |
||
| 526 | |||
| 527 | template <> struct MappingTraits<WasmYAML::FeatureEntry> { |
||
| 528 | static void mapping(IO &IO, WasmYAML::FeatureEntry &FeatureEntry); |
||
| 529 | }; |
||
| 530 | |||
| 531 | template <> struct MappingTraits<WasmYAML::SegmentInfo> { |
||
| 532 | static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo); |
||
| 533 | }; |
||
| 534 | |||
| 535 | template <> struct MappingTraits<WasmYAML::LocalDecl> { |
||
| 536 | static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl); |
||
| 537 | }; |
||
| 538 | |||
| 539 | template <> struct MappingTraits<WasmYAML::InitExpr> { |
||
| 540 | static void mapping(IO &IO, WasmYAML::InitExpr &Expr); |
||
| 541 | }; |
||
| 542 | |||
| 543 | template <> struct MappingTraits<WasmYAML::DataSegment> { |
||
| 544 | static void mapping(IO &IO, WasmYAML::DataSegment &Segment); |
||
| 545 | }; |
||
| 546 | |||
| 547 | template <> struct MappingTraits<WasmYAML::ElemSegment> { |
||
| 548 | static void mapping(IO &IO, WasmYAML::ElemSegment &Segment); |
||
| 549 | }; |
||
| 550 | |||
| 551 | template <> struct MappingTraits<WasmYAML::SymbolInfo> { |
||
| 552 | static void mapping(IO &IO, WasmYAML::SymbolInfo &Info); |
||
| 553 | }; |
||
| 554 | |||
| 555 | template <> struct MappingTraits<WasmYAML::InitFunction> { |
||
| 556 | static void mapping(IO &IO, WasmYAML::InitFunction &Init); |
||
| 557 | }; |
||
| 558 | |||
| 559 | template <> struct ScalarEnumerationTraits<WasmYAML::ComdatKind> { |
||
| 560 | static void enumeration(IO &IO, WasmYAML::ComdatKind &Kind); |
||
| 561 | }; |
||
| 562 | |||
| 563 | template <> struct MappingTraits<WasmYAML::ComdatEntry> { |
||
| 564 | static void mapping(IO &IO, WasmYAML::ComdatEntry &ComdatEntry); |
||
| 565 | }; |
||
| 566 | |||
| 567 | template <> struct MappingTraits<WasmYAML::Comdat> { |
||
| 568 | static void mapping(IO &IO, WasmYAML::Comdat &Comdat); |
||
| 569 | }; |
||
| 570 | |||
| 571 | template <> struct ScalarEnumerationTraits<WasmYAML::ValueType> { |
||
| 572 | static void enumeration(IO &IO, WasmYAML::ValueType &Type); |
||
| 573 | }; |
||
| 574 | |||
| 575 | template <> struct ScalarEnumerationTraits<WasmYAML::ExportKind> { |
||
| 576 | static void enumeration(IO &IO, WasmYAML::ExportKind &Kind); |
||
| 577 | }; |
||
| 578 | |||
| 579 | template <> struct ScalarEnumerationTraits<WasmYAML::TableType> { |
||
| 580 | static void enumeration(IO &IO, WasmYAML::TableType &Type); |
||
| 581 | }; |
||
| 582 | |||
| 583 | template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> { |
||
| 584 | static void enumeration(IO &IO, WasmYAML::Opcode &Opcode); |
||
| 585 | }; |
||
| 586 | |||
| 587 | template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> { |
||
| 588 | static void enumeration(IO &IO, WasmYAML::RelocType &Kind); |
||
| 589 | }; |
||
| 590 | |||
| 591 | template <> struct MappingTraits<WasmYAML::DylinkImportInfo> { |
||
| 592 | static void mapping(IO &IO, WasmYAML::DylinkImportInfo &Info); |
||
| 593 | }; |
||
| 594 | |||
| 595 | template <> struct MappingTraits<WasmYAML::DylinkExportInfo> { |
||
| 596 | static void mapping(IO &IO, WasmYAML::DylinkExportInfo &Info); |
||
| 597 | }; |
||
| 598 | |||
| 599 | } // end namespace yaml |
||
| 600 | } // end namespace llvm |
||
| 601 | |||
| 602 | #endif // LLVM_OBJECTYAML_WASMYAML_H |