contrib/llvm/include/llvm/ObjectYAML/WasmYAML.h

   1 //===- WasmYAML.h - Wasm YAMLIO implementation ------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// This file declares classes for handling the YAML representation
  12 /// of wasm binaries.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_OBJECTYAML_WASMYAML_H
  17 #define LLVM_OBJECTYAML_WASMYAML_H
  18
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/BinaryFormat/Wasm.h"
  21 #include "llvm/ObjectYAML/YAML.h"
  22 #include "llvm/Support/Casting.h"
  23 #include <cstdint>
  24 #include <memory>
  25 #include <vector>
  26
  27 namespace llvm {
  28 namespace WasmYAML {
  29
  30 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SectionType)
  31 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ValueType)
  32 LLVM_YAML_STRONG_TYPEDEF(uint32_t, TableType)
  33 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SignatureForm)
  34 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ExportKind)
  35 LLVM_YAML_STRONG_TYPEDEF(uint32_t, Opcode)
  36 LLVM_YAML_STRONG_TYPEDEF(uint32_t, RelocType)
  37 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolFlags)
  38 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SymbolKind)
  39 LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
  40 LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
  41 LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
  42
  43 struct FileHeader {
  44   yaml::Hex32 Version;
  45 };
  46
  47 struct Limits {
  48   LimitFlags Flags;
  49   yaml::Hex32 Initial;
  50   yaml::Hex32 Maximum;
  51 };
  52
  53 struct Table {
  54   TableType ElemType;
  55   Limits TableLimits;
  56 };
  57
  58 struct Export {
  59   StringRef Name;
  60   ExportKind Kind;
  61   uint32_t Index;
  62 };
  63
  64 struct ElemSegment {
  65   uint32_t TableIndex;
  66   wasm::WasmInitExpr Offset;
  67   std::vector<uint32_t> Functions;
  68 };
  69
  70 struct Global {
  71   uint32_t Index;
  72   ValueType Type;
  73   bool Mutable;
  74   wasm::WasmInitExpr InitExpr;
  75 };
  76
  77 struct Import {
  78   StringRef Module;
  79   StringRef Field;
  80   ExportKind Kind;
  81   union {
  82     uint32_t SigIndex;
  83     Global GlobalImport;
  84     Table TableImport;
  85     Limits Memory;
  86   };
  87 };
  88
  89 struct LocalDecl {
  90   ValueType Type;
  91   uint32_t Count;
  92 };
  93
  94 struct Function {
  95   uint32_t Index;
  96   std::vector<LocalDecl> Locals;
  97   yaml::BinaryRef Body;
  98 };
  99
 100 struct Relocation {
 101   RelocType Type;
 102   uint32_t Index;
 103   yaml::Hex32 Offset;
 104   int32_t Addend;
 105 };
 106
 107 struct DataSegment {
 108   uint32_t MemoryIndex;
 109   uint32_t SectionOffset;
 110   wasm::WasmInitExpr Offset;
 111   yaml::BinaryRef Content;
 112 };
 113
 114 struct NameEntry {
 115   uint32_t Index;
 116   StringRef Name;
 117 };
 118
 119 struct SegmentInfo {
 120   uint32_t Index;
 121   StringRef Name;
 122   uint32_t Alignment;
 123   SegmentFlags Flags;
 124 };
 125
 126 struct Signature {
 127   uint32_t Index;
 128   SignatureForm Form = wasm::WASM_TYPE_FUNC;
 129   std::vector<ValueType> ParamTypes;
 130   ValueType ReturnType;
 131 };
 132
 133 struct SymbolInfo {
 134   uint32_t Index;
 135   StringRef Name;
 136   SymbolKind Kind;
 137   SymbolFlags Flags;
 138   union {
 139     uint32_t ElementIndex;
 140     wasm::WasmDataReference DataRef;
 141   };
 142 };
 143
 144 struct InitFunction {
 145   uint32_t Priority;
 146   uint32_t Symbol;
 147 };
 148
 149 struct ComdatEntry {
 150   ComdatKind Kind;
 151   uint32_t Index;
 152 };
 153
 154 struct Comdat {
 155   StringRef Name;
 156   std::vector<ComdatEntry> Entries;
 157 };
 158
 159 struct Section {
 160   explicit Section(SectionType SecType) : Type(SecType) {}
 161   virtual ~Section();
 162
 163   SectionType Type;
 164   std::vector<Relocation> Relocations;
 165 };
 166
 167 struct CustomSection : Section {
 168   explicit CustomSection(StringRef Name)
 169       : Section(wasm::WASM_SEC_CUSTOM), Name(Name) {}
 170
 171   static bool classof(const Section *S) {
 172     return S->Type == wasm::WASM_SEC_CUSTOM;
 173   }
 174
 175   StringRef Name;
 176   yaml::BinaryRef Payload;
 177 };
 178
 179 struct NameSection : CustomSection {
 180   NameSection() : CustomSection("name") {}
 181
 182   static bool classof(const Section *S) {
 183     auto C = dyn_cast<CustomSection>(S);
 184     return C && C->Name == "name";
 185   }
 186
 187   std::vector<NameEntry> FunctionNames;
 188 };
 189
 190 struct LinkingSection : CustomSection {
 191   LinkingSection() : CustomSection("linking") {}
 192
 193   static bool classof(const Section *S) {
 194     auto C = dyn_cast<CustomSection>(S);
 195     return C && C->Name == "linking";
 196   }
 197
 198   uint32_t Version;
 199   std::vector<SymbolInfo> SymbolTable;
 200   std::vector<SegmentInfo> SegmentInfos;
 201   std::vector<InitFunction> InitFunctions;
 202   std::vector<Comdat> Comdats;
 203 };
 204
 205 struct TypeSection : Section {
 206   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 207
 208   static bool classof(const Section *S) {
 209     return S->Type == wasm::WASM_SEC_TYPE;
 210   }
 211
 212   std::vector<Signature> Signatures;
 213 };
 214
 215 struct ImportSection : Section {
 216   ImportSection() : Section(wasm::WASM_SEC_IMPORT) {}
 217
 218   static bool classof(const Section *S) {
 219     return S->Type == wasm::WASM_SEC_IMPORT;
 220   }
 221
 222   std::vector<Import> Imports;
 223 };
 224
 225 struct FunctionSection : Section {
 226   FunctionSection() : Section(wasm::WASM_SEC_FUNCTION) {}
 227
 228   static bool classof(const Section *S) {
 229     return S->Type == wasm::WASM_SEC_FUNCTION;
 230   }
 231
 232   std::vector<uint32_t> FunctionTypes;
 233 };
 234
 235 struct TableSection : Section {
 236   TableSection() : Section(wasm::WASM_SEC_TABLE) {}
 237
 238   static bool classof(const Section *S) {
 239     return S->Type == wasm::WASM_SEC_TABLE;
 240   }
 241
 242   std::vector<Table> Tables;
 243 };
 244
 245 struct MemorySection : Section {
 246   MemorySection() : Section(wasm::WASM_SEC_MEMORY) {}
 247
 248   static bool classof(const Section *S) {
 249     return S->Type == wasm::WASM_SEC_MEMORY;
 250   }
 251
 252   std::vector<Limits> Memories;
 253 };
 254
 255 struct GlobalSection : Section {
 256   GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
 257
 258   static bool classof(const Section *S) {
 259     return S->Type == wasm::WASM_SEC_GLOBAL;
 260   }
 261
 262   std::vector<Global> Globals;
 263 };
 264
 265 struct ExportSection : Section {
 266   ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
 267
 268   static bool classof(const Section *S) {
 269     return S->Type == wasm::WASM_SEC_EXPORT;
 270   }
 271
 272   std::vector<Export> Exports;
 273 };
 274
 275 struct StartSection : Section {
 276   StartSection() : Section(wasm::WASM_SEC_START) {}
 277
 278   static bool classof(const Section *S) {
 279     return S->Type == wasm::WASM_SEC_START;
 280   }
 281
 282   uint32_t StartFunction;
 283 };
 284
 285 struct ElemSection : Section {
 286   ElemSection() : Section(wasm::WASM_SEC_ELEM) {}
 287
 288   static bool classof(const Section *S) {
 289     return S->Type == wasm::WASM_SEC_ELEM;
 290   }
 291
 292   std::vector<ElemSegment> Segments;
 293 };
 294
 295 struct CodeSection : Section {
 296   CodeSection() : Section(wasm::WASM_SEC_CODE) {}
 297
 298   static bool classof(const Section *S) {
 299     return S->Type == wasm::WASM_SEC_CODE;
 300   }
 301
 302   std::vector<Function> Functions;
 303 };
 304
 305 struct DataSection : Section {
 306   DataSection() : Section(wasm::WASM_SEC_DATA) {}
 307
 308   static bool classof(const Section *S) {
 309     return S->Type == wasm::WASM_SEC_DATA;
 310   }
 311
 312   std::vector<DataSegment> Segments;
 313 };
 314
 315 struct Object {
 316   FileHeader Header;
 317   std::vector<std::unique_ptr<Section>> Sections;
 318 };
 319
 320 } // end namespace WasmYAML
 321 } // end namespace llvm
 322
 323 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::WasmYAML::Section>)
 324 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Signature)
 325 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ValueType)
 326 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Table)
 327 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Import)
 328 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Export)
 329 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
 330 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
 331 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
 332 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
 333 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
 334 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
 335 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
 336 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 337 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 338 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 339 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
 340 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
 341 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
 342
 343 namespace llvm {
 344 namespace yaml {
 345
 346 template <> struct MappingTraits<WasmYAML::FileHeader> {
 347   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 348 };
 349
 350 template <> struct MappingTraits<std::unique_ptr<WasmYAML::Section>> {
 351   static void mapping(IO &IO, std::unique_ptr<WasmYAML::Section> &Section);
 352 };
 353
 354 template <> struct MappingTraits<WasmYAML::Object> {
 355   static void mapping(IO &IO, WasmYAML::Object &Object);
 356 };
 357
 358 template <> struct MappingTraits<WasmYAML::Import> {
 359   static void mapping(IO &IO, WasmYAML::Import &Import);
 360 };
 361
 362 template <> struct MappingTraits<WasmYAML::Export> {
 363   static void mapping(IO &IO, WasmYAML::Export &Export);
 364 };
 365
 366 template <> struct MappingTraits<WasmYAML::Global> {
 367   static void mapping(IO &IO, WasmYAML::Global &Global);
 368 };
 369
 370 template <> struct ScalarBitSetTraits<WasmYAML::LimitFlags> {
 371   static void bitset(IO &IO, WasmYAML::LimitFlags &Value);
 372 };
 373
 374 template <> struct ScalarBitSetTraits<WasmYAML::SymbolFlags> {
 375   static void bitset(IO &IO, WasmYAML::SymbolFlags &Value);
 376 };
 377
 378 template <> struct ScalarEnumerationTraits<WasmYAML::SymbolKind> {
 379   static void enumeration(IO &IO, WasmYAML::SymbolKind &Kind);
 380 };
 381
 382 template <> struct ScalarBitSetTraits<WasmYAML::SegmentFlags> {
 383   static void bitset(IO &IO, WasmYAML::SegmentFlags &Value);
 384 };
 385
 386 template <> struct ScalarEnumerationTraits<WasmYAML::SectionType> {
 387   static void enumeration(IO &IO, WasmYAML::SectionType &Type);
 388 };
 389
 390 template <> struct MappingTraits<WasmYAML::Signature> {
 391   static void mapping(IO &IO, WasmYAML::Signature &Signature);
 392 };
 393
 394 template <> struct MappingTraits<WasmYAML::Table> {
 395   static void mapping(IO &IO, WasmYAML::Table &Table);
 396 };
 397
 398 template <> struct MappingTraits<WasmYAML::Limits> {
 399   static void mapping(IO &IO, WasmYAML::Limits &Limits);
 400 };
 401
 402 template <> struct MappingTraits<WasmYAML::Function> {
 403   static void mapping(IO &IO, WasmYAML::Function &Function);
 404 };
 405
 406 template <> struct MappingTraits<WasmYAML::Relocation> {
 407   static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
 408 };
 409
 410 template <> struct MappingTraits<WasmYAML::NameEntry> {
 411   static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
 412 };
 413
 414 template <> struct MappingTraits<WasmYAML::SegmentInfo> {
 415   static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
 416 };
 417
 418 template <> struct MappingTraits<WasmYAML::LocalDecl> {
 419   static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
 420 };
 421
 422 template <> struct MappingTraits<wasm::WasmInitExpr> {
 423   static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
 424 };
 425
 426 template <> struct MappingTraits<WasmYAML::DataSegment> {
 427   static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
 428 };
 429
 430 template <> struct MappingTraits<WasmYAML::ElemSegment> {
 431   static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);
 432 };
 433
 434 template <> struct MappingTraits<WasmYAML::SymbolInfo> {
 435   static void mapping(IO &IO, WasmYAML::SymbolInfo &Info);
 436 };
 437
 438 template <> struct MappingTraits<WasmYAML::InitFunction> {
 439   static void mapping(IO &IO, WasmYAML::InitFunction &Init);
 440 };
 441
 442 template <> struct ScalarEnumerationTraits<WasmYAML::ComdatKind> {
 443   static void enumeration(IO &IO, WasmYAML::ComdatKind &Kind);
 444 };
 445
 446 template <> struct MappingTraits<WasmYAML::ComdatEntry> {
 447   static void mapping(IO &IO, WasmYAML::ComdatEntry &ComdatEntry);
 448 };
 449
 450 template <> struct MappingTraits<WasmYAML::Comdat> {
 451   static void mapping(IO &IO, WasmYAML::Comdat &Comdat);
 452 };
 453
 454 template <> struct ScalarEnumerationTraits<WasmYAML::ValueType> {
 455   static void enumeration(IO &IO, WasmYAML::ValueType &Type);
 456 };
 457
 458 template <> struct ScalarEnumerationTraits<WasmYAML::ExportKind> {
 459   static void enumeration(IO &IO, WasmYAML::ExportKind &Kind);
 460 };
 461
 462 template <> struct ScalarEnumerationTraits<WasmYAML::TableType> {
 463   static void enumeration(IO &IO, WasmYAML::TableType &Type);
 464 };
 465
 466 template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
 467   static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
 468 };
 469
 470 template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
 471   static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
 472 };
 473
 474 } // end namespace yaml
 475 } // end namespace llvm
 476
 477 #endif // LLVM_OBJECTYAML_WASMYAML_H