From 2723b1bd06d08530f5260d66540cf87c878a97e7 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 15:51:15 +0300
Subject: [PATCH 01/14] refactor

---
 src/module.ts | 78 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 51 insertions(+), 27 deletions(-)

diff --git a/src/module.ts b/src/module.ts
index f553229a22..416e687403 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -552,7 +552,9 @@ export class Module {
   v128(bytes: Uint8Array): ExpressionRef {
     assert(bytes.length == 16);
     var out = this.lit;
-    for (let i = 0; i < 16; ++i) binaryen.__i32_store8(out + i, bytes[i]);
+    for (let i = 0; i < 16; ++i) {
+      binaryen.__i32_store8(out + i, bytes[i]);
+    }
     binaryen._BinaryenLiteralVec128(out, out);
     return binaryen._BinaryenConst(this.ref, out);
   }
@@ -585,7 +587,9 @@ export class Module {
   ): ExpressionRef {
     var cStr = this.allocStringCached(name);
     var cArr = allocPtrArray(operands);
-    var ret = binaryen._BinaryenHost(this.ref, op, cStr, cArr, operands ? (<ExpressionRef[]>operands).length : 0);
+    var ret = binaryen._BinaryenHost(
+      this.ref, op, cStr, cArr, operands ? (<ExpressionRef[]>operands).length : 0
+    );
     binaryen._free(cArr);
     return ret;
   }
@@ -1095,7 +1099,15 @@ export class Module {
   ): FunctionRef {
     var cStr = this.allocStringCached(name);
     var cArr = allocPtrArray(varTypes);
-    var ret = binaryen._BinaryenAddFunction(this.ref, cStr, params, results, cArr, varTypes ? varTypes.length : 0, body);
+    var ret = binaryen._BinaryenAddFunction(
+      this.ref,
+      cStr,
+      params,
+      results,
+      cArr,
+      varTypes ? varTypes.length : 0,
+      body
+    );
     binaryen._free(cArr);
     return ret;
   }
@@ -1114,7 +1126,11 @@ export class Module {
 
   private hasTemporaryFunction: bool = false;
 
-  addTemporaryFunction(result: NativeType, paramTypes: NativeType[] | null, body: ExpressionRef): FunctionRef {
+  addTemporaryFunction(
+    result: NativeType,
+    paramTypes: NativeType[] | null,
+    body: ExpressionRef
+  ): FunctionRef {
     this.hasTemporaryFunction = assert(!this.hasTemporaryFunction);
     var tempName = this.allocStringCached("");
     var cArr = allocPtrArray(paramTypes);
@@ -1276,8 +1292,9 @@ export class Module {
     var offs = new Array<ExpressionRef>(k);
     var sizs = new Array<Index>(k);
     for (let i = 0; i < k; ++i) {
-      let buffer = segments[i].buffer;
-      let offset = segments[i].offset;
+      let segment = segments[i];
+      let buffer = segment.buffer;
+      let offset = segment.offset;
       segs[i] = allocU8Array(buffer);
       psvs[i] = 0; // no passive segments currently
       offs[i] = target == Target.WASM64
@@ -1289,12 +1306,16 @@ export class Module {
     var cArr2 = allocU8Array(psvs);
     var cArr3 = allocPtrArray(offs);
     var cArr4 = allocU32Array(sizs);
-    binaryen._BinaryenSetMemory(this.ref, initial, maximum, cStr, cArr1, cArr2, cArr3, cArr4, k, shared);
+    binaryen._BinaryenSetMemory(
+      this.ref, initial, maximum, cStr, cArr1, cArr2, cArr3, cArr4, k, shared
+    );
     binaryen._free(cArr4);
     binaryen._free(cArr3);
     binaryen._free(cArr2);
     binaryen._free(cArr1);
-    for (let i = k - 1; i >= 0; --i) binaryen._free(segs[i]);
+    for (let i = k - 1; i >= 0; --i) {
+      binaryen._free(segs[i]);
+    }
   }
 
   // table
@@ -1314,7 +1335,9 @@ export class Module {
       names[i] = this.allocStringCached(funcs[i]);
     }
     var cArr = allocPtrArray(names);
-    binaryen._BinaryenSetFunctionTable(this.ref, initial, maximum, cArr, numNames, offset);
+    binaryen._BinaryenSetFunctionTable(
+      this.ref, initial, maximum, cArr, numNames, offset
+    );
     binaryen._free(cArr);
   }
 
@@ -2256,20 +2279,20 @@ export function hasSideEffects(expr: ExpressionRef, features: FeatureFlags = Fea
 
 function allocU8Array(u8s: Uint8Array | null): usize {
   if (!u8s) return 0;
-  var numValues = u8s.length;
-  var ptr = binaryen._malloc(numValues);
-  var idx = ptr;
-  for (let i = 0; i < numValues; ++i) {
-    binaryen.__i32_store8(idx++, u8s[i]);
+  var len = u8s.length;
+  var ptr = binaryen._malloc(len);
+  for (let i = 0; i < len; ++i) {
+    binaryen.__i32_store8(ptr + i, u8s[i]);
   }
   return ptr;
 }
 
 function allocI32Array(i32s: i32[] | null): usize {
   if (!i32s) return 0;
-  var ptr = binaryen._malloc(i32s.length << 2);
+  var len = i32s.length;
+  var ptr = binaryen._malloc(len << 2);
   var idx = ptr;
-  for (let i = 0, k = i32s.length; i < k; ++i) {
+  for (let i = 0; i < len; ++i) {
     let val = i32s[i];
     binaryen.__i32_store(idx, val);
     idx += 4;
@@ -2279,9 +2302,10 @@ function allocI32Array(i32s: i32[] | null): usize {
 
 function allocU32Array(u32s: u32[] | null): usize {
   if (!u32s) return 0;
-  var ptr = binaryen._malloc(u32s.length << 2);
+  var len = u32s.length;
+  var ptr = binaryen._malloc(len << 2);
   var idx = ptr;
-  for (let i = 0, k = u32s.length; i < k; ++i) {
+  for (let i = 0; i < len; ++i) {
     let val = u32s[i];
     binaryen.__i32_store(idx, val);
     idx += 4;
@@ -2293,9 +2317,10 @@ function allocPtrArray(ptrs: usize[] | null): usize {
   if (!ptrs) return 0;
   // TODO: WASM64
   assert(ASC_TARGET != Target.WASM64);
-  var ptr = binaryen._malloc(ptrs.length << 2);
+  var len = ptrs.length;
+  var ptr = binaryen._malloc(len << 2);
   var idx = ptr;
-  for (let i = 0, k = ptrs.length; i < k; ++i) {
+  for (let i = 0, k = len; i < k; ++i) {
     let val = ptrs[i];
     binaryen.__i32_store(idx, <i32>val);
     idx += 4;
@@ -2329,7 +2354,7 @@ function stringLengthUTF8(str: string): usize {
 
 function allocString(str: string | null): usize {
   if (str === null) return 0;
-  var ptr = binaryen._malloc(stringLengthUTF8(str) + 1);
+  var ptr = binaryen._malloc(stringLengthUTF8(str) + 1) >>> 0;
   // the following is based on Emscripten's stringToUTF8Array
   var idx = ptr;
   for (let i = 0, k = str.length; i < k; ++i) {
@@ -2370,9 +2395,9 @@ function allocString(str: string | null): usize {
   return ptr;
 }
 
-function readBuffer(ptr: usize, length: i32): Uint8Array {
-  var ret = new Uint8Array(length);
-  for (let i = 0; i < length; ++i) {
+function readBuffer(ptr: usize, len: i32): Uint8Array {
+  var ret = new Uint8Array(len);
+  for (let i = 0; i < len; ++i) {
     ret[i] = binaryen.__i32_load8_u(ptr + <usize>i);
   }
   return ret;
@@ -2380,7 +2405,7 @@ function readBuffer(ptr: usize, length: i32): Uint8Array {
 
 export function readString(ptr: usize): string | null {
   if (!ptr) return null;
-  var arr = new Array<i32>();
+  var arr = new Array<u32>();
   // the following is based on Emscripten's UTF8ArrayToString
   var cp: u32;
   var u1: u32, u2: u32, u3: u32, u4: u32, u5: u32;
@@ -2416,12 +2441,11 @@ export function readString(ptr: usize): string | null {
       arr.push(cp);
     } else {
       let ch = cp - 0x10000;
-      arr.push(0xD800 | (ch >> 10));
+      arr.push(0xD800 | (ch >>> 10));
       arr.push(0xDC00 | (ch & 0x3FF));
     }
   }
   return String.fromCharCodes(arr);
-  // return String.fromCodePoints(arr);
 }
 
 /** Result structure of {@link Module#toBinary}. */

From eef16f2a0b0ea3a7ffda9fd489653914f9601626 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 16:28:33 +0300
Subject: [PATCH 02/14] more

---
 src/glue/binaryen.js         |  4 +-
 src/glue/js/collections.js   |  6 +--
 src/glue/js/float.js         |  8 ++--
 src/glue/js/i64.js           | 68 ++++++++++++++++----------------
 src/glue/wasm/collections.ts |  6 +--
 src/glue/wasm/float.ts       |  8 ++--
 src/glue/wasm/i64.ts         | 75 ++++++++++++++++--------------------
 src/module.ts                | 16 ++++++--
 8 files changed, 95 insertions(+), 96 deletions(-)

diff --git a/src/glue/binaryen.js b/src/glue/binaryen.js
index f173b76539..fc106ff8c8 100644
--- a/src/glue/binaryen.js
+++ b/src/glue/binaryen.js
@@ -9,7 +9,7 @@ module.exports = binaryen;
 
 const { Module } = require("../module");
 
-Module.prototype.toText = function() {
+Module.prototype.toText = function toText() {
   // NOTE: Conversion to StackIR can yield conversion artifacts like sequences
   // of unreachable statements not actually emitted by the compiler. Optimizing
   // StackIR removes these again, but may also suppress useless code emitted by
@@ -17,6 +17,6 @@ Module.prototype.toText = function() {
   return binaryen.wrapModule(this.ref).emitStackIR(/* optimize-stack-ir */ true);
 };
 
-Module.prototype.toAsmjs = function() {
+Module.prototype.toAsmjs = function toAsmjs() {
   return binaryen.wrapModule(this.ref).emitAsmjs();
 };
diff --git a/src/glue/js/collections.js b/src/glue/js/collections.js
index a94224f0a3..63a3b9499d 100644
--- a/src/glue/js/collections.js
+++ b/src/glue/js/collections.js
@@ -3,14 +3,14 @@
  * @license Apache-2.0
  */
 
-global.Map_keys = function(map) {
+global.Map_keys = function Map_keys(map) {
   return Array.from(map.keys());
 };
 
-global.Map_values = function(map) {
+global.Map_values = function Map_values(map) {
   return Array.from(map.values());
 };
 
-global.Set_values = function(set) {
+global.Set_values = function Set_values(set) {
   return Array.from(set.values());
 };
diff --git a/src/glue/js/float.js b/src/glue/js/float.js
index ee3992b149..0c32ed5a0e 100644
--- a/src/glue/js/float.js
+++ b/src/glue/js/float.js
@@ -9,22 +9,22 @@ const F64 = new Float64Array(1);
 const F32 = new Float32Array(F64.buffer);
 const I32 = new Int32Array(F64.buffer);
 
-global.f32_as_i32 = function(value) {
+global.f32_as_i32 = function f32_as_i32(value) {
   F32[0] = value;
   return I32[0];
 };
 
-global.i32_as_f32 = function(value) {
+global.i32_as_f32 = function i32_as_f32(value) {
   I32[0] = value;
   return F32[0];
 };
 
-global.f64_as_i64 = function(value) {
+global.f64_as_i64 = function f64_as_i64(value) {
   F64[0] = value;
   return i64_new(I32[0], I32[1]);
 };
 
-global.i64_as_f64 = function(value) {
+global.i64_as_f64 = function i64_as_f64(value) {
   I32[0] = i64_low(value);
   I32[1] = i64_high(value);
   return F64[0];
diff --git a/src/glue/js/i64.js b/src/glue/js/i64.js
index 47b634f59d..414025c674 100644
--- a/src/glue/js/i64.js
+++ b/src/glue/js/i64.js
@@ -11,31 +11,31 @@ global.i64_zero    = Long.ZERO;
 global.i64_one     = Long.ONE;
 global.i64_neg_one = Long.fromInt(-1);
 
-global.i64_new = function(lo, hi) {
+global.i64_new = function i64_new(lo, hi) {
   return Long.fromBits(lo, hi);
 };
 
-global.i64_low = function(value) {
+global.i64_low = function i64_low(value) {
   return value.low;
 };
 
-global.i64_high = function(value) {
+global.i64_high = function i64_high(value) {
   return value.high;
 };
 
-global.i64_add = function(left, right) {
+global.i64_add = function i64_add(left, right) {
   return left.add(right);
 };
 
-global.i64_sub = function(left, right) {
+global.i64_sub = function i64_sub(left, right) {
   return left.sub(right);
 };
 
-global.i64_mul = function(left, right) {
+global.i64_mul = function i64_mul(left, right) {
   return left.mul(right);
 };
 
-global.i64_pow = function(left, right) {
+global.i64_pow = function i64_pow(left, right) {
   var rightLo = right.low;
   var rightHi = right.high;
   if (rightHi <= 0) {
@@ -60,121 +60,121 @@ global.i64_pow = function(left, right) {
   return result;
 };
 
-global.i64_div = function(left, right) {
+global.i64_div = function i64_div(left, right) {
   return left.div(right);
 };
 
-global.i64_div_u = function(left, right) {
+global.i64_div_u = function i64_div_u(left, right) {
   return left.toUnsigned().div(right.toUnsigned()).toSigned();
 };
 
-global.i64_rem = function(left, right) {
+global.i64_rem = function i64_rem(left, right) {
   return left.mod(right);
 };
 
-global.i64_rem_u = function(left, right) {
+global.i64_rem_u = function i64_rem_u(left, right) {
   return left.toUnsigned().mod(right.toUnsigned()).toSigned();
 };
 
-global.i64_and = function(left, right) {
+global.i64_and = function i64_and(left, right) {
   return left.and(right);
 };
 
-global.i64_or = function(left, right) {
+global.i64_or = function i64_or(left, right) {
   return left.or(right);
 };
 
-global.i64_xor = function(left, right) {
+global.i64_xor = function i64_xor(left, right) {
   return left.xor(right);
 };
 
-global.i64_shl = function(left, right) {
+global.i64_shl = function i64_shl(left, right) {
   return left.shl(right);
 };
 
-global.i64_shr = function(left, right) {
+global.i64_shr = function i64_shr(left, right) {
   return left.shr(right);
 };
 
-global.i64_shr_u = function(left, right) {
+global.i64_shr_u = function i64_shr_u(left, right) {
   return left.shru(right);
 };
 
-global.i64_not = function(value) {
+global.i64_not = function i64_not(value) {
   return value.not();
 };
 
-global.i64_eq = function(left, right) {
+global.i64_eq = function i64_eq(left, right) {
   return left.eq(right);
 };
 
-global.i64_ne = function(left, right) {
+global.i64_ne = function i64_ne(left, right) {
   return left.ne(right);
 };
 
-global.i64_gt = function(left, right) {
+global.i64_gt = function i64_gt(left, right) {
   return left.gt(right);
 };
 
-global.i64_align = function(value, alignment) {
+global.i64_align = function i64_align(value, alignment) {
   assert(alignment && (alignment & (alignment - 1)) == 0);
   var mask = Long.fromInt(alignment - 1);
   return value.add(mask).and(mask.not());
 };
 
-global.i64_is_i8 = function(value) {
+global.i64_is_i8 = function i64_is_i8(value) {
   return value.high === 0 && (value.low >= 0 && value.low <= i8.MAX_VALUE)
       || value.high === -1 && (value.low >= i8.MIN_VALUE && value.low < 0);
 };
 
-global.i64_is_i16 = function(value) {
+global.i64_is_i16 = function i64_is_i16(value) {
   return value.high === 0 && (value.low >= 0 && value.low <= i16.MAX_VALUE)
       || value.high === -1 && (value.low >= i16.MIN_VALUE && value.low < 0);
 };
 
-global.i64_is_i32 = function(value) {
+global.i64_is_i32 = function i64_is_i32(value) {
   return (value.high === 0 && value.low >= 0)
       || (value.high === -1 && value.low < 0);
 };
 
-global.i64_is_u8 = function(value) {
+global.i64_is_u8 = function i64_is_u8(value) {
   return value.high === 0 && value.low >= 0 && value.low <= u8.MAX_VALUE;
 };
 
-global.i64_is_u16 = function(value) {
+global.i64_is_u16 = function i64_is_u16(value) {
   return value.high === 0 && value.low >= 0 && value.low <= u16.MAX_VALUE;
 };
 
-global.i64_is_u32 = function(value) {
+global.i64_is_u32 = function i64_is_u32(value) {
   return value.high === 0;
 };
 
-global.i64_is_bool = function(value) {
+global.i64_is_bool = function i64_is_bool(value) {
   return value.high === 0 && (value.low === 0 || value.low === 1);
 };
 
 const minSafeF32 = Long.fromNumber(f32.MIN_SAFE_INTEGER);
 const maxSafeF32 = Long.fromNumber(f32.MAX_SAFE_INTEGER);
 
-global.i64_is_f32 = function(value) {
+global.i64_is_f32 = function i64_is_f32(value) {
   return value.gte(minSafeF32) && value.lte(maxSafeF32);
 };
 
 const minSafeF64 = Long.fromNumber(f64.MIN_SAFE_INTEGER);
 const maxSafeF64 = Long.fromNumber(f64.MAX_SAFE_INTEGER);
 
-global.i64_is_f64 = function(value) {
+global.i64_is_f64 = function i64_is_f64(value) {
   return value.gte(minSafeF64) && value.lte(maxSafeF64);
 };
 
-global.i64_to_f32 = function(value) {
+global.i64_to_f32 = function i64_to_f32(value) {
   return global.Math.fround(value.toNumber());
 };
 
-global.i64_to_f64 = function(value) {
+global.i64_to_f64 = function i64_to_f64(value) {
   return value.toNumber();
 };
 
-global.i64_to_string = function(value, unsigned) {
+global.i64_to_string = function i64_to_string(value, unsigned) {
   return (unsigned ? value.toUnsigned() : value).toString();
 };
diff --git a/src/glue/wasm/collections.ts b/src/glue/wasm/collections.ts
index 11fe30208e..9862fc13fc 100644
--- a/src/glue/wasm/collections.ts
+++ b/src/glue/wasm/collections.ts
@@ -6,19 +6,19 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function Map_keys<K,V>(map: Map<K,V>): K[] {
   return map.keys(); // preliminary
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function Map_values<K,V>(map: Map<K,V>): V[] {
   return map.values(); // preliminary
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function Set_values<V>(set: Set<V>): V[] {
   return set.values(); // preliminary
 }
diff --git a/src/glue/wasm/float.ts b/src/glue/wasm/float.ts
index ad852e04fe..8df450b509 100644
--- a/src/glue/wasm/float.ts
+++ b/src/glue/wasm/float.ts
@@ -6,25 +6,25 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function f32_as_i32(value: f32): i32 {
   return reinterpret<i32>(value);
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i32_as_f32(value: i32): f32 {
   return reinterpret<f32>(value);
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function f64_as_i64(value: f64): i64 {
   return reinterpret<i64>(value);
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_as_f64(value: i64): f64 {
   return reinterpret<f64>(value);
 }
diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index ff69d03c18..84be82ca8f 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -14,37 +14,37 @@
 @global const i64_neg_one: i64 = -1;
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_new(lo: i32, hi: i32 = 0): i64 {
   return lo | (hi << 32);
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_low(value: i64): i32 {
   return <i32>value;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_high(value: i64): i32 {
   return <i32>(value >>> 32);
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_add(left: i64, right: i64): i64 {
   return left + right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_sub(left: i64, right: i64): i64 {
   return left - right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_mul(left: i64, right: i64): i64 {
   return left * right;
 }
@@ -68,91 +68,91 @@ function i64_pow(left: i64, right: i64): i64 {
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_div(left: i64, right: i64): i64 {
   return left / right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_div_u(left: i64, right: i64): i64 {
   return <u64>left / <u64>right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_rem(left: i64, right: i64): i64 {
   return left % right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_rem_u(left: i64, right: i64): i64 {
   return <u64>left % <u64>right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_and(left: i64, right: i64): i64 {
   return left & right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_or(left: i64, right: i64): i64 {
   return left | right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_xor(left: i64, right: i64): i64 {
   return left ^ right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_shl(left: i64, right: i64): i64 {
   return left << right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_shr(left: i64, right: i64): i64 {
   return left >> right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_shr_u(left: i64, right: i64): i64 {
   return left >>> right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_not(value: i64): i64 {
   return ~value;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_eq(left: i64, right: i64): bool {
   return left == right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_ne(left: i64, right: i64): bool {
   return left != right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_gt(left: i64, right: i64): bool {
   return left > right;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_align(value: i64, alignment: i64): i64 {
   var mask: i64 = alignment - 1;
   assert(alignment && (alignment & mask) == 0);
@@ -160,67 +160,67 @@ function i64_align(value: i64, alignment: i64): i64 {
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_i8(value: i64): bool {
   return value >= i8.MIN_VALUE && value <= <i64>i8.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_i16(value: i64): bool {
   return value >= i16.MIN_VALUE && value <= <i64>i16.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_i32(value: i64): bool {
   return value >= i32.MIN_VALUE && value <= <i64>i32.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_u8(value: i64): bool {
   return value >= 0 && value <= <i64>u8.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_u16(value: i64): bool {
   return value >= 0 && value <= <i64>u16.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_u32(value: i64): bool {
   return value >= 0 && value <= <i64>u32.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_bool(value: i64): bool {
   return value === 0 || value === 1;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_f32(value: i64): bool {
   return value >= <i64>f32.MIN_SAFE_INTEGER && value <= <i64>f32.MAX_SAFE_INTEGER;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_is_f64(value: i64): bool {
   return value >= <i64>f64.MIN_SAFE_INTEGER && value <= <i64>f64.MAX_SAFE_INTEGER;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_to_f32(value: i64): f32 {
   return <f32>value;
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_to_f64(value: i64): f64 {
   return <f64>value;
 }
@@ -230,14 +230,5 @@ import { CharCode } from "../../util";
 // @ts-ignore: decorator
 @global
 function i64_to_string(value: i64, unsigned: bool = false): string {
-  var chars = new Array<i32>();
-  if (!unsigned && value < 0) {
-    chars.push(CharCode.MINUS);
-    value = -value;
-  }
-  do {
-    chars.push(CharCode._0 + <i32>(<u64>value % 10));
-    value = <u64>value / 10;
-  } while (value);
-  return String.fromCharCodes(chars);
+  return (unsigned ? <u64>value : value).toString();
 }
diff --git a/src/module.ts b/src/module.ts
index 416e687403..beb24e893f 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -849,8 +849,12 @@ export class Module {
     var cStr = this.allocStringCached(target);
     var cArr = allocPtrArray(operands);
     var ret = isReturn
-      ? binaryen._BinaryenReturnCall(this.ref, cStr, cArr, operands ? operands.length : 0, returnType)
-      : binaryen._BinaryenCall(this.ref, cStr, cArr, operands ? operands.length : 0, returnType);
+      ? binaryen._BinaryenReturnCall(
+          this.ref, cStr, cArr, operands ? operands.length : 0, returnType
+        )
+      : binaryen._BinaryenCall(
+          this.ref, cStr, cArr, operands ? operands.length : 0, returnType
+        );
     binaryen._free(cArr);
     return ret;
   }
@@ -872,8 +876,12 @@ export class Module {
   ): ExpressionRef {
     var cArr = allocPtrArray(operands);
     var ret = isReturn
-      ? binaryen._BinaryenReturnCallIndirect(this.ref, index, cArr, operands ? operands.length : 0, params, results)
-      : binaryen._BinaryenCallIndirect(this.ref, index, cArr, operands ? operands.length : 0, params, results);
+      ? binaryen._BinaryenReturnCallIndirect(
+          this.ref, index, cArr, operands ? operands.length : 0, params, results
+        )
+      : binaryen._BinaryenCallIndirect(
+          this.ref, index, cArr, operands ? operands.length : 0, params, results
+        );
     binaryen._free(cArr);
     return ret;
   }

From 82d3faad46304c374d371f63dc15c1a202622a2d Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 16:32:57 +0300
Subject: [PATCH 03/14] fix

---
 src/glue/wasm/i64.ts | 2 --
 src/module.ts        | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index 84be82ca8f..89b438c1dd 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -225,8 +225,6 @@ function i64_to_f64(value: i64): f64 {
   return <f64>value;
 }
 
-import { CharCode } from "../../util";
-
 // @ts-ignore: decorator
 @global
 function i64_to_string(value: i64, unsigned: bool = false): string {
diff --git a/src/module.ts b/src/module.ts
index beb24e893f..c30fb7cad9 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2413,7 +2413,7 @@ function readBuffer(ptr: usize, len: i32): Uint8Array {
 
 export function readString(ptr: usize): string | null {
   if (!ptr) return null;
-  var arr = new Array<u32>();
+  var arr = new Array<i32>();
   // the following is based on Emscripten's UTF8ArrayToString
   var cp: u32;
   var u1: u32, u2: u32, u3: u32, u4: u32, u5: u32;

From 42f1869359d29609cda992f7c65c4625085411ae Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 16:50:55 +0300
Subject: [PATCH 04/14] remove redundant cases for allocString &
 stringLengthUTF8

---
 src/glue/wasm/i64.ts |  2 +-
 src/module.ts        | 24 ++++--------------------
 2 files changed, 5 insertions(+), 21 deletions(-)

diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index 89b438c1dd..1ece186cbb 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -226,7 +226,7 @@ function i64_to_f64(value: i64): f64 {
 }
 
 // @ts-ignore: decorator
-@global
+@global @inline
 function i64_to_string(value: i64, unsigned: bool = false): string {
   return (unsigned ? <u64>value : value).toString();
 }
diff --git a/src/module.ts b/src/module.ts
index c30fb7cad9..8824901eb7 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2344,17 +2344,13 @@ function stringLengthUTF8(str: string): usize {
       u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
     }
     if (u <= 0x7F) {
-      ++len;
+      len += 1;
     } else if (u <= 0x7FF) {
       len += 2;
     } else if (u <= 0xFFFF) {
       len += 3;
-    } else if (u <= 0x1FFFFF) {
-      len += 4;
-    } else if (u <= 0x3FFFFFF) {
-      len += 5;
     } else {
-      len += 6;
+      len += 4;
     }
   }
   return len;
@@ -2379,21 +2375,9 @@ function allocString(str: string | null): usize {
       binaryen.__i32_store8(idx++, (0xE0 |  (u >>> 12)      ) as u8);
       binaryen.__i32_store8(idx++, (0x80 | ((u >>>  6) & 63)) as u8);
       binaryen.__i32_store8(idx++, (0x80 | ( u         & 63)) as u8);
-    } else if (u <= 0x1FFFFF) {
-      binaryen.__i32_store8(idx++, (0xF0 |  (u >>> 18)      ) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>> 12) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>>  6) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ( u         & 63)) as u8);
-    } else if (u <= 0x3FFFFFF) {
-      binaryen.__i32_store8(idx++, (0xF8 |  (u >>> 24)      ) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>> 18) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>> 12) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>>  6) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ( u         & 63)) as u8);
     } else {
-      binaryen.__i32_store8(idx++, (0xFC |  (u >>> 30)      ) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>> 24) & 63)) as u8);
-      binaryen.__i32_store8(idx++, (0x80 | ((u >>> 18) & 63)) as u8);
+      assert(u < 0x200000, "Invalid Unicode code point during allocString");
+      binaryen.__i32_store8(idx++, (0xF0 |  (u >>> 18)      ) as u8);
       binaryen.__i32_store8(idx++, (0x80 | ((u >>> 12) & 63)) as u8);
       binaryen.__i32_store8(idx++, (0x80 | ((u >>>  6) & 63)) as u8);
       binaryen.__i32_store8(idx++, (0x80 | ( u         & 63)) as u8);

From f4debe65390573665df5ccaf6fa3f3beec3ee09e Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 17:00:42 +0300
Subject: [PATCH 05/14] what if simplify readString?

---
 src/module.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/module.ts b/src/module.ts
index 8824901eb7..5453e2b079 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2397,18 +2397,18 @@ function readBuffer(ptr: usize, len: i32): Uint8Array {
 
 export function readString(ptr: usize): string | null {
   if (!ptr) return null;
-  var arr = new Array<i32>();
+  var str = "";
   // the following is based on Emscripten's UTF8ArrayToString
   var cp: u32;
   var u1: u32, u2: u32, u3: u32, u4: u32, u5: u32;
   while (cp = binaryen.__i32_load8_u(ptr++)) {
     if (!(cp & 0x80)) {
-      arr.push(cp);
+      str += String.fromCharCode(cp);
       continue;
     }
     u1 = binaryen.__i32_load8_u(ptr++) & 63;
     if ((cp & 0xE0) == 0xC0) {
-      arr.push(((cp & 31) << 6) | u1);
+      str += String.fromCharCode(((cp & 31) << 6) | u1);
       continue;
     }
     u2 = binaryen.__i32_load8_u(ptr++) & 63;
@@ -2428,16 +2428,16 @@ export function readString(ptr: usize): string | null {
         }
       }
     }
-    arr.push(cp);
+    str += String.fromCharCode(cp);
     if (cp < 0x10000) {
-      arr.push(cp);
+      str += String.fromCharCode(cp);
     } else {
       let ch = cp - 0x10000;
-      arr.push(0xD800 | (ch >>> 10));
-      arr.push(0xDC00 | (ch & 0x3FF));
+      str += String.fromCharCode(0xD800 | (ch >>> 10)) +
+             String.fromCharCode(0xDC00 | (ch & 0x3FF));
     }
   }
-  return String.fromCharCodes(arr);
+  return str;
 }
 
 /** Result structure of {@link Module#toBinary}. */

From 9c976179743eefc563bc35d91cb98255ee1f5901 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 17:00:42 +0300
Subject: [PATCH 06/14] Revert "what if simplify readString?"

This reverts commit f4debe65390573665df5ccaf6fa3f3beec3ee09e.
---
 src/module.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/module.ts b/src/module.ts
index 5453e2b079..8824901eb7 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2397,18 +2397,18 @@ function readBuffer(ptr: usize, len: i32): Uint8Array {
 
 export function readString(ptr: usize): string | null {
   if (!ptr) return null;
-  var str = "";
+  var arr = new Array<i32>();
   // the following is based on Emscripten's UTF8ArrayToString
   var cp: u32;
   var u1: u32, u2: u32, u3: u32, u4: u32, u5: u32;
   while (cp = binaryen.__i32_load8_u(ptr++)) {
     if (!(cp & 0x80)) {
-      str += String.fromCharCode(cp);
+      arr.push(cp);
       continue;
     }
     u1 = binaryen.__i32_load8_u(ptr++) & 63;
     if ((cp & 0xE0) == 0xC0) {
-      str += String.fromCharCode(((cp & 31) << 6) | u1);
+      arr.push(((cp & 31) << 6) | u1);
       continue;
     }
     u2 = binaryen.__i32_load8_u(ptr++) & 63;
@@ -2428,16 +2428,16 @@ export function readString(ptr: usize): string | null {
         }
       }
     }
-    str += String.fromCharCode(cp);
+    arr.push(cp);
     if (cp < 0x10000) {
-      str += String.fromCharCode(cp);
+      arr.push(cp);
     } else {
       let ch = cp - 0x10000;
-      str += String.fromCharCode(0xD800 | (ch >>> 10)) +
-             String.fromCharCode(0xDC00 | (ch & 0x3FF));
+      arr.push(0xD800 | (ch >>> 10));
+      arr.push(0xDC00 | (ch & 0x3FF));
     }
   }
-  return str;
+  return String.fromCharCodes(arr);
 }
 
 /** Result structure of {@link Module#toBinary}. */

From d29c9438112f3e592d7de64d14f81afce36a6d0a Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 17:46:05 +0300
Subject: [PATCH 07/14] Faster?

---
 src/glue/js/collections.js | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/glue/js/collections.js b/src/glue/js/collections.js
index 63a3b9499d..ae3dc66787 100644
--- a/src/glue/js/collections.js
+++ b/src/glue/js/collections.js
@@ -4,13 +4,28 @@
  */
 
 global.Map_keys = function Map_keys(map) {
-  return Array.from(map.keys());
+  const arr = new Array(map.size);
+  let i = 0;
+  for (let key of map.keys()) {
+    arr[i++] = key;
+  }
+  return arr;
 };
 
 global.Map_values = function Map_values(map) {
-  return Array.from(map.values());
+  const arr = new Array(map.size);
+  let i = 0;
+  for (let value of map.values()) {
+    arr[i++] = value;
+  }
+  return arr;
 };
 
 global.Set_values = function Set_values(set) {
-  return Array.from(set.values());
+  const arr = new Array(set.size);
+  let i = 0;
+  for (let value of set.values()) {
+    arr[i++] = value;
+  }
+  return arr;
 };

From 9b535aaf2f9898780303bc6e43ec7d081c786868 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 17:46:05 +0300
Subject: [PATCH 08/14] Revert "Faster?"

This reverts commit d29c9438112f3e592d7de64d14f81afce36a6d0a.
---
 src/glue/js/collections.js | 21 +++------------------
 1 file changed, 3 insertions(+), 18 deletions(-)

diff --git a/src/glue/js/collections.js b/src/glue/js/collections.js
index ae3dc66787..63a3b9499d 100644
--- a/src/glue/js/collections.js
+++ b/src/glue/js/collections.js
@@ -4,28 +4,13 @@
  */
 
 global.Map_keys = function Map_keys(map) {
-  const arr = new Array(map.size);
-  let i = 0;
-  for (let key of map.keys()) {
-    arr[i++] = key;
-  }
-  return arr;
+  return Array.from(map.keys());
 };
 
 global.Map_values = function Map_values(map) {
-  const arr = new Array(map.size);
-  let i = 0;
-  for (let value of map.values()) {
-    arr[i++] = value;
-  }
-  return arr;
+  return Array.from(map.values());
 };
 
 global.Set_values = function Set_values(set) {
-  const arr = new Array(set.size);
-  let i = 0;
-  for (let value of set.values()) {
-    arr[i++] = value;
-  }
-  return arr;
+  return Array.from(set.values());
 };

From 7d634f81dbe316630f0091ec8ef9bc7d0068b54b Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 18:47:45 +0300
Subject: [PATCH 09/14] more refactorings

---
 src/module.ts | 58 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 45 insertions(+), 13 deletions(-)

diff --git a/src/module.ts b/src/module.ts
index 8824901eb7..af9aa22222 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -1277,7 +1277,9 @@ export class Module {
     var cStr1 = this.allocStringCached(internalName);
     var cStr2 = this.allocStringCached(externalModuleName);
     var cStr3 = this.allocStringCached(externalBaseName);
-    binaryen._BinaryenAddEventImport(this.ref, cStr1, cStr2, cStr3, attribute, params, results);
+    binaryen._BinaryenAddEventImport(
+      this.ref, cStr1, cStr2, cStr3, attribute, params, results
+    );
   }
 
   // memory
@@ -1762,10 +1764,14 @@ export class Module {
       case ExpressionId.GlobalGet: {
         let globalName = binaryen._BinaryenGlobalGetGetName(expr);
         if (!globalName) break;
-        return binaryen._BinaryenGlobalGet(this.ref, globalName, binaryen._BinaryenExpressionGetType(expr));
+        return binaryen._BinaryenGlobalGet(
+          this.ref, globalName, binaryen._BinaryenExpressionGetType(expr)
+        );
       }
       case ExpressionId.Load: {
-        if (!(nested1 = this.cloneExpression(binaryen._BinaryenLoadGetPtr(expr), noSideEffects, maxDepth))) {
+        if (!(nested1 = this.cloneExpression(
+          binaryen._BinaryenLoadGetPtr(expr), noSideEffects, maxDepth)
+        )) {
           break;
         }
         return (
@@ -1787,19 +1793,29 @@ export class Module {
         );
       }
       case ExpressionId.Unary: {
-        if (!(nested1 = this.cloneExpression(binaryen._BinaryenUnaryGetValue(expr), noSideEffects, maxDepth))) {
+        if (!(nested1 = this.cloneExpression(
+          binaryen._BinaryenUnaryGetValue(expr), noSideEffects, maxDepth)
+        )) {
           break;
         }
-        return binaryen._BinaryenUnary(this.ref, binaryen._BinaryenUnaryGetOp(expr), nested1);
+        return binaryen._BinaryenUnary(
+          this.ref, binaryen._BinaryenUnaryGetOp(expr), nested1
+        );
       }
       case ExpressionId.Binary: {
-        if (!(nested1 = this.cloneExpression(binaryen._BinaryenBinaryGetLeft(expr), noSideEffects, maxDepth))) {
+        if (!(nested1 = this.cloneExpression(
+          binaryen._BinaryenBinaryGetLeft(expr), noSideEffects, maxDepth)
+        )) {
           break;
         }
-        if (!(nested2 = this.cloneExpression(binaryen._BinaryenBinaryGetRight(expr), noSideEffects, maxDepth))) {
+        if (!(nested2 = this.cloneExpression(
+          binaryen._BinaryenBinaryGetRight(expr), noSideEffects, maxDepth)
+        )) {
           break;
         }
-        return binaryen._BinaryenBinary(this.ref, binaryen._BinaryenBinaryGetOp(expr), nested1, nested2);
+        return binaryen._BinaryenBinary(
+          this.ref, binaryen._BinaryenBinaryGetOp(expr), nested1, nested2
+        );
       }
     }
     return 0;
@@ -1809,7 +1825,12 @@ export class Module {
     return binaryen._BinaryenExpressionCopy(expr, this.ref);
   }
 
-  runExpression(expr: ExpressionRef, flags: ExpressionRunnerFlags, maxDepth: i32 = 50, maxLoopIterations: i32 = 1): ExpressionRef {
+  runExpression(
+    expr: ExpressionRef,
+    flags: ExpressionRunnerFlags,
+    maxDepth: i32 = 50,
+    maxLoopIterations: i32 = 1
+  ): ExpressionRef {
     var runner = binaryen._ExpressionRunnerCreate(this.ref, flags, maxDepth, maxLoopIterations);
     var precomp =  binaryen._ExpressionRunnerRunAndDispose(runner, expr);
     if (precomp) {
@@ -2453,16 +2474,23 @@ export class BinaryModule {
 /** Tests if an expression needs an explicit 'unreachable' when it is the terminating statement. */
 export function needsExplicitUnreachable(expr: ExpressionRef): bool {
   // not applicable if pushing a value to the stack
-  if (binaryen._BinaryenExpressionGetType(expr) != NativeType.Unreachable) return false;
+  if (binaryen._BinaryenExpressionGetType(expr) != NativeType.Unreachable) {
+    return false;
+  }
 
   switch (binaryen._BinaryenExpressionGetId(expr)) {
     case ExpressionId.Unreachable:
     case ExpressionId.Return: return false;
-    case ExpressionId.Break: return binaryen._BinaryenBreakGetCondition(expr) != 0;
+    case ExpressionId.Break: {
+      return binaryen._BinaryenBreakGetCondition(expr) != 0;
+    }
     case ExpressionId.Block: {
       if (!binaryen._BinaryenBlockGetName(expr)) { // can't break out of it
         let numChildren = binaryen._BinaryenBlockGetNumChildren(expr); // last child needs unreachable
-        return numChildren > 0 && needsExplicitUnreachable(binaryen._BinaryenBlockGetChild(expr, numChildren - 1));
+        return (
+          numChildren > 0 &&
+          needsExplicitUnreachable(binaryen._BinaryenBlockGetChild(expr, numChildren - 1))
+        );
       }
     }
   }
@@ -2470,7 +2498,11 @@ export function needsExplicitUnreachable(expr: ExpressionRef): bool {
 }
 
 /** Traverses all expression members of an expression, calling the given visitor. */
-export function traverse<T>(expr: ExpressionRef, data: T, visit: (expr: ExpressionRef, data: T) => void): bool {
+export function traverse<T>(
+  expr:  ExpressionRef,
+  data:  T,
+  visit: (expr: ExpressionRef, data: T) => void
+): bool {
   switch (getExpressionId(expr)) {
     case ExpressionId.Block: {
       for (let i: Index = 0, n = binaryen._BinaryenBlockGetNumChildren(expr); i < n; ++i) {

From 8d9f9b8ed19a0285dd1d8d182f721e406381b865 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 19:53:41 +0300
Subject: [PATCH 10/14] fix

---
 src/glue/wasm/i64.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index 1ece186cbb..91532d4133 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -228,5 +228,5 @@ function i64_to_f64(value: i64): f64 {
 // @ts-ignore: decorator
 @global @inline
 function i64_to_string(value: i64, unsigned: bool = false): string {
-  return (unsigned ? <u64>value : value).toString();
+  return unsigned ? (<u64>value).toString() : value.toString();
 }

From fefe048586511b38c69baa4110838e0ff3b0eb5e Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Mon, 15 Jun 2020 19:54:27 +0300
Subject: [PATCH 11/14] refactor

---
 src/glue/wasm/i64.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index 91532d4133..eab650577e 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -228,5 +228,5 @@ function i64_to_f64(value: i64): f64 {
 // @ts-ignore: decorator
 @global @inline
 function i64_to_string(value: i64, unsigned: bool = false): string {
-  return unsigned ? (<u64>value).toString() : value.toString();
+  return unsigned ? u64(value).toString() : value.toString();
 }

From e00b7b1cc63957a217c78d8329f112f1e73ce475 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Tue, 16 Jun 2020 00:16:49 +0300
Subject: [PATCH 12/14] improve some i64 glue methods

---
 src/glue/js/i64.js   | 8 ++++----
 src/glue/wasm/i64.ts | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/glue/js/i64.js b/src/glue/js/i64.js
index 414025c674..9e05e7a22b 100644
--- a/src/glue/js/i64.js
+++ b/src/glue/js/i64.js
@@ -138,11 +138,11 @@ global.i64_is_i32 = function i64_is_i32(value) {
 };
 
 global.i64_is_u8 = function i64_is_u8(value) {
-  return value.high === 0 && value.low >= 0 && value.low <= u8.MAX_VALUE;
+  return value.high === 0 && (value.low >>> 0) <= u8.MAX_VALUE;
 };
 
 global.i64_is_u16 = function i64_is_u16(value) {
-  return value.high === 0 && value.low >= 0 && value.low <= u16.MAX_VALUE;
+  return value.high === 0 && (value.low >>> 0) <= u16.MAX_VALUE;
 };
 
 global.i64_is_u32 = function i64_is_u32(value) {
@@ -150,7 +150,7 @@ global.i64_is_u32 = function i64_is_u32(value) {
 };
 
 global.i64_is_bool = function i64_is_bool(value) {
-  return value.high === 0 && (value.low === 0 || value.low === 1);
+  return (value.high | (value.low & ~1)) === 0;
 };
 
 const minSafeF32 = Long.fromNumber(f32.MIN_SAFE_INTEGER);
@@ -176,5 +176,5 @@ global.i64_to_f64 = function i64_to_f64(value) {
 };
 
 global.i64_to_string = function i64_to_string(value, unsigned) {
-  return (unsigned ? value.toUnsigned() : value).toString();
+  return unsigned ? value.toUnsigned().toString() : value.toString();
 };
diff --git a/src/glue/wasm/i64.ts b/src/glue/wasm/i64.ts
index eab650577e..852060ddf5 100644
--- a/src/glue/wasm/i64.ts
+++ b/src/glue/wasm/i64.ts
@@ -180,25 +180,25 @@ function i64_is_i32(value: i64): bool {
 // @ts-ignore: decorator
 @global @inline
 function i64_is_u8(value: i64): bool {
-  return value >= 0 && value <= <i64>u8.MAX_VALUE;
+  return <u64>value <= <u64>u8.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
 @global @inline
 function i64_is_u16(value: i64): bool {
-  return value >= 0 && value <= <i64>u16.MAX_VALUE;
+  return <u64>value <= <u64>u16.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
 @global @inline
 function i64_is_u32(value: i64): bool {
-  return value >= 0 && value <= <i64>u32.MAX_VALUE;
+  return <u64>value <= <u64>u32.MAX_VALUE;
 }
 
 // @ts-ignore: decorator
 @global @inline
 function i64_is_bool(value: i64): bool {
-  return value === 0 || value === 1;
+  return (value & ~1) == 0;
 }
 
 // @ts-ignore: decorator

From 95869671a7db027a65b29a104d49da56a2f8e793 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Tue, 16 Jun 2020 17:27:04 +0300
Subject: [PATCH 13/14] fix readString

---
 src/module.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/module.ts b/src/module.ts
index af9aa22222..a8884e9e71 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2449,7 +2449,6 @@ export function readString(ptr: usize): string | null {
         }
       }
     }
-    arr.push(cp);
     if (cp < 0x10000) {
       arr.push(cp);
     } else {

From 316a83cae296745c38ab2c6194124a8dee56d456 Mon Sep 17 00:00:00 2001
From: MaxGraey <maxgraey@gmail.com>
Date: Tue, 16 Jun 2020 19:49:21 +0300
Subject: [PATCH 14/14] reduce utf8 cases

---
 src/module.ts | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/module.ts b/src/module.ts
index a8884e9e71..ea4f1d75aa 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -2421,7 +2421,7 @@ export function readString(ptr: usize): string | null {
   var arr = new Array<i32>();
   // the following is based on Emscripten's UTF8ArrayToString
   var cp: u32;
-  var u1: u32, u2: u32, u3: u32, u4: u32, u5: u32;
+  var u1: u32, u2: u32, u3: u32;
   while (cp = binaryen.__i32_load8_u(ptr++)) {
     if (!(cp & 0x80)) {
       arr.push(cp);
@@ -2440,13 +2440,7 @@ export function readString(ptr: usize): string | null {
       if ((cp & 0xF8) == 0xF0) {
         cp = ((cp & 7) << 18) | (u1 << 12) | (u2 << 6) | u3;
       } else {
-        u4 = binaryen.__i32_load8_u(ptr++) & 63;
-        if ((cp & 0xFC) == 0xF8) {
-          cp = ((cp & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4;
-        } else {
-          u5 = binaryen.__i32_load8_u(ptr++) & 63;
-          cp = ((cp & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5;
-        }
+        assert("Invalid UTF8 sequence during readString");
       }
     }
     if (cp < 0x10000) {