porffor 0.0.0-d650361 → 0.0.0-e975d7a

package/compiler/codeGen.js

@@ -1,9 +1,9 @@
 import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { signedLEB128, unsignedLEB128 } from "./encoding.js";
+import { ieee754_binary64, signedLEB128, unsignedLEB128 } from "./encoding.js";
 import { operatorOpcode } from "./expression.js";
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
 import { PrototypeFuncs } from "./prototype.js";
-import { number, i32x4 } from "./embedding.js";
+import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
 import parse from "./parse.js";
 import * as Rhemyn from "../rhemyn/compile.js";
 
@@ -326,6 +326,8 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
+const isIntOp = op => op[0] >= 0xb7 && op[0] <= 0xba;
+
 const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
     '||': falsy,
@@ -338,6 +340,32 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   // generic structure for {a} OP {b}
   // -->
   // _ = {a}; if (OP_CHECK) {b} else _
+
+  // if we can, use int tmp and convert at the end to help prevent unneeded conversions
+  // (like if we are in an if condition - very common)
+  const leftIsInt = isIntOp(left[left.length - 1]);
+  const rightIsInt = isIntOp(right[right.length - 1]);
+
+  const canInt = leftIsInt && rightIsInt;
+
+  if (canInt) {
+    // remove int -> float conversions from left and right
+    left.pop();
+    right.pop();
+
+    return [
+      ...left,
+      [ Opcodes.local_tee, localTmp(scope, 'logictmpi', Valtype.i32) ],
+      ...checks[op](scope, [], leftType, true),
+      [ Opcodes.if, Valtype.i32 ],
+      ...right,
+      [ Opcodes.else ],
+      [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
+      [ Opcodes.end ],
+      Opcodes.i32_from
+    ];
+  }
+
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
@@ -361,6 +389,9 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
+  const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
+  if (aotWFA) addVarMeta(name, { wellFormed: undefined });
+
   if (assign) {
     const pointer = arrays.get(name ?? '$undeclared');
 
@@ -588,12 +619,12 @@ const compareStrings = (scope, left, right) => {
   ];
 };
 
-const truthy = (scope, wasm, type) => {
+const truthy = (scope, wasm, type, int = false) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    ...number(1)
+    ...number(1, int ? Valtype.i32 : valtypeBinary)
   ];
 
   if (type === TYPES.string) {
@@ -609,8 +640,8 @@ const truthy = (scope, wasm, type) => {
       // if length != 0
       /* [ Opcodes.i32_eqz ],
       [ Opcodes.i32_eqz ], */
-      Opcodes.i32_from_u
-    ]
+      ...(int ? [] : [ Opcodes.i32_from_u ])
+    ];
   }
 
   // if != 0
@@ -623,12 +654,12 @@ const truthy = (scope, wasm, type) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
+const falsy = (scope, wasm, type, int = false) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    ...number(0)
+    ...number(0, int ? Valtype.i32 : valtypeBinary)
   ];
 
   if (type === TYPES.string) {
@@ -643,7 +674,7 @@ const falsy = (scope, wasm, type) => {
 
       // if length == 0
       [ Opcodes.i32_eqz ],
-      Opcodes.i32_from_u
+      ...(int ? [] : [ Opcodes.i32_from_u ])
     ]
   }
 
@@ -651,31 +682,29 @@ const falsy = (scope, wasm, type) => {
   return [
     ...wasm,
 
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    ...(int ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz, Opcodes.i32_from_u ])
   ];
 };
 
-const nullish = (scope, wasm, type) => {
+const nullish = (scope, wasm, type, int = false) => {
   // undefined
   if (type === TYPES.undefined) return [
     ...wasm,
     [ Opcodes.drop ],
-    ...number(1)
+    ...number(1, int ? Valtype.i32 : valtypeBinary)
   ];
 
   // null (if object and = "0")
   if (type === TYPES.object) return [
     ...wasm,
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    ...(int ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz, Opcodes.i32_from_u ])
   ];
 
   // not
   return [
     ...wasm,
     [ Opcodes.drop ],
-    ...number(0)
+    ...number(0, int ? Valtype.i32 : valtypeBinary)
   ];
 };
 
@@ -989,12 +1018,38 @@ const generateLiteral = (scope, decl, global, name) => {
         case 'bigint': return number(TYPES.bigint);
       }
 
+      const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
+      let wellFormed = aotWFA ? true : undefined;
+
       const str = decl.value;
       const rawElements = new Array(str.length);
+      let j = 0;
       for (let i = 0; i < str.length; i++) {
         rawElements[i] = str.charCodeAt(i);
+
+        if (wellFormed) {
+          // check if surrogate
+          if ((str.charCodeAt(j) & 0xF800) === 0xD800) {
+            // unpaired trailing surrogate
+            if (str.charCodeAt(j) >= 0xDC00) {
+              wellFormed = false;
+            }
+
+            // unpaired leading surrogate
+            // if (++j >= str.length || (str.charCodeAt(j) & 0xFC00) != 0xDC00) {
+            if ((str.charCodeAt(++j) & 0xFC00) != 0xDC00) {
+              wellFormed = false;
+            }
+          }
+
+          j++;
+        }
       }
 
+      // console.log(wellFormed, str);
+
+      if (aotWFA) addVarMeta(name, { wellFormed });
+
       return makeArray(scope, {
         rawElements
       }, global, name, false, 'i16')[0];
@@ -1213,29 +1268,39 @@ const generateCall = (scope, decl, _global, _name) => {
     if (protoFunc.noArgRetLength && decl.arguments.length === 0) return arrayUtil.getLength(pointer)
 
     let protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[baseType]}_${protoName}_tmp`, protoFunc.local) : -1;
+    let protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[baseType]}_${protoName}_tmp2`, protoFunc.local2) : -1;
 
     // use local for cached i32 length as commonly used
     let lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
 
+    let lengthI32CacheUsed = false;
+
+    const protoOut = protoFunc(pointer, {
+      getCachedI32: () => {
+        lengthI32CacheUsed = true;
+        return [ [ Opcodes.local_get, lengthLocal ] ]
+      },
+      setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
+      get: () => arrayUtil.getLength(pointer),
+      getI32: () => arrayUtil.getLengthI32(pointer),
+      set: value => arrayUtil.setLength(pointer, value),
+      setI32: value => arrayUtil.setLengthI32(pointer, value)
+    }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
+      return makeArray(scope, {
+        rawElements: new Array(length)
+      }, _global, _name, true, itemType);
+    }, varMetadata.get(baseName));
+
     return [
       ...out,
 
-      ...arrayUtil.getLengthI32(pointer),
-      [ Opcodes.local_set, lengthLocal ],
+      ...(!lengthI32CacheUsed ? [] : [
+        ...arrayUtil.getLengthI32(pointer),
+        [ Opcodes.local_set, lengthLocal ],
+      ]),
 
       [ Opcodes.block, valtypeBinary ],
-      ...protoFunc(pointer, {
-        getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
-        setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
-        get: () => arrayUtil.getLength(pointer),
-        getI32: () => arrayUtil.getLengthI32(pointer),
-        set: value => arrayUtil.setLength(pointer, value),
-        setI32: value => arrayUtil.setLengthI32(pointer, value)
-      }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        return makeArray(scope, {
-          rawElements: new Array(length)
-        }, _global, _name, true, itemType);
-      }),
+      ...protoOut,
       [ Opcodes.end ]
     ];
   }
@@ -1306,7 +1371,7 @@ const generateCall = (scope, decl, _global, _name) => {
 const generateNew = (scope, decl, _global, _name) => {
   // hack: basically treat this as a normal call for builtins for now
   const name = mapName(decl.callee.name);
-  if (internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
+  if (internalConstrs[name] && !internalConstrs[name].notConstr) return internalConstrs[name].generate(scope, decl, _global, _name);
   if (!builtinFuncs[name]) return todo(`new statement is not supported yet`); // return todo(`new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
@@ -1324,12 +1389,12 @@ const unhackName = name => {
 };
 
 const generateVar = (scope, decl) => {
-  const out = [];
+  let out = [];
 
   const topLevel = scope.name === 'main';
 
   // global variable if in top scope (main) and var ..., or if wanted
-  const global = decl.kind === 'var';
+  const global = topLevel || decl._bare; // decl.kind === 'var';
   const target = global ? globals : scope.locals;
 
   for (const x of decl.declarations) {
@@ -1366,7 +1431,7 @@ const generateVar = (scope, decl) => {
 
     // x.init ??= DEFAULT_VALUE;
     if (x.init) {
-      out.push(...generate(scope, x.init, global, name));
+      out = out.concat(generate(scope, x.init, global, name));
 
       // if our value is the result of a function, infer the type from that func's return value
       if (out[out.length - 1][0] === Opcodes.call) {
@@ -1435,20 +1500,22 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
+  // arr[i] | str[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
-    // arr[i] | str[i]
     const name = decl.left.object.name;
     const pointer = arrays.get(name);
 
     const aotPointer = pointer != null;
 
-    const newValueTmp = localTmp(scope, '__member_setter_tmp');
+    const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
+    const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     const parentType = getNodeType(scope, decl.left.object);
 
-    const op = decl.operator.slice(0, -1);
     return [
-      ...(aotPointer ? number(0, Valtype.i32) : [
+      ...(aotPointer ? [] : [
         ...generate(scope, decl.left.object),
         Opcodes.i32_to_u
       ]),
@@ -1460,9 +1527,13 @@ const generateAssign = (scope, decl) => {
       Opcodes.i32_to_u,
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
-      [ Opcodes.i32_add ],
+      ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+      ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-      ...(op === '' ? generate(scope, decl.right, false, name) : performOp(scope, op, generate(scope, decl.left), generate(scope, decl.right), parentType === TYPES._array ? TYPES.number : TYPES.string, getNodeType(scope, decl.right), false, name, true)),
+      ...(op === '=' ? generate(scope, decl.right, false, name) : performOp(scope, op, [
+        [ Opcodes.local_get, pointerTmp ],
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ], generate(scope, decl.right), parentType === TYPES._array ? TYPES.number : TYPES.string, getNodeType(scope, decl.right), false, name, true)),
       [ Opcodes.local_tee, newValueTmp ],
 
       ...(parentType === TYPES._array ? [
@@ -1479,10 +1550,10 @@ const generateAssign = (scope, decl) => {
   const [ local, isGlobal ] = lookupName(scope, name);
 
   if (local === undefined) {
-    // todo: this should be a devtools/repl/??? only thing
+    // todo: this should be a sloppy mode only thing
 
     // only allow = for this
-    if (decl.operator !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
+    if (op !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
 
     if (builtinVars[name]) {
       // just return rhs (eg `NaN = 2`)
@@ -1491,14 +1562,14 @@ const generateAssign = (scope, decl) => {
 
     // set global and return (eg a = 2)
     return [
-      ...generateVar(scope, { kind: 'var', declarations: [ { id: { name }, init: decl.right } ] }),
+      ...generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name }, init: decl.right } ] }),
       [ Opcodes.global_get, globals[name].idx ]
     ];
   }
 
   typeStates[name] = getNodeType(scope, decl.right);
 
-  if (decl.operator === '=') {
+  if (op === '=') {
     // typeStates[name] = getNodeType(scope, decl.right);
 
     return [
@@ -1508,7 +1579,6 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  const op = decl.operator.slice(0, -1);
   if (op === '||' || op === '&&' || op === '??') {
     // todo: is this needed?
     // for logical assignment ops, it is not left @= right ~= left = left @ right
@@ -1964,10 +2034,28 @@ const StoreOps = {
   i16: Opcodes.i32_store16
 };
 
+let data = [];
+
+const compileBytes = (val, itemType, signed = true) => {
+  switch (itemType) {
+    case 'i8': return [ val % 256 ];
+    case 'i16': return [ val % 256, Math.floor(val / 256) ];
+
+    case 'i32':
+    case 'i64':
+      return enforceFourBytes(signedLEB128(val));
+
+    case 'f64': return ieee754_binary64(val);
+  }
+};
+
 const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
   const out = [];
 
+  let firstAssign = false;
   if (!arrays.has(name) || name === '$undeclared') {
+    firstAssign = true;
+
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
     arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`, itemType) * pageSize);
@@ -1978,8 +2066,29 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const useRawElements = !!decl.rawElements;
   const elements = useRawElements ? decl.rawElements : decl.elements;
 
+  const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
+  if (firstAssign && useRawElements) {
+    let bytes = compileBytes(length, 'i32');
+
+    if (!initEmpty) for (let i = 0; i < length; i++) {
+      if (elements[i] == null) continue;
+
+      bytes.push(...compileBytes(elements[i], itemType));
+    }
+
+    data.push({
+      offset: pointer,
+      bytes
+    });
+
+    // local value as pointer
+    out.push(...number(pointer));
+
+    return [ out, pointer ];
+  }
+
   // store length as 0th array
   out.push(
     ...number(0, Valtype.i32),
@@ -1988,7 +2097,6 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   );
 
   const storeOp = StoreOps[itemType];
-  const valtype = itemTypeToValtype[itemType];
 
   if (!initEmpty) for (let i = 0; i < length; i++) {
     if (elements[i] == null) continue;
@@ -2011,6 +2119,17 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', initEm
   return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
+let varMetadata = new Map();
+const addVarMeta = (_name, obj) => {
+  const name = _name ?? '$undeclared';
+  if (!varMetadata.has(name)) varMetadata.set(name, {});
+
+  const meta = varMetadata.get(name);
+  for (const k in obj) {
+    meta[k] = obj[k];
+  }
+};
+
 export const generateMember = (scope, decl, _global, _name) => {
   const type = getNodeType(scope, decl.object);
 
@@ -2351,6 +2470,18 @@ const internalConstrs = {
       ];
     },
     type: TYPES._array
+  },
+
+  __Array_of: {
+    // this is not a constructor but best fits internal structure here
+    generate: (scope, decl, global, name) => {
+      // Array.of(i0, i1, ...)
+      return generateArray(scope, {
+        elements: decl.arguments
+      }, global, name);
+    },
+    type: TYPES._array,
+    notConstr: true
   }
 };
 
@@ -2364,7 +2495,9 @@ export default program => {
   depth = [];
   typeStates = {};
   arrays = new Map();
+  varMetadata = new Map();
   pages = new Map();
+  data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
@@ -2441,5 +2574,5 @@ export default program => {
   // if blank main func and other exports, remove it
   if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(funcs.length - 1, 1);
 
-  return { funcs, globals, tags, exceptions, pages };
+  return { funcs, globals, tags, exceptions, pages, data };
 };

package/compiler/embedding.js

@@ -9,11 +9,15 @@ export const number = (n, valtype = valtypeBinary) => {
   }
 };
 
-const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const enforceOneByte = arr => [ arr[0] ?? 0 ];
+export const enforceTwoBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0 ];
+export const enforceFourBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0 ];
+export const enforceEightBytes = arr => [ arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0, arr[3] ?? 0, arr[4] ?? 0, arr[5] ?? 0, arr[6] ?? 0, arr[7] ?? 0 ];
+
 export const i32x4 = (a, b, c, d) => [ [
   ...Opcodes.v128_const,
-  ...enforceTwoBytes(signedLEB128(a)),
-  ...enforceTwoBytes(signedLEB128(b)),
-  ...enforceTwoBytes(signedLEB128(c)),
-  ...enforceTwoBytes(signedLEB128(d))
+  ...enforceFourBytes(signedLEB128(a)),
+  ...enforceFourBytes(signedLEB128(b)),
+  ...enforceFourBytes(signedLEB128(c)),
+  ...enforceFourBytes(signedLEB128(d))
 ] ];

package/compiler/index.js

@@ -59,7 +59,7 @@ export default (code, flags) => {
   if (flags.includes('info')) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
 
   const t1 = performance.now();
-  const { funcs, globals, tags, exceptions, pages } = codeGen(program);
+  const { funcs, globals, tags, exceptions, pages, data } = codeGen(program);
   if (flags.includes('info')) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
 
   if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
@@ -71,14 +71,14 @@ export default (code, flags) => {
   if (process.argv.includes('-opt-funcs')) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
-  const sections = produceSections(funcs, globals, tags, pages, flags);
+  const sections = produceSections(funcs, globals, tags, pages, data, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
   if (allocLog) {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
     const bytes = wasmPages * 65536;
     log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
-    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+    console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
   }
 
   const out = { wasm: sections, funcs, globals, tags, exceptions, pages };

package/compiler/opt.js

@@ -317,28 +317,24 @@ export default (funcs, globals) => {
         continue;
       }
 
-      if (i < 2) continue;
-      const lastLastInst = wasm[i - 2];
+      // remove unneeded before get with update exprs (n++, etc) when value is unused
+      if (i < wasm.length - 4 && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get && wasm[i + 1][0] === Opcodes.const && [Opcodes.add, Opcodes.sub].includes(wasm[i + 2][0]) && wasm[i + 3][0] === Opcodes.local_set && wasm[i + 3][1] === inst[1] && (wasm[i + 4][0] === Opcodes.drop || wasm[i + 4][0] === Opcodes.br)) {
+        // local.get 1
+        // local.get 1
+        // -->
+        // local.get 1
 
-      if (depth.length === 2) {
-        // hack to remove unneeded before get in for loops with (...; i++)
-        if (lastLastInst[0] === Opcodes.end && lastInst[1] === inst[1] && lastInst[0] === Opcodes.local_get && inst[0] === Opcodes.local_get) {
-          // local.get 1
-          // local.get 1
-          // -->
-          // local.get 1
-
-          // remove drop at the end as well
-          if (wasm[i + 4][0] === Opcodes.drop) {
-            wasm.splice(i + 4, 1);
-          }
+        // remove drop at the end as well
+        if (wasm[i + 4][0] === Opcodes.drop) wasm.splice(i + 4, 1);
 
-          wasm.splice(i, 1); // remove this inst (second get)
-          i--;
-          continue;
-        }
+        wasm.splice(i, 1); // remove this inst (second get)
+        i--;
+        continue;
       }
 
+      if (i < 2) continue;
+      const lastLastInst = wasm[i - 2];
+
       if (lastLastInst[1] === inst[1] && inst[0] === Opcodes.local_get && lastInst[0] === Opcodes.local_tee && lastLastInst[0] === Opcodes.local_set) {
         // local.set x
         // local.tee y

package/compiler/prototype.js

@@ -23,7 +23,9 @@ const TYPES = {
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
-  const noCCAChecks = process.argv.includes('-funsafe-no-charcodeat-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
@@ -203,7 +205,7 @@ export const PrototypeFuncs = function() {
   this[TYPES._array].fill.returnType = TYPES._array;
 
   this[TYPES.string] = {
-    at: (pointer, length, wIndex, iTmp, arrayShell) => {
+    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -258,7 +260,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 [
@@ -290,7 +292,7 @@ export const PrototypeFuncs = function() {
         ...wIndex,
         Opcodes.i32_to,
 
-        ...(noCCAChecks ? [] : [
+        ...(zeroChecks.charcodeat ? [] : [
           [ Opcodes.local_set, iTmp ],
 
           // index < 0
@@ -322,10 +324,87 @@ export const PrototypeFuncs = function() {
         Opcodes.i32_from_u
       ];
     },
+
+    isWellFormed: (pointer, length, wIndex, iTmp, iTmp2, arrayShell, { wellFormed } = {}) => {
+      // aot approx metadata
+      if (wellFormed != null) return number(wellFormed ? 1 : 0);
+
+      return [
+        // note: we cannot presume it begins as 0 in case it was used previously
+        ...number(0, Valtype.i32),
+        [ Opcodes.local_set, iTmp ],
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        [ Opcodes.block, Blocktype.void ],
+
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + 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 ],
+
+        // if not followed by trailing surrogate, return false
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(pointer + 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 ],
+
+        // 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 ],
+
+        [ 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(),
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 0 ],
+
+        [ 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.local = Valtype.i32;
+
+  this[TYPES.string].isWellFormed.local = Valtype.i32;
+  this[TYPES.string].isWellFormed.local2 = Valtype.i32;
+  this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 };