diff options
Diffstat (limited to 'js/src/wasm/WasmDump.cpp')
| -rw-r--r-- | js/src/wasm/WasmDump.cpp | 293 |
1 files changed, 293 insertions, 0 deletions
diff --git a/js/src/wasm/WasmDump.cpp b/js/src/wasm/WasmDump.cpp new file mode 100644 index 0000000000..2af9ebece2 --- /dev/null +++ b/js/src/wasm/WasmDump.cpp @@ -0,0 +1,293 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "wasm/WasmDump.h" + +#include <cinttypes> + +using namespace js; +using namespace js::wasm; + +#ifdef DEBUG + +void wasm::Dump(ValType type) { + Fprinter out(stdout); + wasm::Dump(type, out); +} + +void wasm::Dump(ValType type, GenericPrinter& out) { + Dump(type.storageType(), out); +} + +void wasm::Dump(StorageType type) { + Fprinter out(stdout); + wasm::Dump(type, out); +} + +void wasm::Dump(StorageType type, GenericPrinter& out) { + const char* literal = nullptr; + switch (type.kind()) { + case StorageType::I8: + literal = "i8"; + break; + case StorageType::I16: + literal = "i16"; + break; + case StorageType::I32: + literal = "i32"; + break; + case StorageType::I64: + literal = "i64"; + break; + case StorageType::V128: + literal = "v128"; + break; + case StorageType::F32: + literal = "f32"; + break; + case StorageType::F64: + literal = "f64"; + break; + case StorageType::Ref: + return Dump(type.refType(), out); + } + out.put(literal); +} + +void wasm::Dump(RefType type) { + Fprinter out(stdout); + wasm::Dump(type, out); +} + +void wasm::Dump(RefType type, GenericPrinter& out) { + if (type.isNullable() && !type.isTypeRef()) { + const char* literal = nullptr; + switch (type.kind()) { + case RefType::Func: + literal = "funcref"; + break; + case RefType::Extern: + literal = "externref"; + break; + case RefType::Any: + literal = "anyref"; + break; + case RefType::NoFunc: + literal = "nullfuncref"; + break; + case RefType::NoExtern: + literal = "nullexternref"; + break; + case RefType::None: + literal = "nullref"; + break; + case RefType::Eq: + literal = "eqref"; + break; + case RefType::I31: + literal = "i31ref"; + break; + case RefType::Struct: + literal = "structref"; + break; + case RefType::Array: + literal = "arrayref"; + break; + case RefType::Exn: + literal = "exnref"; + break; + case RefType::TypeRef: { + MOZ_CRASH("type ref should not be possible here"); + } + } + out.put(literal); + return; + } + + // Emit the full reference type with heap type + const char* heapType = nullptr; + switch (type.kind()) { + case RefType::Func: + heapType = "func"; + break; + case RefType::Extern: + heapType = "extern"; + break; + case RefType::Any: + heapType = "any"; + break; + case RefType::NoFunc: + heapType = "nofunc"; + break; + case RefType::NoExtern: + heapType = "noextern"; + break; + case RefType::None: + heapType = "none"; + break; + case RefType::Eq: + heapType = "eq"; + break; + case RefType::I31: + heapType = "eq"; + break; + case RefType::Struct: + heapType = "struct"; + break; + case RefType::Array: + heapType = "array"; + break; + case RefType::Exn: + heapType = "exn"; + break; + case RefType::TypeRef: { + uintptr_t typeAddress = (uintptr_t)type.typeDef(); + out.printf("(ref %s0x%" PRIxPTR ")", type.isNullable() ? "null " : "", + typeAddress); + return; + } + } + out.printf("(ref %s%s)", type.isNullable() ? "null " : "", heapType); +} + +void wasm::Dump(const FuncType& funcType) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(funcType, out); +} + +void wasm::Dump(const FuncType& funcType, IndentedPrinter& out) { + out.printf("(func\n"); + { + IndentedPrinter::AutoIndent innerIndent(out); + for (ValType arg : funcType.args()) { + out.printf("(param "); + Dump(arg, out); + out.printf(")\n"); + } + for (ValType result : funcType.results()) { + out.printf("(result "); + Dump(result, out); + out.printf(")\n"); + } + } + out.printf(")\n"); +} + +void wasm::Dump(const StructType& structType) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(structType, out); +} + +void wasm::Dump(const StructType& structType, IndentedPrinter& out) { + out.printf("(struct\n"); + { + IndentedPrinter::AutoIndent innerIndent(out); + for (const StructField& field : structType.fields_) { + out.printf("(field "); + if (field.isMutable) { + out.printf("(mut "); + } + Dump(field.type, out); + if (field.isMutable) { + out.printf(")"); + } + out.printf(")\n"); + } + } + out.printf(")\n"); +} + +void wasm::Dump(const ArrayType& arrayType) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(arrayType, out); +} + +void wasm::Dump(const ArrayType& arrayType, IndentedPrinter& out) { + out.printf("(array "); + if (arrayType.isMutable_) { + out.printf("(mut "); + } + Dump(arrayType.elementType_, out); + if (arrayType.isMutable_) { + out.printf(")"); + } + out.printf(")\n"); +} + +void wasm::Dump(const TypeDef& typeDef) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(typeDef, out); +} + +void wasm::Dump(const TypeDef& typeDef, IndentedPrinter& out) { + out.printf("(type 0x%" PRIxPTR "\n", (uintptr_t)&typeDef); + + { + IndentedPrinter::AutoIndent innerIndent(out); + out.printf("final=%u\n", typeDef.isFinal() ? 1 : 0); + out.printf("subtypingDepth=%u\n", typeDef.subTypingDepth()); + if (typeDef.superTypeDef()) { + out.printf("superType=0x%" PRIxPTR "\n", + (uintptr_t)typeDef.superTypeDef()); + } + switch (typeDef.kind()) { + case TypeDefKind::Func: + Dump(typeDef.funcType(), out); + break; + case TypeDefKind::Struct: + Dump(typeDef.structType(), out); + break; + case TypeDefKind::Array: + Dump(typeDef.arrayType(), out); + break; + case TypeDefKind::None: + out.printf("(none)\n"); + break; + } + } + + out.printf(")\n"); +} + +void wasm::Dump(const RecGroup& recGroup) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(recGroup, out); +} + +void wasm::Dump(const RecGroup& recGroup, IndentedPrinter& out) { + out.printf("(rec\n"); + { + IndentedPrinter::AutoIndent innerIndent(out); + for (uint32_t typeIndex = 0; typeIndex < recGroup.numTypes(); typeIndex++) { + Dump(recGroup.type(typeIndex), out); + } + } + out.printf(")\n"); +} + +void wasm::Dump(const TypeContext& typeContext) { + Fprinter fileOut(stdout); + IndentedPrinter out(fileOut); + wasm::Dump(typeContext, out); +} + +void wasm::Dump(const TypeContext& typeContext, IndentedPrinter& out) { + out.printf("(types\n"); + { + IndentedPrinter::AutoIndent innerIndent(out); + for (const SharedRecGroup& recGroup : typeContext.groups()) { + Dump(*recGroup, out); + } + } + out.printf(")\n"); +} + +#endif // DEBUG |