porffor 0.14.0-f67c123a1 → 0.16.0-a2e115b05

package/compiler/index.js

@@ -12,14 +12,7 @@ globalThis.decompile = decompile;
 const logFuncs = (funcs, globals, exceptions) => {
   console.log('\n' + underline(bold('funcs')));
 
-  const startIndex = funcs.sort((a, b) => a.index - b.index)[0].index;
   for (const f of funcs) {
-    console.log(`${underline(f.name)} (${f.index - startIndex})`);
-
-    console.log(`params: ${f.params.map((_, i) => Object.keys(f.locals)[Object.values(f.locals).indexOf(Object.values(f.locals).find(x => x.idx === i))]).join(', ')}`);
-    console.log(`returns: ${f.returns.length > 0 ? true : false}`);
-    console.log(`locals: ${Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).map(x => `${x} (${f.locals[x].idx})`).join(', ')}`);
-    console.log();
     console.log(decompile(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
   }
 
@@ -44,12 +37,14 @@ export default (code, flags) => {
   opt(funcs, globals, pages, tags, exceptions);
   if (Prefs.profileCompiler) console.log(`3. optimized in ${(performance.now() - t2).toFixed(2)}ms`);
 
-  if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
+  // if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
   const wasm = assemble(funcs, globals, tags, pages, data, flags);
   if (Prefs.profileCompiler) console.log(`4. assembled in ${(performance.now() - t3).toFixed(2)}ms`);
 
+  if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
+
   if (Prefs.allocLog) {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
     const bytes = wasmPages * 65536;
@@ -89,7 +84,8 @@ export default (code, flags) => {
       else compiler = [ compiler ];
 
     const tmpfile = 'porffor_tmp.c';
-    const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-ffast-math', '-fno-exceptions' ];
+    const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO ];
+    if (!Prefs.compiler) args.push('-flto=thin', '-march=native', '-s', '-ffast-math', '-fno-exceptions', '-fno-ident', '-fno-asynchronous-unwind-tables', '-ffunction-sections', '-fdata-sections', '-Wl,--gc-sections');
 
     const c = toc(out);
     fs.writeFileSync(tmpfile, c);

package/compiler/opt.js

@@ -108,7 +108,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
   for (const f of funcs) {
     const wasm = f.wasm;
 
-    const lastType = f.locals['#last_type'];
+    const lastType = f.locals['#last_type']?.idx;
 
     let runs = (+Prefs.optWasmRuns) || 2; // todo: how many by default?
     while (runs > 0) {
@@ -248,7 +248,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
         }
 
         // remove setting last type if it is never gotten
-        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType?.idx) {
+        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType) {
           // replace this inst with drop
           wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
           if (i > 0) i--;

package/compiler/parse.js

@@ -7,10 +7,10 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
   globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
 }
 
-const file = process.argv.slice(2).find(x => x[0] !== '-');
+const file = process.argv.slice(2).find(x => x[0] !== '-' && !['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(x));
 
 // should we try to support types (while parsing)
-const types = Prefs.parseTypes || file?.endsWith('.ts');
+const types = Prefs.parseTypes || Prefs.t || file?.endsWith('.ts');
 globalThis.typedInput = types && Prefs.optTypes;
 
 // todo: review which to use by default

package/compiler/precompile.js

@@ -18,9 +18,9 @@ const compile = async (file, [ _funcs, _globals ]) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--bytestring', '--todo-time=compile', '--no-aot-pointer-opt', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--parse-types', '--opt-types'];
+  let args = ['--bytestring', '--todo-time=compile', '--truthy=no_nan_negative', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--fast-length', '--parse-types', '--opt-types'];
   if (first.startsWith('// @porf')) {
-    args = args.concat(first.slice('// @porf '.length).split(' '));
+    args = first.slice('// @porf '.length).split(' ').concat(args);
   }
   process.argv = argv.concat(args);
 
@@ -111,8 +111,9 @@ ${funcs.map(x => {
     ${x.returnType != null ? `returnType: ${JSON.stringify(x.returnType)}` : 'typedReturns: true'},
     locals: ${JSON.stringify(Object.values(x.locals).slice(x.params.length).map(x => x.type))},
     localNames: ${JSON.stringify(Object.keys(x.locals))},
-${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)}` : ''}
-  };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n')
+${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)},` : ''}
+${x.table ? `    table: true` : ''}
+  };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}
 };`;
 };

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports', 'alwaysMemory' ];
+const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused' ];
 
 let cache = {};
 const obj = new Proxy({}, {
@@ -6,7 +6,7 @@ const obj = new Proxy({}, {
     // intentionally misses with undefined values cached
     if (cache[p]) return cache[p];
 
-    return cache[p] = (() => {
+    const ret = (() => {
       // fooBar -> foo-bar
       const name = p[0] === '_' ? p : p.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
       const prefix = name.length === 1 ? '-' : '--';
@@ -19,6 +19,10 @@ const obj = new Proxy({}, {
       if (onByDefault.includes(p)) return true;
       return undefined;
     })();
+
+    // do not cache in web demo as args are changed live
+    if (!globalThis.document) cache[p] = ret;
+    return ret;
   }
 });
 

package/compiler/prototype.js

@@ -16,7 +16,7 @@ export const PrototypeFuncs = function() {
 
   this[TYPES.array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    at: (pointer, length, wIndex, iTmp) => [
+    at: (pointer, length, wIndex, wType, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
       [ Opcodes.local_tee, iTmp ],
@@ -47,31 +47,39 @@ export const PrototypeFuncs = function() {
       [ Opcodes.end ],
 
       [ Opcodes.local_get, iTmp ],
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
       // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
+    push: (pointer, length, wNewMember, wType, iTmp, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
-      // generated wasm for new member
+      // store value
+      [ Opcodes.local_get, iTmp ],
       ...wNewMember,
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
 
-      // store in memory
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      // store type
+      [ Opcodes.local_get, iTmp ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // bump array length by 1 and return it
       ...length.setI32([
@@ -93,7 +101,7 @@ export const PrototypeFuncs = function() {
       // ...length.get()
     ],
 
-    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
+    pop: (pointer, length, _1, _2, iTmp, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
@@ -121,13 +129,18 @@ export const PrototypeFuncs = function() {
       // load last element
       ...(unusedValue() ? [] : [
         ...length.getCachedI32(),
-        ...number(ValtypeSize[valtype], Valtype.i32),
+        ...number(ValtypeSize[valtype] + 1, Valtype.i32),
         [ Opcodes.i32_mul ],
 
         ...pointer,
         [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
 
-        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
       ])
     ],
 
@@ -153,8 +166,12 @@ export const PrototypeFuncs = function() {
       ]),
 
       // load first element
+      // todo/perf: unusedValue opt
       ...pointer,
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      ...pointer,
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // offset page by -1 ind
       // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
@@ -170,13 +187,13 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_add ],
 
       // src = base array index + length size + an index
-      ...number(ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize.i32 + ValtypeSize[valtype] + 1, Valtype.i32),
       ...pointer,
       [ Opcodes.i32_add ],
 
       // size = new length * sizeof element
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
 
@@ -194,7 +211,7 @@ export const PrototypeFuncs = function() {
       // ]),
     ],
 
-    fill: (pointer, length, wElement, iTmp) => [
+    fill: (pointer, length, wElement, wType, iTmp, iTmp2) => [
       ...wElement,
       [ Opcodes.local_set, iTmp ],
 
@@ -206,7 +223,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_sub ],
 
       // * sizeof value
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       ...length.setCachedI32(),
@@ -224,17 +241,25 @@ export const PrototypeFuncs = function() {
 
       [ Opcodes.loop, Blocktype.void ],
 
-      // set element using pointer
+      // calculate offset
       ...length.getCachedI32(),
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp2 ],
 
+      // store value
+      [ Opcodes.local_get, iTmp2 ],
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128( ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store type
+      [ Opcodes.local_get, iTmp2 ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // pointer - sizeof value
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_sub ],
 
       ...length.setCachedI32(),
@@ -254,12 +279,16 @@ export const PrototypeFuncs = function() {
   };
 
   this[TYPES.array].at.local = Valtype.i32;
+  this[TYPES.array].push.returnType = TYPES.number;
   this[TYPES.array].push.noArgRetLength = true;
+  this[TYPES.array].push.local = Valtype.i32;
+  this[TYPES.array].pop.local = Valtype.i32;
   this[TYPES.array].fill.local = valtypeBinary;
+  this[TYPES.array].fill.local2 = Valtype.i32;
   this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
-    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+    at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -317,7 +346,7 @@ export const PrototypeFuncs = function() {
     },
 
     // todo: out of bounds properly
-    charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+    charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -347,127 +376,124 @@ export const PrototypeFuncs = function() {
       ];
     },
 
-    charCodeAt: (pointer, length, wIndex, iTmp) => {
-      return [
-        ...wIndex,
-        Opcodes.i32_to,
-
-        ...(zeroChecks.charcodeat ? [] : [
-          [ Opcodes.local_set, iTmp ],
+    charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+      ...wIndex,
+      Opcodes.i32_to,
 
-          // index < 0
-          ...(noUnlikelyChecks ? [] : [
-            [ Opcodes.local_get, iTmp ],
-            ...number(0, Valtype.i32),
-            [ Opcodes.i32_lt_s ],
-          ]),
+      ...(zeroChecks.charcodeat ? [] : [
+        [ Opcodes.local_set, iTmp ],
 
-          // index >= length
+        // index < 0
+        ...(noUnlikelyChecks ? [] : [
           [ Opcodes.local_get, iTmp ],
-          ...length.getCachedI32(),
-          [ Opcodes.i32_ge_s ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+        ]),
 
-          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-          [ Opcodes.if, Blocktype.void ],
-          ...number(valtype === 'i32' ? -1 : NaN),
-          [ Opcodes.br, 1 ],
-          [ Opcodes.end ],
+        // index >= length
+        [ Opcodes.local_get, iTmp ],
+        ...length.getCachedI32(),
+        [ Opcodes.i32_ge_s ],
 
-          [ Opcodes.local_get, iTmp ],
-        ]),
+        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        [ Opcodes.if, Blocktype.void ],
+        ...number(valtype === 'i32' ? -1 : NaN),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ],
 
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
+        [ Opcodes.local_get, iTmp ],
+      ]),
 
-        ...pointer,
-        [ Opcodes.i32_add ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
 
-        // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
-        Opcodes.i32_from_u
-      ];
-    },
+      ...pointer,
+      [ Opcodes.i32_add ],
 
-    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 ],
+      // load current string ind {arg}
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      Opcodes.i32_from_u
+    ],
 
-        // use cached length as end pointer
-        ...length.getCachedI32(),
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
-        ...pointer,
-        [ Opcodes.i32_add ],
-        ...length.setCachedI32(),
+    isWellFormed: (pointer, length, _1, _2, iTmp, iTmp2) => [
+      // 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.loop, Blocktype.void ],
 
-        [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
 
-        [ Opcodes.local_get, iTmp ],
-        [ 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 ],
+      [ Opcodes.local_get, iTmp ],
+      [ 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 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(0),
-        [ Opcodes.br, 3 ],
-        [ Opcodes.end ],
+      // 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 ],
 
-        // bump index again since gone through two valid chars
-        [ Opcodes.local_get, iTmp ],
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, iTmp ],
+      // 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(0),
+      [ Opcodes.br, 3 ],
+      [ Opcodes.end ],
 
-        [ Opcodes.end ],
+      // bump index again since gone through two valid chars
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
-        // 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 ],
+      [ Opcodes.end ],
 
-        ...length.getCachedI32(), // end pointer
-        [ Opcodes.i32_ne ],
-        [ Opcodes.br_if, 0 ],
+      // 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 ],
 
-        [ Opcodes.end ],
+      ...length.getCachedI32(), // end pointer
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 0 ],
 
-        // return true
-        ...number(1)
-      ]
-    }
+      [ Opcodes.end ],
+
+      // return true
+      ...number(1)
+    ]
   };
 
   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.returnType = TYPES.number;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
   this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
@@ -477,7 +503,7 @@ export const PrototypeFuncs = function() {
 
   if (Prefs.bytestring) {
     this[TYPES.bytestring] = {
-      at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+      at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
@@ -533,7 +559,7 @@ export const PrototypeFuncs = function() {
       },
 
       // todo: out of bounds properly
-      charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+      charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
@@ -560,55 +586,52 @@ export const PrototypeFuncs = function() {
         ];
       },
 
-      charCodeAt: (pointer, length, wIndex, iTmp) => {
-        return [
-          ...wIndex,
-          Opcodes.i32_to,
-
-          ...(zeroChecks.charcodeat ? [] : [
-            [ Opcodes.local_set, iTmp ],
+      charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+        ...wIndex,
+        Opcodes.i32_to,
 
-            // index < 0
-            ...(noUnlikelyChecks ? [] : [
-              [ Opcodes.local_get, iTmp ],
-              ...number(0, Valtype.i32),
-              [ Opcodes.i32_lt_s ],
-            ]),
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
 
-            // index >= length
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
             [ Opcodes.local_get, iTmp ],
-            ...length.getCachedI32(),
-            [ Opcodes.i32_ge_s ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
 
-            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-            [ Opcodes.if, Blocktype.void ],
-            ...number(valtype === 'i32' ? -1 : NaN),
-            [ Opcodes.br, 1 ],
-            [ Opcodes.end ],
+          // index >= length
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-            [ Opcodes.local_get, iTmp ],
-          ]),
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(valtype === 'i32' ? -1 : NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-          ...pointer,
-          [ Opcodes.i32_add ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-          // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
-          Opcodes.i32_from_u
-        ];
-      },
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      isWellFormed: () => {
-        return [
-          // we know it must be true as it is a bytestring lol
-          ...number(1)
-        ]
-      }
+        // load current string ind {arg}
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ],
+
+      isWellFormed: () => [
+        // we know it must be true as it is a bytestring lol
+        ...number(1)
+      ]
     };
 
     this[TYPES.bytestring].at.local = Valtype.i32;
     this[TYPES.bytestring].at.returnType = TYPES.bytestring;
     this[TYPES.bytestring].charAt.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charCodeAt.returnType = TYPES.number;
     this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
     this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;