porffor 0.1.1 → 0.2.0-c6c8c81

package/compiler/parse.js

@@ -1,4 +1,27 @@
-const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
+import { log } from "./log.js";
+
+// deno compat
+if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
+  const textEncoder = new TextEncoder();
+  globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
+}
+
+// import { parse } from 'acorn';
+
+// todo: review which to use by default
+const parser = process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? 'acorn';
+const { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
+
+// supported parsers:
+// - acorn
+// - meriyah
+// - hermes-parser
+// - @babel/parser
+
+// should we try to support types (while parsing)
+const types = process.argv.includes('-types');
+
+if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parser', `passed -types with a parser (${parser}) which does not support`);
 
 export default (input, flags) => {
   return parse(input, {

package/compiler/prototype.js

@@ -5,27 +5,30 @@ import { UNDEFINED } from "./builtins.js";
 
 // todo: do not duplicate this
 const TYPES = {
-  number: 0xffffffffffff0,
-  boolean: 0xffffffffffff1,
-  string: 0xffffffffffff2,
-  undefined: 0xffffffffffff3,
-  object: 0xffffffffffff4,
-  function: 0xffffffffffff5,
-  symbol: 0xffffffffffff6,
-  bigint: 0xffffffffffff7,
+  number: 0x00,
+  boolean: 0x01,
+  string: 0x02,
+  undefined: 0x03,
+  object: 0x04,
+  function: 0x05,
+  symbol: 0x06,
+  bigint: 0x07,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0x10,
+  _regexp: 0x11
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
+  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+    else zeroChecks = {};
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    // todo: out of bounds (>) properly
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
@@ -36,7 +39,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
       [ Opcodes.if, Blocktype.void ],
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, iTmp ],
       [ Opcodes.end ],
@@ -47,7 +50,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
 
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_ge_s ],
       [ Opcodes.i32_or ],
 
@@ -60,36 +63,48 @@ export const PrototypeFuncs = function() {
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
+      ...pointer,
+      [ Opcodes.i32_add ],
+
       // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ]
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
     ],
 
     // todo: only for 1 argument
     push: (pointer, length, wNewMember) => [
       // get memory offset of array at last index (length)
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
+      ...pointer,
+      [ Opcodes.i32_add ],
+
       // generated wasm for new member
       ...wNewMember,
 
       // store in memory
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
 
       // bump array length by 1 and return it
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
-        [ Opcodes.i32_add ]
+        [ Opcodes.i32_add ],
+
+        ...length.setCachedI32(),
+        ...length.getCachedI32(),
       ]),
 
-      ...length.get
+      ...length.getCachedI32(),
+      Opcodes.i32_from_u
+
+      // ...length.get()
     ],
 
     pop: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -100,22 +115,28 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
-        [ Opcodes.i32_sub ]
+        [ Opcodes.i32_sub ],
+
+        ...length.setCachedI32(),
+        ...length.getCachedI32(),
       ]),
 
       // load last element
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 - ValtypeSize[valtype]) ]
+      ...pointer,
+      [ Opcodes.i32_add ],
+
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
     ],
 
     shift: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       Opcodes.i32_eqz,
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -126,29 +147,122 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
-        [ Opcodes.i32_sub ]
+        [ Opcodes.i32_sub ],
+
+        ...length.setCachedI32(),
+        ...length.getCachedI32(),
       ]),
 
       // load first element
-      ...number(0, Valtype.i32),
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+      ...pointer,
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // offset page by -1 ind
+      // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
+      // ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
+      // ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
+      // [ ...Opcodes.memory_copy, 0x00, 0x00 ]
 
       // offset all elements by -1 ind
-      ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
-      ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
-      ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
+
+      // dst = base array index + length size
+      ...number(ValtypeSize.i32, Valtype.i32),
+      ...pointer,
+      [ Opcodes.i32_add ],
+
+      // src = base array index + length size + an index
+      ...number(ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32),
+      ...pointer,
+      [ Opcodes.i32_add ],
+
+      // size = new length * sizeof element
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+
+      // move pointer + sizeof element
+      // ...pointer.get(),
+      // ...number(ValtypeSize[valtype], Valtype.i32),
+      // [ Opcodes.i32_add ],
+      // ...pointer.set(),
+
+      // // write length - 1 in new address
+      // ...length.setI32([
+      //   ...length.getCachedI32(),
+      //   ...number(1, Valtype.i32),
+      //   [ Opcodes.i32_sub ]
+      // ]),
+    ],
+
+    fill: (pointer, length, wElement, iTmp) => [
+      ...wElement,
+      [ Opcodes.local_set, iTmp ],
+
+      // use cached length i32 as pointer
+      ...length.getCachedI32(),
+
+      // length - 1 for indexes
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      // * sizeof value
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      ...length.setCachedI32(),
+
+      ...(noUnlikelyChecks ? [] : [
+        ...length.getCachedI32(),
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...pointer,
+        Opcodes.i32_from_u,
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // set element using pointer
+      ...length.getCachedI32(),
+      ...pointer,
+      [ Opcodes.i32_add ],
+
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128( ValtypeSize.i32) ],
+
+      // pointer - sizeof value
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      ...length.setCachedI32(),
+
+      // if pointer >= 0, loop
+      ...length.getCachedI32(),
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.br_if, 0 ],
+
+      [ Opcodes.end ],
+
+      // return this array
+      ...pointer,
+      Opcodes.i32_from_u,
     ]
   };
 
   this[TYPES._array].at.local = Valtype.i32;
   this[TYPES._array].push.noArgRetLength = true;
+  this[TYPES._array].fill.local = valtypeBinary;
+  this[TYPES._array].fill.returnType = TYPES._array;
 
   this[TYPES.string] = {
-    // todo: out of bounds properly
-    at: (pointer, length, wIndex, iTmp, arrayShell) => {
+    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -157,9 +271,9 @@ export const PrototypeFuncs = function() {
         [ Opcodes.drop ],
 
         ...number(0, Valtype.i32), // base 0 for store later
-        Opcodes.i32_to_u,
 
         ...wIndex,
+        Opcodes.i32_to_u,
         [ Opcodes.local_tee, iTmp ],
 
         // if index < 0: access index + array length
@@ -167,7 +281,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
         [ Opcodes.if, Blocktype.void ],
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, iTmp ],
         [ Opcodes.end ],
@@ -178,7 +292,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
 
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_ge_s ],
         [ Opcodes.i32_or ],
 
@@ -191,8 +305,11 @@ export const PrototypeFuncs = function() {
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 
+        ...pointer,
+        [ Opcodes.i32_add ],
+
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
 
         // store to new string ind 0
         [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
@@ -203,7 +320,7 @@ export const PrototypeFuncs = function() {
     },
 
     // todo: out of bounds properly
-    charAt: (pointer, length, wIndex, _, arrayShell) => {
+    charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -219,8 +336,11 @@ export const PrototypeFuncs = function() {
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 
+        ...pointer,
+        [ Opcodes.i32_add ],
+
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
 
         // store to new string ind 0
         [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
@@ -234,39 +354,126 @@ export const PrototypeFuncs = function() {
       return [
         ...wIndex,
         Opcodes.i32_to,
-        [ Opcodes.local_set, iTmp ],
 
-        // index < 0
-        ...(noUnlikelyChecks ? [] : [
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
+
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
+            [ Opcodes.local_get, iTmp ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
+
+          // index >= length
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
+
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
           [ Opcodes.local_get, iTmp ],
-          ...number(0, Valtype.i32),
-          [ Opcodes.i32_lt_s ],
         ]),
 
-        // index >= length
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        ...pointer,
+        [ Opcodes.i32_add ],
+
+        // load current string ind {arg}
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ];
+    },
+
+    isWellFormed: (pointer, length, wIndex, iTmp, iTmp2) => {
+      return [
+        // note: we cannot presume it begins as 0 in case it was used previously
+        ...pointer,
+        [ Opcodes.local_set, iTmp ],
+
+        // use cached length as end pointer
+        ...length.getCachedI32(),
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        ...pointer,
+        [ Opcodes.i32_add ],
+        ...length.setCachedI32(),
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        [ Opcodes.block, Blocktype.void ],
+
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.local_set, iTmp2 ],
+
+        // if not surrogate, continue
+        [ Opcodes.local_get, iTmp2 ],
+        ...number(0xF800, Valtype.i32),
+        [ Opcodes.i32_and ],
+        ...number(0xD800, Valtype.i32),
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 0 ],
+
+        // if not leading surrogate, return false
+        [ Opcodes.local_get, iTmp2 ],
+        ...number(0xDC00, Valtype.i32),
         [ Opcodes.i32_ge_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(0),
+        [ Opcodes.br, 3 ],
+        [ Opcodes.end ],
 
-        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        // if not followed by trailing surrogate, return false
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
+        ...number(0xFC00, Valtype.i32),
+        [ Opcodes.i32_and ],
+        ...number(0xDC00, Valtype.i32),
+        [ Opcodes.i32_ne ],
         [ Opcodes.if, Blocktype.void ],
-        ...number(NaN),
-        [ Opcodes.br, 1 ],
+        ...number(0),
+        [ Opcodes.br, 3 ],
         [ Opcodes.end ],
 
+        // bump index again since gone through two valid chars
         [ Opcodes.local_get, iTmp ],
         ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
 
-        // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
-        Opcodes.i32_from_u
-      ];
-    },
+        [ Opcodes.end ],
+
+        // bump pointer and loop if not at the end
+        [ Opcodes.local_get, iTmp ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, iTmp ],
+
+        ...length.getCachedI32(), // end pointer
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 0 ],
+
+        [ Opcodes.end ],
+
+        // return true
+        ...number(1)
+      ]
+    }
   };
 
-  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
+
+  this[TYPES.string].isWellFormed.local = Valtype.i32;
+  this[TYPES.string].isWellFormed.local2 = Valtype.i32;
+  this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 };

package/compiler/sections.js

@@ -1,18 +1,34 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal } from './encoding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
 import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
+import { log } from "./log.js";
 
 const createSection = (type, data) => [
   type,
   ...encodeVector(data)
 ];
 
-export default (funcs, globals, tags, pages, flags) => {
+const customSection = (name, data) => [
+  Section.custom,
+  ...encodeVector([...encodeString(name), ...data])
+];
+
+const chHint = (topTier, baselineTier, strategy) => {
+  // 1 byte of 4 2 bit components: spare, top tier, baseline tier, compilation strategy
+  // tiers: 0x00 = default, 0x01 = baseline (liftoff), 0x02 = optimized (turbofan)
+  // strategy: 0x00 = default, 0x01 = lazy, 0x02 = eager, 0x03 = lazy baseline, eager top tier
+  return (strategy | (baselineTier << 2) | (topTier << 4));
+};
+
+export default (funcs, globals, tags, pages, data, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
+  const compileHints = process.argv.includes('-compile-hints');
+  if (compileHints) log.warning('sections', 'compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
+
   const getType = (params, returns) => {
     const hash = `${params.join(',')}_${returns.join(',')}`;
     if (optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
@@ -36,7 +52,7 @@ export default (funcs, globals, tags, pages, flags) => {
     // tree shake imports
     for (const f of funcs) {
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] < importedFuncs.length) {
           const idx = inst[1];
           const func = importedFuncs[idx];
 
@@ -51,15 +67,17 @@ export default (funcs, globals, tags, pages, flags) => {
     // fix call indexes for non-imports
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
+      f.originalIndex = f.index;
       f.index -= delta;
 
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
@@ -73,6 +91,14 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(funcs.map(x => getType(x.params, x.returns))) // type indexes
   );
 
+  // compilation hints section - unspecd, v8 only
+  // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
+  const chSection = !compileHints ? [] : customSection(
+    'compilationHints',
+    // for now just do everything as optimise eager
+    encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
+  );
+
   const globalSection = Object.keys(globals).length === 0 ? [] : createSection(
     Section.global,
     encodeVector(Object.keys(globals).map(x => [ globals[x].type, 0x01, ...number(globals[x].init ?? 0, globals[x].type).flat(), Opcodes.end ]))
@@ -80,10 +106,13 @@ export default (funcs, globals, tags, pages, flags) => {
 
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
+  if (process.argv.includes('-always-memory') && pages.size === 0) pages.set('-always-memory', 0);
+  if (optLevel === 0) pages.set('O0 precaution', 0);
+
   const usesMemory = pages.size > 0;
   const memorySection = !usesMemory ? [] : createSection(
     Section.memory,
-    encodeVector([ [ 0x00, Math.ceil((pages.size * pageSize) / PageSize) ] ])
+    encodeVector([ [ 0x00, ...unsignedLEB128(Math.ceil((pages.size * pageSize) / PageSize)) ] ])
   );
 
   // export memory if used
@@ -121,7 +150,7 @@ export default (funcs, globals, tags, pages, flags) => {
 
       if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
 
-      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x !== null), Opcodes.end ]);
+      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x <= 0xff), Opcodes.end ]);
     }))
   );
 
@@ -130,13 +159,24 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(types)
   );
 
+  const dataSection = data.length === 0 ? [] : createSection(
+    Section.data,
+    encodeVector(data.map(x => [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ]))
+  );
+
+  const dataCountSection = data.length === 0 ? [] : createSection(
+    Section.data_count,
+    unsignedLEB128(data.length)
+  );
+
   if (process.argv.includes('-sections')) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),
     globalSection: globalSection.map(x => x.toString(16)),
     exportSection: exportSection.map(x => x.toString(16)),
-    codeSection: codeSection.map(x => x.toString(16))
+    codeSection: codeSection.map(x => x.toString(16)),
+    dataSection: dataSection.map(x => x.toString(16)),
   });
 
   return Uint8Array.from([
@@ -145,10 +185,13 @@ export default (funcs, globals, tags, pages, flags) => {
     ...typeSection,
     ...importSection,
     ...funcSection,
+    ...chSection,
     ...memorySection,
     ...tagSection,
     ...globalSection,
     ...exportSection,
-    ...codeSection
+    ...dataCountSection,
+    ...codeSection,
+    ...dataSection
   ]);
 };

package/compiler/wasmSpec.js

@@ -118,6 +118,7 @@ export const Opcodes = {
   i64_shl: 0x86,
   i64_shr_s: 0x87,
   i64_shr_u: 0x88,
+  i64_rotl: 0x89,
 
   f64_eq: 0x61,
   f64_ne: 0x62,
@@ -156,6 +157,8 @@ export const Opcodes = {
   f64_convert_i64_s: 0xb9,
   f64_convert_i64_u: 0xba,
 
+  f64_reinterpret_i64: 0xbf,
+
   i32_trunc_sat_f64_s: [ 0xfc, 0x02 ],
   i32_trunc_sat_f64_u: [ 0xfc, 0x03 ],