porffor 0.2.0-fbab1de → 0.2.0-fdf0fc5

package/compiler/2c.js

@@ -1,24 +1,106 @@
-import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from "./log.js";
 
 const CValtype = {
-  i8: 'char',
-  i16: 'unsigned short', // presume all i16 stuff is unsigned
-  i32: 'long',
-  i32_u: 'unsigned long',
-  i64: 'long long',
-  i64_u: 'unsigned long long',
+  i8: 'i8',
+  i16: 'i16',
+  i32: 'i32',
+  u32: 'u32',
+  i64: 'i64',
+  u64: 'u64',
 
-  f32: 'float',
-  f64: 'double',
+  f32: 'f32',
+  f64: 'f64',
 
   undefined: 'void'
 };
 
+const alwaysPreface = `typedef uint8_t i8;
+typedef uint16_t i16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+typedef float f32;
+typedef double f64;
+
+f64 NAN = 0e+0/0e+0;
+
+struct ReturnValue {
+  ${CValtype.f64} value;
+  ${CValtype.i32} type;
+};\n\n`;
+
+// todo: is memcpy/etc safe with host endianness?
+
+// all:
+// immediates: ['align', 'offset']
+const CMemFuncs = {
+  [Opcodes.i32_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i32],
+    returns: false
+  },
+  [Opcodes.i32_store16]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i16],
+    returns: false
+  },
+  [Opcodes.i32_store8]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i8],
+    returns: false
+  },
+
+  [Opcodes.i32_load]: {
+    c: `${CValtype.i32} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load16_u]: {
+    c: `${CValtype.i16} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load8_u]: {
+    c: `${CValtype.i8} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+
+  [Opcodes.f64_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.f64],
+    returns: false
+  },
+  [Opcodes.f64_load]: {
+    c: `${CValtype.f64} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.f64
+  },
+};
+
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
+const invValtype = inv(Valtype);
 
 for (const x in CValtype) {
   if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
@@ -32,15 +114,22 @@ const todo = msg => {
     }
   }
 
-  throw new TodoError(`todo: ${msg}`);
+  throw new TodoError(msg);
 };
 
 const removeBrackets = str => {
-  if (str.startsWith('(long)(unsigned long)')) return '(long)(unsigned long)(' + removeBrackets(str.slice(22, -1)) + ')';
+  // return str;
+  // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
+
+  for (const x in CValtype) {
+    const p = `(${x})`;
+    if (str.startsWith(p)) return p + removeBrackets(str.slice(p.length));
+  }
+
   return str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
 };
 
-export default ({ funcs, globals, tags, exceptions, pages }) => {
+export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -56,12 +145,11 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
   }
 
   const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
+  const prepend = new Map(), prependMain = new Map();
 
-  // TODO: make type i16
-  let out = `struct ReturnValue {
-  ${CValtype.f64} value;
-  ${CValtype.i32} type;
-};\n\n`;
+  includes.set('stdint.h', true);
+
+  let out = ``;
 
   for (const x in globals) {
     const g = globals[x];
@@ -70,6 +158,15 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     out += ';\n';
   }
 
+  if (pages.size > 0) {
+    prepend.set('_memory', `char _memory[${pages.size * pageSize}];\n`);
+    includes.set('string.h', true);
+  }
+
+  if (data.length > 0) {
+    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+  }
+
   // for (const [ x, p ] of pages) {
     // out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
     // out += ';\n';
@@ -78,7 +175,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
   if (out) out += '\n';
 
   let depth = 1;
-  const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
+  let brDepth = 0;
+  const line = (str, semi = true) => out += `${' '.repeat(depth * 2 + brDepth * 2)}${str}${semi ? ';' : ''}\n`;
   const lines = lines => {
     for (const x of lines) {
       out += `${' '.repeat(depth * 2)}${x}\n`;
@@ -111,6 +209,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     return tmp;
   };
 
+  let brId = 0;
+
   for (const f of funcs) {
     depth = 1;
 
@@ -124,7 +224,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     const returns = f.returns.length > 0;
 
     const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? 'double' : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+
+    if (f.name === 'main') {
+      out += [...prependMain.values()].join('\n');
+      if (prependMain.size > 0) out += '\n\n';
+    }
 
     const localKeys = Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).slice(f.params.length).sort((a, b) => f.locals[a].idx - f.locals[b].idx);
     for (const x of localKeys) {
@@ -134,11 +239,58 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
     if (localKeys.length !== 0) out += '\n';
 
+    const rets = [];
+    const runOnEnd = [];
+
     let vals = [];
-    const endNeedsCurly = [], ignoreEnd = [];
-    let beginLoop = false, lastCond = false, ifTernary = false;
+    const endNeedsCurly = [];
+    const brs = [];
+    let lastCond = false;
+
+    // let brDepth = 0;
+
+    const blockStart = (i, loop) => {
+      // reset "stack"
+      // vals = [];
+
+      rets.push(i[1]);
+
+      const br = brId++;
+      brs.push(br);
+      if (loop) {
+        line(`j${br}:;`, false);
+        runOnEnd.push(null);
+      } else {
+        runOnEnd.push(() => line(`j${br}:;`, false));
+      }
+
+      if (i[1] !== Blocktype.void) line(`${CValtype[i[1]]} _r${br}`);
+
+      brDepth++;
+    };
+
+    const highlight = i => {
+      const surrounding = 6;
+
+      const decomp = decompile(f.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, f.locals, f.params, f.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+      const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+      let longest = 0;
+      for (let j = 0; j < decomp.length; j++) {
+        longest = Math.max(longest, noAnsi(decomp[j]).length);
+      }
+
+      const middle = Math.floor(decomp.length / 2);
+      decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+      console.log('\x1B[90m...\x1B[0m');
+      console.log(decomp.join('\n'));
+      console.log('\x1B[90m...\x1B[0m\n');
+    };
+
     for (let _ = 0; _ < f.wasm.length; _++) {
       const i = f.wasm[_];
+      if (!i || !i[0]) continue;
 
       if (invOperatorOpcode[i[0]]) {
         const b = vals.pop();
@@ -160,12 +312,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
         switch (i[1]) {
           // i32_trunc_sat_f64_s
           case 0x02:
-            vals.push(`(${CValtype.i32})${vals.pop()}`);
+            vals.push(`(${CValtype.i32})(${vals.pop()})`);
             break;
 
           // i32_trunc_sat_f64_u
           case 0x03:
-            vals.push(`(${CValtype.i32})(${CValtype.i32_u})${vals.pop()}`);
+            vals.push(`(${CValtype.u32})(${vals.pop()})`);
             break;
         }
 
@@ -176,12 +328,19 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
       switch (i[0]) {
         case Opcodes.i32_const:
         case Opcodes.i64_const:
-          vals.push(read_signedLEB128(i.slice(1)).toString());
+          // vals.push(read_signedLEB128(i.slice(1)).toString());
+          vals.push(new String(read_signedLEB128(i.slice(1)).toString()));
+          vals.at(-1).offset = _;
           break;
 
-        case Opcodes.f64_const:
-          vals.push(read_ieee754_binary64(i.slice(1)).toExponential());
+        case Opcodes.f64_const: {
+          // const val = read_ieee754_binary64(i.slice(1)).toExponential();
+          const val = new String(read_ieee754_binary64(i.slice(1)).toExponential());
+          // vals.push(val == 'NaN' ? 'NAN' : val);
+          vals.push(val == 'NaN' ? new String('NAN') : val);
+          vals.at(-1).offset = _;
           break;
+        }
 
         case Opcodes.local_get:
           vals.push(`${invLocals[i[1]]}`);
@@ -192,9 +351,9 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
           break;
 
         case Opcodes.local_tee:
-          // line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
-          // vals.push(`${invLocals[i[1]]}`);
-          vals.push(`((${invLocals[i[1]]} = ${vals.pop()}))`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
+          vals.push(`${invLocals[i[1]]}`);
+          // vals.push(`((${invLocals[i[1]]} = ${vals.pop()}))`);
           break;
 
         case Opcodes.global_get:
@@ -207,78 +366,102 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(int)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          vals.push(`(${CValtype.i32})(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
           break;
 
         case Opcodes.f64_convert_i32_u:
         case Opcodes.f64_convert_i32_s:
         case Opcodes.f64_convert_i64_u:
         case Opcodes.f64_convert_i64_s:
-          // int to double
-          vals.push(`(double)${vals.pop()}`);
+          // int to f64
+          vals.push(`(${CValtype.f64})(${removeBrackets(vals.pop())})`);
           break;
 
+        case Opcodes.i32_eqz:
+          if (lastCond) {
+            vals.push(`!(${removeBrackets(vals.pop())})`);
+          } else {
+            let cond = '(' + removeBrackets(vals.pop());
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `${cond.slice(`(${CValtype.i32})`.length)}) == 0e+0`;
+              else cond += ') == 0';
+            vals.push(cond);
+          }
+          lastCond = true;
+          continue;
+
         case Opcodes.return:
           // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
           line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
-        case Opcodes.if:
+        case Opcodes.if: {
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
-              else cond += ' == 1';
-          }
-
-          ifTernary = i[1] !== Blocktype.void;
-          if (ifTernary) {
-            ifTernary = cond;
-            break;
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
           }
 
-          if (beginLoop) {
-            beginLoop = false;
-            line(`while (${cond}) {`, false);
-
-            depth++;
-            endNeedsCurly.push(true);
-            ignoreEnd.push(false, true);
-            break;
-          }
+          line(`// if ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
 
           line(`if (${cond}) {`, false);
 
           depth++;
           endNeedsCurly.push(true);
-          ignoreEnd.push(false);
           break;
+        }
 
-        case Opcodes.else:
-          if (ifTernary) break;
+        case Opcodes.else: {
+          const br = brs.at(-1);
+          const ret = rets.at(-1);
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            // vals.push(`_r${br}`);
+          }
 
           depth--;
           line(`} else {`, false);
           depth++;
+
+          // reset "stack"
+          // vals = [];
           break;
+        }
 
-        case Opcodes.loop:
-          // not doing properly, fake a while loop
-          beginLoop = true;
+        case Opcodes.loop: {
+          line(`// loop ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, true);
+          endNeedsCurly.push(false);
           break;
+        }
 
-        case Opcodes.end:
-          if (ignoreEnd.pop()) break;
+        case Opcodes.end: {
+          const br = brs.pop();
+          const ret = rets.pop();
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            vals.push(`_r${br}`);
+          }
 
-          if (ifTernary) {
-            const b = vals.pop();
-            const a = vals.pop();
-            vals.push(`${ifTernary} ? ${a} : ${b}`);
-            break;
+          const enc = endNeedsCurly.pop() === true;
+          if (enc) {
+            depth--;
+            line('}', false);
           }
 
-          depth--;
-          if (endNeedsCurly.pop() === true) line('}', false);
+          brDepth--;
+
+          line(`// end`, false);
+
+          const roe = runOnEnd.pop();
+          if (roe) roe();
+
           break;
+        }
 
         case Opcodes.call:
           let func = funcs.find(x => x.index === i[1]);
@@ -286,7 +469,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
             const importFunc = importFuncs[i[1]];
             switch (importFunc.name) {
               case 'print':
-                line(`printf("%f\\n", ${vals.pop()})`);
+                // line(`printf("%f\\n", ${vals.pop()})`);
+                line(`printf("${valtype === 'f64' ? '%g' : '%i'}\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
               case 'printChar':
@@ -349,13 +533,74 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           vals.pop();
           break;
 
-        case Opcodes.br:
-          // ignore
-          // reset "stack"
-          vals = [];
+        case Opcodes.block:
+          line(`// block ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
+          endNeedsCurly.push(false);
+          break;
+
+        case Opcodes.br: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.pop())}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+
+          // // reset "stack"
+          // vals = [];
+          break;
+        }
+
+        case Opcodes.br_if: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+
+          let cond = removeBrackets(vals.pop());
+          if (!lastCond) {
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
+          }
+
+          line(`if (${cond}) {`, false);
+          depth++;
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.at(-1))}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+          depth--;
+          line(`}`, false);
+
           break;
+        }
+
+        case Opcodes.throw: {
+          const id = vals.pop();
+
+          line(`printf("Uncaught ${exceptions[id].constructor}: ${exceptions[id].message}\\n")`);
+          line(`exit(1)`);
+
+          includes.set('stdlib.h', true);
+
+          break;
+        }
 
         default:
+          if (CMemFuncs[i[0]]) {
+            const name = invOpcodes[i[0]];
+            const func = CMemFuncs[i[0]];
+            if (!prepend.has(name)) {
+              prepend.set(name, `${func.returns || 'void'} ${name}(${CValtype.i32} align, ${CValtype.i32} offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
+              // generate func c and prepend
+            }
+
+            const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
+
+            let args = [];
+            for (let j = 0; j < func.args.length; j++) args.unshift(removeBrackets(vals.pop()));
+
+            if (func.returns !== false) {
+              vals.push(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            } else line(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            break;
+          }
+
           log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
           // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
       }
@@ -379,7 +624,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
 
-  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + out;
+  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
-  return out;
+  return out.trim();
 };

package/compiler/{sections.js → assemble.js}

@@ -1,8 +1,9 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
-import { number } from './embedding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, ieee754_binary64, unsignedLEB128_into, signedLEB128_into, ieee754_binary64_into } from './encoding.js';
+// import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from "./log.js";
+import Prefs from './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -26,12 +27,12 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   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 compileHints = Prefs.compileHints;
+  if (compileHints) log.warning('assemble', '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]}`);
+    if (Prefs.optLog) log('assemble', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
     if (optLevel >= 1 && typeCache[hash] !== undefined) return typeCache[hash];
 
     const type = [ FuncType, ...encodeVector(params), ...encodeVector(returns) ];
@@ -44,7 +45,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   let importFuncs = [];
 
-  if (optLevel < 1) {
+  if (optLevel < 1 || !Prefs.treeshakeWasmImports) {
     importFuncs = importedFuncs;
   } else {
     let imports = new Map();
@@ -79,11 +80,11 @@ export default (funcs, globals, tags, pages, data, flags) => {
   }
   globalThis.importFuncs = importFuncs;
 
-  if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  if (Prefs.optLog) log('assemble', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(x.name.startsWith('profile') ? Valtype.i32 : valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
   );
 
   const funcSection = createSection(
@@ -95,18 +96,65 @@ export default (funcs, globals, tags, pages, data, flags) => {
   // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
   const chSection = !compileHints ? [] : customSection(
     'compilationHints',
-    // for now just do everything as optimise eager
+    // for now just do everything as optimize 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 ]))
-  );
+  // const t0 = performance.now();
+
+  // specially optimized assembly for globals as this version is much (>5x) faster than traditional createSection(...)
+  const globalsValues = Object.values(globals);
+
+  let globalSection = [];
+  if (globalsValues.length > 0) {
+    let data = unsignedLEB128(globalsValues.length);
+    for (let i = 0; i < globalsValues.length; i++) {
+      const global = globalsValues[i];
+
+      switch (global.type) {
+        case Valtype.i32:
+          if (i > 0) data.push(Opcodes.end, Valtype.i32, 0x01, Opcodes.i32_const);
+            else data.push(Valtype.i32, 0x01, Opcodes.i32_const);
+
+          signedLEB128_into(global.init ?? 0, data);
+          break;
+
+        case Valtype.i64:
+          if (i > 0) data.push(Opcodes.end, Valtype.i64, 0x01, Opcodes.i64_const);
+            else data.push(Valtype.i64, 0x01, Opcodes.i64_const);
+
+          signedLEB128_into(global.init ?? 0, data);
+          break;
+
+        case Valtype.f64:
+          if (i > 0) data.push(Opcodes.end, Valtype.f64, 0x01, Opcodes.f64_const);
+            else data.push(Valtype.f64, 0x01, Opcodes.f64_const);
+
+          ieee754_binary64_into(global.init ?? 0, data);
+          break;
+      }
+    }
+
+    data.push(Opcodes.end);
+
+    globalSection.push(Section.global);
+
+    unsignedLEB128_into(data.length, globalSection);
+    globalSection = globalSection.concat(data);
+  }
+
+  // if (Prefs.profileCompiler) {
+  //   const log = console.log;
+  //   console.log = function () {
+  //     log.apply(this, arguments);
+  //     console.log = log;
+  //     console.log(`  a. assembled global section in ${(performance.now() - t0).toFixed(2)}ms\n`);
+  //   };
+  // }
 
   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 (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
   if (optLevel === 0) pages.set('O0 precaution', 0);
 
   const usesMemory = pages.size > 0;
@@ -169,7 +217,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     unsignedLEB128(data.length)
   );
 
-  if (process.argv.includes('-sections')) console.log({
+  if (Prefs.sections) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),