summaryrefslogtreecommitdiffstats
path: root/js/src/wasm/WasmDump.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /js/src/wasm/WasmDump.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/wasm/WasmDump.cpp')
-rw-r--r--js/src/wasm/WasmDump.cpp293
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