porffor 0.0.0-d650361 → 0.0.0-e975d7a

package/compiler/sections.js

@@ -1,5 +1,5 @@
 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';
 
@@ -20,7 +20,7 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
-export default (funcs, globals, tags, pages, flags) => {
+export default (funcs, globals, tags, pages, data, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
@@ -105,6 +105,8 @@ 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);
+
   const usesMemory = pages.size > 0;
   const memorySection = !usesMemory ? [] : createSection(
     Section.memory,
@@ -155,13 +157,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([
@@ -175,6 +188,8 @@ export default (funcs, globals, tags, pages, flags) => {
     ...tagSection,
     ...globalSection,
     ...exportSection,
-    ...codeSection
+    ...dataCountSection,
+    ...codeSection,
+    ...dataSection
   ]);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.0.0-d650361",
+  "version": "0.0.0-e975d7a",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/runner/info.js

@@ -36,7 +36,7 @@ const print = str => {
 };
 
 const t0 = performance.now();
-const { wasm, exports } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
+const { wasm, exports, pages } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
 
 if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
@@ -51,4 +51,39 @@ if (!process.argv.includes('-no-run')) {
 }
 
 if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
-if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+
+if (!raw && process.argv.includes('-mem') && exports.$) {
+  console.log();
+
+  let lastMemory, lastPages;
+  const PageSize = 65536;
+  const memoryToString = mem => {
+    let out = '';
+    const pages = lastPages.length;
+    const wasmPages = mem.buffer.byteLength / PageSize;
+
+    out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KiB\x1B[0m for ${pages} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n`;
+
+    const buf = new Uint8Array(mem.buffer);
+
+    for (let i = 0; i < pages; i++) {
+      out += `\x1B[36m${lastPages[i]}\x1B[2m | \x1B[0m`;
+
+      for (let j = 0; j < 50; j++) {
+        const val = buf[i * pageSize + j];
+        if (val === 0) out += '\x1B[2m';
+        out += val.toString(16).padStart(2, '0');
+        if (val === 0) out += '\x1B[0m';
+        out += ' ';
+      }
+      out += '\n';
+    }
+
+    return out;
+  };
+
+  lastPages = [...pages.keys()];
+  lastMemory = exports.$;
+  console.log(memoryToString(lastMemory));
+}