Apply format changes from #2048 (#2059)

Mass change to apply clang-format to everything. We are applying this in a PR by me so the (git) blame is all mine ;) but @aheejin did all the work to get clang-format set up and all the manual work to tidy up some things to make the output nicer in #2048

5 files changed, 257 insertions, 286 deletions

diff --git a/src/asmjs/asm_v_wasm.cpp b/src/asmjs/asm_v_wasm.cpp
index a0b3938fa..bbc7dabd9 100644
--- a/src/asmjs/asm_v_wasm.cpp
+++ b/src/asmjs/asm_v_wasm.cpp
@@ -17,52 +17,71 @@
 #include "asm_v_wasm.h"
 #include "wasm.h"
 
-
 namespace wasm {
 
 Type asmToWasmType(AsmType asmType) {
   switch (asmType) {
-    case ASM_INT: return Type::i32;
-    case ASM_DOUBLE: return Type::f64;
-    case ASM_FLOAT: return Type::f32;
-    case ASM_INT64: return Type::i64;
-    case ASM_NONE: return Type::none;
+    case ASM_INT:
+      return Type::i32;
+    case ASM_DOUBLE:
+      return Type::f64;
+    case ASM_FLOAT:
+      return Type::f32;
+    case ASM_INT64:
+      return Type::i64;
+    case ASM_NONE:
+      return Type::none;
     case ASM_FLOAT32X4:
     case ASM_FLOAT64X2:
     case ASM_INT8X16:
     case ASM_INT16X8:
-    case ASM_INT32X4: return Type::v128;
+    case ASM_INT32X4:
+      return Type::v128;
   }
   WASM_UNREACHABLE();
 }
 
 AsmType wasmToAsmType(Type type) {
   switch (type) {
-    case i32: return ASM_INT;
-    case f32: return ASM_FLOAT;
-    case f64: return ASM_DOUBLE;
-    case i64: return ASM_INT64;
-    case v128: assert(false && "v128 not implemented yet");
-    case none: return ASM_NONE;
-    case unreachable: WASM_UNREACHABLE();
+    case i32:
+      return ASM_INT;
+    case f32:
+      return ASM_FLOAT;
+    case f64:
+      return ASM_DOUBLE;
+    case i64:
+      return ASM_INT64;
+    case v128:
+      assert(false && "v128 not implemented yet");
+    case none:
+      return ASM_NONE;
+    case unreachable:
+      WASM_UNREACHABLE();
   }
   WASM_UNREACHABLE();
 }
 
 char getSig(Type type) {
   switch (type) {
-    case i32:  return 'i';
-    case i64:  return 'j';
-    case f32:  return 'f';
-    case f64:  return 'd';
-    case v128: return 'V';
-    case none: return 'v';
-    case unreachable: WASM_UNREACHABLE();
+    case i32:
+      return 'i';
+    case i64:
+      return 'j';
+    case f32:
+      return 'f';
+    case f64:
+      return 'd';
+    case v128:
+      return 'V';
+    case none:
+      return 'v';
+    case unreachable:
+      WASM_UNREACHABLE();
   }
   WASM_UNREACHABLE();
 }
 
-std::string getSig(const FunctionType *type) {
+std::string getSig(const FunctionType* type) {
   std::string ret;
   ret += getSig(type->result);
   for (auto param : type->params) {
@@ -71,7 +90,7 @@ std::string getSig(const FunctionType *type) {
   return ret;
 }
 
-std::string getSig(Function *func) {
+std::string getSig(Function* func) {
   std::string ret;
   ret += getSig(func->result);
   for (auto type : func->params) {
@@ -82,13 +101,20 @@ std::string getSig(Function *func) {
 
 Type sigToType(char sig) {
   switch (sig) {
-    case 'i': return i32;
-    case 'j': return i64;
-    case 'f': return f32;
-    case 'd': return f64;
-    case 'V': return v128;
-    case 'v': return none;
-    default: abort();
+    case 'i':
+      return i32;
+    case 'j':
+      return i64;
+    case 'f':
+      return f32;
+    case 'd':
+      return f64;
+    case 'V':
+      return v128;
+    case 'v':
+      return none;
+    default:
+      abort();
   }
 }
 
diff --git a/src/asmjs/asmangle.cpp b/src/asmjs/asmangle.cpp
index 0453139b3..743603023 100644
--- a/src/asmjs/asmangle.cpp
+++ b/src/asmjs/asmangle.cpp
@@ -17,7 +17,6 @@
 #include "asmjs/asmangle.h"
 #include <assert.h>
 
-
 namespace wasm {
 
 std::string asmangle(std::string name) {
@@ -49,10 +48,7 @@ std::string asmangle(std::string name) {
       break;
     }
     default: {
-      if (
-        !(ch >= 'a' && ch <= 'z') &&
-        !(ch >= 'A' && ch <= 'Z')
-      ) {
+      if (!(ch >= 'a' && ch <= 'z') && !(ch >= 'A' && ch <= 'Z')) {
         name = "$" + name.substr(1);
         mightBeKeyword = false;
       }
@@ -79,10 +75,7 @@ std::string asmangle(std::string name) {
         break;
       }
       default: {
-        if (
-          !(ch >= 'a' && ch <= 'z') &&
-          !(ch >= 'A' && ch <= 'Z')
-        ) {
+        if (!(ch >= 'a' && ch <= 'z') && !(ch >= 'A' && ch <= 'Z')) {
           name = name.substr(0, i) + "_" + name.substr(i + 1);
           mightBeKeyword = false;
         }
@@ -106,59 +99,36 @@ std::string asmangle(std::string name) {
         break;
       }
       case 'c': {
-        if (
-          name == "case" ||
-          name == "continue" ||
-          name == "catch" ||
-          name == "const" ||
-          name == "class"
-        ) {
+        if (name == "case" || name == "continue" || name == "catch" ||
+            name == "const" || name == "class") {
           goto mangleKeyword;
         }
         break;
       }
       case 'd': {
-        if (
-          name == "do" ||
-          name == "default" ||
-          name == "debugger"
-        ) {
+        if (name == "do" || name == "default" || name == "debugger") {
           goto mangleKeyword;
         }
         break;
       }
       case 'e': {
-        if (
-          name == "else" ||
-          name == "enum" ||
-          name == "eval" || // to be sure
-          name == "export" ||
-          name == "extends"
-        ) {
+        if (name == "else" || name == "enum" || name == "eval" || // to be sure
+            name == "export" || name == "extends") {
           goto mangleKeyword;
         }
         break;
       }
       case 'f': {
-        if (
-          name == "for" ||
-          name == "false" ||
-          name == "finally" ||
-          name == "function"
-        ) {
+        if (name == "for" || name == "false" || name == "finally" ||
+            name == "function") {
           goto mangleKeyword;
         }
         break;
       }
       case 'i': {
-        if (
-          name == "if" ||
-          name == "in" ||
-          name == "import" ||
-          name == "interface" ||
-          name == "implements" ||
-          name == "instanceof"
-        ) {
+        if (name == "if" || name == "in" || name == "import" ||
+            name == "interface" || name == "implements" ||
+            name == "instanceof") {
           goto mangleKeyword;
         }
         break;
@@ -170,21 +140,14 @@ std::string asmangle(std::string name) {
         break;
       }
       case 'n': {
-        if (
-          name == "new" ||
-          name == "null"
-        ) {
+        if (name == "new" || name == "null") {
           goto mangleKeyword;
         }
         break;
       }
       case 'p': {
-        if (
-          name == "public" ||
-          name == "package" ||
-          name == "private" ||
-          name == "protected"
-        ) {
+        if (name == "public" || name == "package" || name == "private" ||
+            name == "protected") {
           goto mangleKeyword;
         }
         break;
@@ -196,41 +159,26 @@ std::string asmangle(std::string name) {
         break;
       }
       case 's': {
-        if (
-          name == "super" ||
-          name == "static" ||
-          name == "switch"
-        ) {
+        if (name == "super" || name == "static" || name == "switch") {
           goto mangleKeyword;
         }
         break;
       }
       case 't': {
-        if (
-          name == "try" ||
-          name == "this" ||
-          name == "true" ||
-          name == "throw" ||
-          name == "typeof"
-        ) {
+        if (name == "try" || name == "this" || name == "true" ||
+            name == "throw" || name == "typeof") {
           goto mangleKeyword;
         }
         break;
       }
       case 'v': {
-        if (
-          name == "var" ||
-          name == "void"
-        ) {
+        if (name == "var" || name == "void") {
           goto mangleKeyword;
         }
         break;
       }
       case 'w': {
-        if (
-          name == "with" ||
-          name == "while"
-        ) {
+        if (name == "with" || name == "while") {
           goto mangleKeyword;
         }
         break;
@@ -241,9 +189,7 @@ std::string asmangle(std::string name) {
         }
         break;
       }
-      mangleKeyword: {
-        name = name + "_";
-      }
+      mangleKeyword : { name = name + "_"; }
     }
   }
   return name;
diff --git a/src/asmjs/asmangle.h b/src/asmjs/asmangle.h
index 161101c07..f0e96317b 100644
--- a/src/asmjs/asmangle.h
+++ b/src/asmjs/asmangle.h
@@ -19,11 +19,10 @@
 
 #include <string>
 
-
 namespace wasm {
 
-  // Mangles a WebAssembly name to a valid JavaScript identifier.
-  std::string asmangle(std::string name);
+// Mangles a WebAssembly name to a valid JavaScript identifier.
+std::string asmangle(std::string name);
 
 } // namespace wasm
 
diff --git a/src/asmjs/shared-constants.cpp b/src/asmjs/shared-constants.cpp
index ec04b63e7..f1123ba67 100644
--- a/src/asmjs/shared-constants.cpp
+++ b/src/asmjs/shared-constants.cpp
@@ -18,104 +18,104 @@
 
 namespace wasm {
 
-cashew::IString GLOBAL("global"),
-                NAN_("NaN"),
-                INFINITY_("Infinity"),
-                NAN__("nan"),
-                INFINITY__("infinity"),
-                TOPMOST("topmost"),
-                INT8ARRAY("Int8Array"),
-                INT16ARRAY("Int16Array"),
-                INT32ARRAY("Int32Array"),
-                UINT8ARRAY("Uint8Array"),
-                UINT16ARRAY("Uint16Array"),
-                UINT32ARRAY("Uint32Array"),
-                FLOAT32ARRAY("Float32Array"),
-                FLOAT64ARRAY("Float64Array"),
-                ARRAY_BUFFER("ArrayBuffer"),
-                ASM_MODULE("asmModule"),
-                IMPOSSIBLE_CONTINUE("impossible-continue"),
-                MATH("Math"),
-                IMUL("imul"),
-                CLZ32("clz32"),
-                FROUND("fround"),
-                ASM2WASM("asm2wasm"),
-                MIN("min"),
-                MAX("max"),
-                F64_REM("f64-rem"),
-                F64_TO_INT("f64-to-int"),
-                F64_TO_UINT("f64-to-uint"),
-                F64_TO_INT64("f64-to-int64"),
-                F64_TO_UINT64("f64-to-uint64"),
-                F32_TO_INT("f32-to-int"),
-                F32_TO_UINT("f32-to-uint"),
-                F32_TO_INT64("f32-to-int64"),
-                F32_TO_UINT64("f32-to-uint64"),
-                I32S_DIV("i32s-div"),
-                I32U_DIV("i32u-div"),
-                I32S_REM("i32s-rem"),
-                I32U_REM("i32u-rem"),
-                GLOBAL_MATH("global.Math"),
-                ABS("abs"),
-                FLOOR("floor"),
-                CEIL("ceil"),
-                SQRT("sqrt"),
-                POW("pow"),
-                I32_TEMP("asm2wasm_i32_temp"),
-                DEBUGGER("debugger"),
-                USE_ASM("use asm"),
-                ALMOST_ASM("almost asm"),
-                BUFFER("buffer"),
-                ENV("env"),
-                STACKTOP("STACKTOP"),
-                STACK_MAX("STACK_MAX"),
-                INSTRUMENT("instrument"),
-                MATH_IMUL("Math_imul"),
-                MATH_ABS("Math_abs"),
-                MATH_CEIL("Math_ceil"),
-                MATH_CLZ32("Math_clz32"),
-                MATH_FLOOR("Math_floor"),
-                MATH_TRUNC("Math_trunc"),
-                MATH_SQRT("Math_sqrt"),
-                MATH_MIN("Math_min"),
-                MATH_MAX("Math_max"),
-                WASM_CTZ32("__wasm_ctz_i32"),
-                WASM_CTZ64("__wasm_ctz_i64"),
-                WASM_CLZ32("__wasm_clz_i32"),
-                WASM_CLZ64("__wasm_clz_i64"),
-                WASM_POPCNT32("__wasm_popcnt_i32"),
-                WASM_POPCNT64("__wasm_popcnt_i64"),
-                WASM_ROTL32("__wasm_rotl_i32"),
-                WASM_ROTL64("__wasm_rotl_i64"),
-                WASM_ROTR32("__wasm_rotr_i32"),
-                WASM_ROTR64("__wasm_rotr_i64"),
-                WASM_GROW_MEMORY("__wasm_grow_memory"),
-                WASM_CURRENT_MEMORY("__wasm_current_memory"),
-                WASM_FETCH_HIGH_BITS("__wasm_fetch_high_bits"),
-                INT64_TO_32_HIGH_BITS("i64toi32_i32$HIGH_BITS"),
-                WASM_NEAREST_F32("__wasm_nearest_f32"),
-                WASM_NEAREST_F64("__wasm_nearest_f64"),
-                WASM_TRUNC_F32("__wasm_trunc_f32"),
-                WASM_TRUNC_F64("__wasm_trunc_f64"),
-                WASM_I64_MUL("__wasm_i64_mul"),
-                WASM_I64_SDIV("__wasm_i64_sdiv"),
-                WASM_I64_UDIV("__wasm_i64_udiv"),
-                WASM_I64_SREM("__wasm_i64_srem"),
-                WASM_I64_UREM("__wasm_i64_urem");
+cashew::IString GLOBAL("global");
+cashew::IString NAN_("NaN");
+cashew::IString INFINITY_("Infinity");
+cashew::IString NAN__("nan");
+cashew::IString INFINITY__("infinity");
+cashew::IString TOPMOST("topmost");
+cashew::IString INT8ARRAY("Int8Array");
+cashew::IString INT16ARRAY("Int16Array");
+cashew::IString INT32ARRAY("Int32Array");
+cashew::IString UINT8ARRAY("Uint8Array");
+cashew::IString UINT16ARRAY("Uint16Array");
+cashew::IString UINT32ARRAY("Uint32Array");
+cashew::IString FLOAT32ARRAY("Float32Array");
+cashew::IString FLOAT64ARRAY("Float64Array");
+cashew::IString ARRAY_BUFFER("ArrayBuffer");
+cashew::IString ASM_MODULE("asmModule");
+cashew::IString IMPOSSIBLE_CONTINUE("impossible-continue");
+cashew::IString MATH("Math");
+cashew::IString IMUL("imul");
+cashew::IString CLZ32("clz32");
+cashew::IString FROUND("fround");
+cashew::IString ASM2WASM("asm2wasm");
+cashew::IString MIN("min");
+cashew::IString MAX("max");
+cashew::IString F64_REM("f64-rem");
+cashew::IString F64_TO_INT("f64-to-int");
+cashew::IString F64_TO_UINT("f64-to-uint");
+cashew::IString F64_TO_INT64("f64-to-int64");
+cashew::IString F64_TO_UINT64("f64-to-uint64");
+cashew::IString F32_TO_INT("f32-to-int");
+cashew::IString F32_TO_UINT("f32-to-uint");
+cashew::IString F32_TO_INT64("f32-to-int64");
+cashew::IString F32_TO_UINT64("f32-to-uint64");
+cashew::IString I32S_DIV("i32s-div");
+cashew::IString I32U_DIV("i32u-div");
+cashew::IString I32S_REM("i32s-rem");
+cashew::IString I32U_REM("i32u-rem");
+cashew::IString GLOBAL_MATH("global.Math");
+cashew::IString ABS("abs");
+cashew::IString FLOOR("floor");
+cashew::IString CEIL("ceil");
+cashew::IString SQRT("sqrt");
+cashew::IString POW("pow");
+cashew::IString I32_TEMP("asm2wasm_i32_temp");
+cashew::IString DEBUGGER("debugger");
+cashew::IString USE_ASM("use asm");
+cashew::IString ALMOST_ASM("almost asm");
+cashew::IString BUFFER("buffer");
+cashew::IString ENV("env");
+cashew::IString STACKTOP("STACKTOP");
+cashew::IString STACK_MAX("STACK_MAX");
+cashew::IString INSTRUMENT("instrument");
+cashew::IString MATH_IMUL("Math_imul");
+cashew::IString MATH_ABS("Math_abs");
+cashew::IString MATH_CEIL("Math_ceil");
+cashew::IString MATH_CLZ32("Math_clz32");
+cashew::IString MATH_FLOOR("Math_floor");
+cashew::IString MATH_TRUNC("Math_trunc");
+cashew::IString MATH_SQRT("Math_sqrt");
+cashew::IString MATH_MIN("Math_min");
+cashew::IString MATH_MAX("Math_max");
+cashew::IString WASM_CTZ32("__wasm_ctz_i32");
+cashew::IString WASM_CTZ64("__wasm_ctz_i64");
+cashew::IString WASM_CLZ32("__wasm_clz_i32");
+cashew::IString WASM_CLZ64("__wasm_clz_i64");
+cashew::IString WASM_POPCNT32("__wasm_popcnt_i32");
+cashew::IString WASM_POPCNT64("__wasm_popcnt_i64");
+cashew::IString WASM_ROTL32("__wasm_rotl_i32");
+cashew::IString WASM_ROTL64("__wasm_rotl_i64");
+cashew::IString WASM_ROTR32("__wasm_rotr_i32");
+cashew::IString WASM_ROTR64("__wasm_rotr_i64");
+cashew::IString WASM_GROW_MEMORY("__wasm_grow_memory");
+cashew::IString WASM_CURRENT_MEMORY("__wasm_current_memory");
+cashew::IString WASM_FETCH_HIGH_BITS("__wasm_fetch_high_bits");
+cashew::IString INT64_TO_32_HIGH_BITS("i64toi32_i32$HIGH_BITS");
+cashew::IString WASM_NEAREST_F32("__wasm_nearest_f32");
+cashew::IString WASM_NEAREST_F64("__wasm_nearest_f64");
+cashew::IString WASM_TRUNC_F32("__wasm_trunc_f32");
+cashew::IString WASM_TRUNC_F64("__wasm_trunc_f64");
+cashew::IString WASM_I64_MUL("__wasm_i64_mul");
+cashew::IString WASM_I64_SDIV("__wasm_i64_sdiv");
+cashew::IString WASM_I64_UDIV("__wasm_i64_udiv");
+cashew::IString WASM_I64_SREM("__wasm_i64_srem");
+cashew::IString WASM_I64_UREM("__wasm_i64_urem");
 
 namespace ABI {
 namespace wasm2js {
 
-cashew::IString SCRATCH_LOAD_I32("wasm2js_scratch_load_i32"),
-                SCRATCH_STORE_I32("wasm2js_scratch_store_i32"),
-                SCRATCH_LOAD_I64("wasm2js_scratch_load_i64"),
-                SCRATCH_STORE_I64("wasm2js_scratch_store_i64"),
-                SCRATCH_LOAD_F32("wasm2js_scratch_load_f32"),
-                SCRATCH_STORE_F32("wasm2js_scratch_store_f32"),
-                SCRATCH_LOAD_F64("wasm2js_scratch_load_f64"),
-                SCRATCH_STORE_F64("wasm2js_scratch_store_f64");
+cashew::IString SCRATCH_LOAD_I32("wasm2js_scratch_load_i32");
+cashew::IString SCRATCH_STORE_I32("wasm2js_scratch_store_i32");
+cashew::IString SCRATCH_LOAD_I64("wasm2js_scratch_load_i64");
+cashew::IString SCRATCH_STORE_I64("wasm2js_scratch_store_i64");
+cashew::IString SCRATCH_LOAD_F32("wasm2js_scratch_load_f32");
+cashew::IString SCRATCH_STORE_F32("wasm2js_scratch_store_f32");
+cashew::IString SCRATCH_LOAD_F64("wasm2js_scratch_load_f64");
+cashew::IString SCRATCH_STORE_F64("wasm2js_scratch_store_f64");
 
 } // namespace wasm2js
 } // namespace ABI
 
-}
+} // namespace wasm
diff --git a/src/asmjs/shared-constants.h b/src/asmjs/shared-constants.h
index b1f93336b..e8d5d5693 100644
--- a/src/asmjs/shared-constants.h
+++ b/src/asmjs/shared-constants.h
@@ -21,90 +21,90 @@
 
 namespace wasm {
 
-extern cashew::IString GLOBAL,
-                NAN_,
-                INFINITY_,
-                NAN__,
-                INFINITY__,
-                TOPMOST,
-                INT8ARRAY,
-                INT16ARRAY,
-                INT32ARRAY,
-                UINT8ARRAY,
-                UINT16ARRAY,
-                UINT32ARRAY,
-                FLOAT32ARRAY,
-                FLOAT64ARRAY,
-                ARRAY_BUFFER,
-                ASM_MODULE,
-                IMPOSSIBLE_CONTINUE,
-                MATH,
-                IMUL,
-                CLZ32,
-                FROUND,
-                ASM2WASM,
-                MIN,
-                MAX,
-                F64_REM,
-                F64_TO_INT,
-                F64_TO_UINT,
-                F64_TO_INT64,
-                F64_TO_UINT64,
-                F32_TO_INT,
-                F32_TO_UINT,
-                F32_TO_INT64,
-                F32_TO_UINT64,
-                I32S_DIV,
-                I32U_DIV,
-                I32S_REM,
-                I32U_REM,
-                GLOBAL_MATH,
-                ABS,
-                FLOOR,
-                CEIL,
-                SQRT,
-                POW,
-                I32_TEMP,
-                DEBUGGER,
-                USE_ASM,
-                ALMOST_ASM,
-                BUFFER,
-                ENV,
-                STACKTOP,
-                STACK_MAX,
-                INSTRUMENT,
-                MATH_IMUL,
-                MATH_ABS,
-                MATH_CEIL,
-                MATH_CLZ32,
-                MATH_FLOOR,
-                MATH_TRUNC,
-                MATH_SQRT,
-                MATH_MIN,
-                MATH_MAX,
-                WASM_CTZ32,
-                WASM_CTZ64,
-                WASM_CLZ32,
-                WASM_CLZ64,
-                WASM_POPCNT32,
-                WASM_POPCNT64,
-                WASM_ROTL32,
-                WASM_ROTL64,
-                WASM_ROTR32,
-                WASM_ROTR64,
-                WASM_GROW_MEMORY,
-                WASM_CURRENT_MEMORY,
-                WASM_FETCH_HIGH_BITS,
-                INT64_TO_32_HIGH_BITS,
-                WASM_NEAREST_F32,
-                WASM_NEAREST_F64,
-                WASM_TRUNC_F32,
-                WASM_TRUNC_F64,
-                WASM_I64_MUL,
-                WASM_I64_SDIV,
-                WASM_I64_UDIV,
-                WASM_I64_SREM,
-                WASM_I64_UREM;
-}
+extern cashew::IString GLOBAL;
+extern cashew::IString NAN_;
+extern cashew::IString INFINITY_;
+extern cashew::IString NAN__;
+extern cashew::IString INFINITY__;
+extern cashew::IString TOPMOST;
+extern cashew::IString INT8ARRAY;
+extern cashew::IString INT16ARRAY;
+extern cashew::IString INT32ARRAY;
+extern cashew::IString UINT8ARRAY;
+extern cashew::IString UINT16ARRAY;
+extern cashew::IString UINT32ARRAY;
+extern cashew::IString FLOAT32ARRAY;
+extern cashew::IString FLOAT64ARRAY;
+extern cashew::IString ARRAY_BUFFER;
+extern cashew::IString ASM_MODULE;
+extern cashew::IString IMPOSSIBLE_CONTINUE;
+extern cashew::IString MATH;
+extern cashew::IString IMUL;
+extern cashew::IString CLZ32;
+extern cashew::IString FROUND;
+extern cashew::IString ASM2WASM;
+extern cashew::IString MIN;
+extern cashew::IString MAX;
+extern cashew::IString F64_REM;
+extern cashew::IString F64_TO_INT;
+extern cashew::IString F64_TO_UINT;
+extern cashew::IString F64_TO_INT64;
+extern cashew::IString F64_TO_UINT64;
+extern cashew::IString F32_TO_INT;
+extern cashew::IString F32_TO_UINT;
+extern cashew::IString F32_TO_INT64;
+extern cashew::IString F32_TO_UINT64;
+extern cashew::IString I32S_DIV;
+extern cashew::IString I32U_DIV;
+extern cashew::IString I32S_REM;
+extern cashew::IString I32U_REM;
+extern cashew::IString GLOBAL_MATH;
+extern cashew::IString ABS;
+extern cashew::IString FLOOR;
+extern cashew::IString CEIL;
+extern cashew::IString SQRT;
+extern cashew::IString POW;
+extern cashew::IString I32_TEMP;
+extern cashew::IString DEBUGGER;
+extern cashew::IString USE_ASM;
+extern cashew::IString ALMOST_ASM;
+extern cashew::IString BUFFER;
+extern cashew::IString ENV;
+extern cashew::IString STACKTOP;
+extern cashew::IString STACK_MAX;
+extern cashew::IString INSTRUMENT;
+extern cashew::IString MATH_IMUL;
+extern cashew::IString MATH_ABS;
+extern cashew::IString MATH_CEIL;
+extern cashew::IString MATH_CLZ32;
+extern cashew::IString MATH_FLOOR;
+extern cashew::IString MATH_TRUNC;
+extern cashew::IString MATH_SQRT;
+extern cashew::IString MATH_MIN;
+extern cashew::IString MATH_MAX;
+extern cashew::IString WASM_CTZ32;
+extern cashew::IString WASM_CTZ64;
+extern cashew::IString WASM_CLZ32;
+extern cashew::IString WASM_CLZ64;
+extern cashew::IString WASM_POPCNT32;
+extern cashew::IString WASM_POPCNT64;
+extern cashew::IString WASM_ROTL32;
+extern cashew::IString WASM_ROTL64;
+extern cashew::IString WASM_ROTR32;
+extern cashew::IString WASM_ROTR64;
+extern cashew::IString WASM_GROW_MEMORY;
+extern cashew::IString WASM_CURRENT_MEMORY;
+extern cashew::IString WASM_FETCH_HIGH_BITS;
+extern cashew::IString INT64_TO_32_HIGH_BITS;
+extern cashew::IString WASM_NEAREST_F32;
+extern cashew::IString WASM_NEAREST_F64;
+extern cashew::IString WASM_TRUNC_F32;
+extern cashew::IString WASM_TRUNC_F64;
+extern cashew::IString WASM_I64_MUL;
+extern cashew::IString WASM_I64_SDIV;
+extern cashew::IString WASM_I64_UDIV;
+extern cashew::IString WASM_I64_SREM;
+extern cashew::IString WASM_I64_UREM;
+} // namespace wasm
 
 #endif // wasm_asmjs_shared_constants_h