@wasmgroundup/emit 0.2.4 → 0.2.6

package/dist/index.d.ts

@@ -5,6 +5,7 @@ declare enum valtype {
     f32 = 125,
     f64 = 124
 }
+declare function blocktype(t?: valtype): number;
 declare function vec<T extends BytecodeFragment>(elements: T): BytecodeFragment;
 declare function section(id: number, contents: BytecodeFragment): (number | BytecodeFragment)[];
 declare function functype(paramTypes: valtype[], resultTypes: valtype[]): BytecodeFragment;
@@ -20,10 +21,13 @@ declare function exportsec(exports: BytecodeFragment): BytecodeFragment;
 declare const funcidx: typeof u32;
 declare const exportdesc: {
     func(idx: number): BytecodeFragment;
+    global(idx: number): BytecodeFragment;
 };
 declare function module(sections: any): BytecodeFragment;
 declare const instr: {
     nop: number;
+    if: number;
+    else: number;
     end: number;
     call: number;
     local: {
@@ -31,6 +35,10 @@ declare const instr: {
         set: number;
         tee: number;
     };
+    global: {
+        get: number;
+        set: number;
+    };
     i32: {
         const: number;
         add: number;
@@ -67,4 +75,11 @@ declare function importsec(ims: BytecodeFragment): BytecodeFragment;
 declare const importdesc: {
     func(x: number): BytecodeFragment;
 };
-export { BytecodeFragment, code, codesec, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, i32, import_, importdesc, importsec, instr, locals, module, name, section, typeidx, typesec, valtype, vec, };
+declare const mut: {
+    const: number;
+    var: number;
+};
+declare function globaltype(t: any, m: any): any[];
+declare function global(gt: any, e: any): any[];
+declare function globalsec(globs: any): (number | BytecodeFragment)[];
+export { blocktype, BytecodeFragment, code, codesec, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, locals, module, mut, name, section, typeidx, typesec, valtype, vec, };

package/dist/index.js

@@ -1,6 +1,7 @@
 const SECTION_ID_TYPE = 1;
 const SECTION_ID_IMPORT = 2;
 const SECTION_ID_FUNCTION = 3;
+const SECTION_ID_GLOBAL = 6;
 const SECTION_ID_EXPORT = 7;
 const SECTION_ID_CODE = 10;
 const TYPE_FUNCTION = 0x60;
@@ -32,6 +33,10 @@ var valtype;
     valtype[valtype["f32"] = 125] = "f32";
     valtype[valtype["f64"] = 124] = "f64";
 })(valtype || (valtype = {}));
+// t: valtype
+function blocktype(t) {
+    return t ?? 0x40;
+}
 function vec(elements) {
     return [u32(elements.length), ...elements];
 }
@@ -73,6 +78,9 @@ const exportdesc = {
     func(idx) {
         return [0x00, funcidx(idx)];
     },
+    global(idx) {
+        return [0x03, globalidx(idx)];
+    },
 };
 function module(sections) {
     return [magic(), version(), sections];
@@ -83,6 +91,8 @@ var numtype;
 })(numtype || (numtype = {}));
 const instr = {
     nop: 0x01,
+    if: 0x04,
+    else: 0x05,
     end: 0x0b,
     call: 0x10,
     local: {
@@ -90,6 +100,10 @@ const instr = {
         set: 0x21,
         tee: 0x22,
     },
+    global: {
+        get: 0x23,
+        set: 0x24,
+    },
     i32: {
         const: 0x41,
         add: 0x6a,
@@ -176,4 +190,21 @@ const importdesc = {
         return [0x00, funcidx(x)];
     },
 };
-export { code, codesec, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, i32, import_, importdesc, importsec, instr, locals, module, name, section, typeidx, typesec, valtype, vec, };
+const globalidx = u32;
+const mut = {
+    const: 0x00,
+    var: 0x01,
+};
+// t:valtype  m:mut
+function globaltype(t, m) {
+    return [t, m];
+}
+// gt:globaltype  e:expr
+function global(gt, e) {
+    return [gt, e];
+}
+// glob*:vec(global)
+function globalsec(globs) {
+    return section(SECTION_ID_GLOBAL, vec(globs));
+}
+export { blocktype, code, codesec, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, locals, module, mut, name, section, typeidx, typesec, valtype, vec, };

package/index.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from "bun:test";
 
 import {
   BytecodeFragment,
+  blocktype,
   code,
   codesec,
   export_,
@@ -12,16 +13,27 @@ import {
   funcidx,
   funcsec,
   functype,
+  global,
+  globalsec,
+  globaltype,
+  i32,
   import_,
   importdesc,
   importsec,
   instr,
   module,
+  mut,
   typeidx,
   typesec,
   valtype,
 } from "./index";
 
+const PI = 3.141592653589793115997963468544185161590576171875;
+
+function fragmentToUInt8Array(frag: BytecodeFragment): Uint8Array {
+  return Uint8Array.from((frag as any).flat(Infinity));
+}
+
 test("simple modules", async () => {
   const makeModule = (paramTypes, resultTypes, body) => {
     const mod = module([
@@ -30,7 +42,7 @@ test("simple modules", async () => {
       exportsec([export_("main", exportdesc.func(0))]),
       codesec([code(func([], body))]),
     ]);
-    return Uint8Array.from(mod.flat(Infinity));
+    return fragmentToUInt8Array(mod);
   };
   const runMain = async (bytes, args) => {
     const { instance } = await WebAssembly.instantiate(bytes);
@@ -74,7 +86,7 @@ test("imports", async () => {
         code(func([], [instr.local.get, 0, instr.call, funcidx(0), instr.end])),
       ]),
     ]);
-    return Uint8Array.from(mod.flat(Infinity));
+    return fragmentToUInt8Array(mod);
   };
 
   const { instance } = await WebAssembly.instantiate(makeModule(), {
@@ -90,23 +102,108 @@ test("imports", async () => {
 });
 
 test("f64", async () => {
-  const PI = 3.141592653589793115997963468544185161590576171875;
   const makeModule = () => {
     const mod = module([
       typesec([functype([], [valtype.f64])]),
-      funcsec([typeidx(0), typeidx(0)]),
+      funcsec([typeidx(0), typeidx(0), typeidx(0)]),
       exportsec([
         export_("pi", exportdesc.func(0)),
         export_("nan", exportdesc.func(1)),
+        export_("one", exportdesc.func(2)),
       ]),
       codesec([
         code(func([], [instr.f64.const, f64(PI), instr.end])),
         code(func([], [instr.f64.const, f64(Number.NaN), instr.end])),
+        code(func([], [instr.f64.const, f64(1), instr.end])),
       ]),
     ]);
-    return Uint8Array.from(mod.flat(Infinity));
+    return fragmentToUInt8Array(mod);
   };
   const { instance } = await WebAssembly.instantiate(makeModule());
   expect(instance.exports.pi()).toBe(PI);
   expect(instance.exports.nan()).toBe(Number.NaN);
+  expect(instance.exports.one()).toBe(1);
+});
+
+test("globals", async () => {
+  const makeModule = () => {
+    const mod = module([
+      typesec([
+        functype([], [valtype.f64]), // pi
+        functype([], [valtype.i32]), // getVar
+        functype([], []), // incVar
+      ]),
+      funcsec([typeidx(0), typeidx(1), typeidx(2)]),
+      globalsec([
+        global(globaltype(valtype.f64, mut.const), [
+          instr.f64.const,
+          f64(PI),
+          instr.end,
+        ]),
+        global(globaltype(valtype.i32, mut.var), [
+          instr.i32.const,
+          i32(0),
+          instr.end,
+        ]),
+      ]),
+      exportsec([
+        export_("pi", exportdesc.func(0)),
+        export_("getVar", exportdesc.func(1)),
+        export_("incVar", exportdesc.func(2)),
+      ]),
+      codesec([
+        code(func([], [instr.global.get, 0, instr.end])), // pi
+        code(func([], [instr.global.get, 1, instr.end])), // getVar
+        code(
+          // prettier-ignore
+          func([], [
+              instr.global.get, 1,
+              instr.i32.const, 1,
+              instr.i32.add,
+              instr.global.set, 1,
+              instr.end,
+            ],
+          ),
+        ), // incVar
+      ]),
+    ]);
+    return fragmentToUInt8Array(mod);
+  };
+
+  const { exports } = (await WebAssembly.instantiate(makeModule())).instance;
+  expect(exports.pi()).toBe(PI);
+  expect(exports.getVar()).toBe(0);
+  exports.incVar();
+  expect(exports.getVar()).toBe(1);
+});
+
+test("if", async () => {
+  const makeModule = () => {
+    const mod = module([
+      typesec([functype([valtype.i32], [valtype.f64])]),
+      funcsec([typeidx(0)]),
+      exportsec([export_("maybePi", exportdesc.func(0))]),
+      codesec([
+        code(
+          func(
+            [],
+            // prettier-ignore
+            [
+              instr.local.get, 0,
+              instr.if, blocktype(valtype.f64),
+              instr.f64.const, f64(PI),
+              instr.else,
+              instr.f64.const, f64(0),
+              instr.end,
+              instr.end,
+            ],
+          ),
+        ),
+      ]),
+    ]);
+    return fragmentToUInt8Array(mod);
+  };
+  const { exports } = (await WebAssembly.instantiate(makeModule())).instance;
+  expect(exports.maybePi(1)).toBe(PI);
+  expect(exports.maybePi(0)).toBe(0);
 });

package/index.ts

@@ -1,6 +1,7 @@
 const SECTION_ID_TYPE = 1;
 const SECTION_ID_IMPORT = 2;
 const SECTION_ID_FUNCTION = 3;
+const SECTION_ID_GLOBAL = 6;
 const SECTION_ID_EXPORT = 7;
 const SECTION_ID_CODE = 10;
 
@@ -40,6 +41,11 @@ enum valtype {
   f64 = 0x7c,
 }
 
+// t: valtype
+function blocktype(t?: valtype): number {
+  return t ?? 0x40;
+}
+
 function vec<T extends BytecodeFragment>(elements: T): BytecodeFragment {
   return [u32(elements.length), ...elements];
 }
@@ -100,6 +106,9 @@ const exportdesc = {
   func(idx: number): BytecodeFragment {
     return [0x00, funcidx(idx)];
   },
+  global(idx: number): BytecodeFragment {
+    return [0x03, globalidx(idx)];
+  },
 };
 
 function module(sections): BytecodeFragment {
@@ -112,6 +121,8 @@ enum numtype {
 
 const instr = {
   nop: 0x01,
+  if: 0x04,
+  else: 0x05,
   end: 0x0b,
   call: 0x10,
 
@@ -120,6 +131,11 @@ const instr = {
     set: 0x21,
     tee: 0x22,
   },
+  global: {
+    get: 0x23,
+    set: 0x24,
+  },
+
   i32: {
     const: 0x41,
     add: 0x6a,
@@ -222,7 +238,30 @@ const importdesc = {
   },
 };
 
+const globalidx = u32;
+
+const mut = {
+  const: 0x00,
+  var: 0x01,
+};
+
+// t:valtype  m:mut
+function globaltype(t, m) {
+  return [t, m];
+}
+
+// gt:globaltype  e:expr
+function global(gt, e) {
+  return [gt, e];
+}
+
+// glob*:vec(global)
+function globalsec(globs) {
+  return section(SECTION_ID_GLOBAL, vec(globs));
+}
+
 export {
+  blocktype,
   BytecodeFragment,
   code,
   codesec,
@@ -234,6 +273,9 @@ export {
   funcidx,
   funcsec,
   functype,
+  global,
+  globalsec,
+  globaltype,
   i32,
   import_,
   importdesc,
@@ -241,6 +283,7 @@ export {
   instr,
   locals,
   module,
+  mut,
   name,
   section,
   typeidx,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wasmgroundup/emit",
   "description": "A library for creating binary-encoded WebAssembly modules",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {