Support 64-bit integers in acorn passes (#24283)

I noticed that acorn-optimizer transforms for ASan, SAFE_HEAP and
GROWABLE_HEAP didn't cover the 64-bit integer support enabled by
`WASM_BIGINT` (`HEAP64` and `HEAPU64` memory views).

Author: RReverser

src/growableHeap.js

@@ -42,6 +42,18 @@ function GROWABLE_HEAP_U32() {
   }
   return HEAPU32;
 }
+function GROWABLE_HEAP_I64() {
+  if (wasmMemory.buffer != HEAP8.buffer) {
+    updateMemoryViews();
+  }
+  return HEAP64;
+}
+function GROWABLE_HEAP_U64() {
+  if (wasmMemory.buffer != HEAP8.buffer) {
+    updateMemoryViews();
+  }
+  return HEAPU64;
+}
 function GROWABLE_HEAP_F32() {
   if (wasmMemory.buffer != HEAP8.buffer) {
     updateMemoryViews();

src/lib/liblittle_endian_heap.js

@@ -11,6 +11,12 @@ var LibraryLittleEndianHeap = {
   $LE_HEAP_STORE_I32: (byteOffset, value) =>
     HEAP_DATA_VIEW.setInt32(byteOffset, value, true),
 
+  $LE_HEAP_STORE_U64: (byteOffset, value) =>
+    HEAP_DATA_VIEW.setBigUint64(byteOffset, value, true),
+
+  $LE_HEAP_STORE_I64: (byteOffset, value) =>
+    HEAP_DATA_VIEW.setBigInt64(byteOffset, value, true),
+
   $LE_HEAP_STORE_F32: (byteOffset, value) =>
     HEAP_DATA_VIEW.setFloat32(byteOffset, value, true),
 
@@ -29,6 +35,12 @@ var LibraryLittleEndianHeap = {
   $LE_HEAP_LOAD_I32: (byteOffset) =>
     HEAP_DATA_VIEW.getInt32(byteOffset, true),
 
+  $LE_HEAP_LOAD_U64: (byteOffset) =>
+    HEAP_DATA_VIEW.getBigUint64(byteOffset, true),
+
+  $LE_HEAP_LOAD_I64: (byteOffset) =>
+    HEAP_DATA_VIEW.getBigInt64(byteOffset, true),
+
   $LE_HEAP_LOAD_F32: (byteOffset) =>
     HEAP_DATA_VIEW.getFloat32(byteOffset, true),
 

src/modules.mjs

@@ -462,6 +462,8 @@ function exportRuntimeSymbols() {
       'GROWABLE_HEAP_U16',
       'GROWABLE_HEAP_I32',
       'GROWABLE_HEAP_U32',
+      'GROWABLE_HEAP_I64',
+      'GROWABLE_HEAP_U64',
       'GROWABLE_HEAP_F32',
       'GROWABLE_HEAP_F64',
     );

src/runtime_asan.js

@@ -43,6 +43,16 @@ function _asan_js_load_4u(ptr) {
   return HEAPU32[ptr];
 }
 /** @suppress{duplicate} */
+function _asan_js_load_8(ptr) {
+  if (runtimeInitialized) return __asan_c_load_8(ptr);
+  return HEAP64[ptr];
+}
+/** @suppress{duplicate} */
+function _asan_js_load_8u(ptr) {
+  if (runtimeInitialized) return BigInt.asUintN(64, __asan_c_load_8u(ptr));
+  return HEAPU64[ptr];
+}
+/** @suppress{duplicate} */
 function _asan_js_load_f(ptr) {
   if (runtimeInitialized) return __asan_c_load_f(ptr);
   return HEAPF32[ptr];
@@ -84,6 +94,19 @@ function _asan_js_store_4u(ptr, val) {
   return HEAPU32[ptr] = val;
 }
 /** @suppress{duplicate} */
+function _asan_js_store_8(ptr, val) {
+  if (runtimeInitialized) return __asan_c_store_8(ptr, val);
+  return HEAP64[ptr] = val;
+}
+/** @suppress{duplicate} */
+function _asan_js_store_8u(ptr, val) {
+  if (runtimeInitialized) {
+    __asan_c_store_8u(ptr, val);
+    return val;
+  }
+  return HEAPU64[ptr] = val;
+}
+/** @suppress{duplicate} */
 function _asan_js_store_f(ptr, val) {
   if (runtimeInitialized) return __asan_c_store_f(ptr, val);
   return HEAPF32[ptr] = val;

system/lib/asan_js.c

@@ -45,6 +45,14 @@ uint32_t _asan_c_load_4u(uintptr_t shifted) {
   uint32_t* ptr = (uint32_t*)(shifted << 2);
   return *ptr;
 }
+int64_t _asan_c_load_8(uintptr_t shifted) {
+  int64_t* ptr = (int64_t*)(shifted << 3);
+  return *ptr;
+}
+uint64_t _asan_c_load_8u(uintptr_t shifted) {
+  uint64_t* ptr = (uint64_t*)(shifted << 3);
+  return *ptr;
+}
 float _asan_c_load_f(uintptr_t shifted) {
   float* ptr = (float*)(shifted << 2);
   return *ptr;
@@ -79,6 +87,14 @@ uint32_t _asan_c_store_4u(uintptr_t shifted, uint32_t val) {
   uint32_t* ptr = (uint32_t*)(shifted << 2);
   return *ptr = val;
 }
+int64_t _asan_c_store_8(uintptr_t shifted, int64_t val) {
+  int64_t* ptr = (int64_t*)(shifted << 3);
+  return *ptr = val;
+}
+uint64_t _asan_c_store_8u(uintptr_t shifted, uint64_t val) {
+  uint64_t* ptr = (uint64_t*)(shifted << 3);
+  return *ptr = val;
+}
 float _asan_c_store_f(uintptr_t shifted, float val) {
   float* ptr = (float*)(shifted << 2);
   return *ptr = val;

test/js_optimizer/asanify-output.js

@@ -14,6 +14,10 @@ _asan_js_store_f(x, 7);
 
 _asan_js_store_d(x, 8);
 
+_asan_js_store_8(x, 9n);
+
+_asan_js_store_8u(x, 10n);
+
 a1 = _asan_js_load_1(x);
 
 a2 = _asan_js_load_2(x);
@@ -30,6 +34,10 @@ a7 = _asan_js_load_f(x);
 
 a8 = _asan_js_load_d(x);
 
+a9 = _asan_js_load_8(x);
+
+a10 = _asan_js_load_8u(x);
+
 foo = _asan_js_store_1u(1337, 42);
 
 _asan_js_load_2(bar(_asan_js_load_d(5)));

test/js_optimizer/asanify.js

@@ -7,6 +7,8 @@ HEAPU16[x] = 5;
 HEAPU32[x] = 6;
 HEAPF32[x] = 7;
 HEAPF64[x] = 8;
+HEAP64[x] = 9n;
+HEAPU64[x] = 10n;
 
 // loads
 a1 = HEAP8[x];
@@ -17,6 +19,8 @@ a5 = HEAPU16[x];
 a6 = HEAPU32[x];
 a7 = HEAPF32[x];
 a8 = HEAPF64[x];
+a9 = HEAP64[x];
+a10 = HEAPU64[x];
 
 // store return value
 foo = HEAPU8[1337] = 42;

test/js_optimizer/growableHeap-output.js

@@ -3,6 +3,7 @@ function f() {
   GROWABLE_HEAP_I32()[$0 >> 2] = $2 + 1;
   $9 = GROWABLE_HEAP_U8()[$2 >> 0] | 0;
   +GROWABLE_HEAP_F64()[x >> 3];
+  GROWABLE_HEAP_I64()[x >> 3] = GROWABLE_HEAP_I64()[y >> 3];
 }
 
 function libraryFunc(ptr, val) {

test/js_optimizer/growableHeap.js

@@ -3,6 +3,7 @@ function f() {
     HEAP32[$0 >> 2] = $2 + 1;
     $9 = HEAPU8[$2 >> 0] | 0;
     +HEAPF64[x >> 3];
+    HEAP64[x >> 3] = HEAP64[y >> 3];
 }
 
 function libraryFunc(ptr, val) {

test/js_optimizer/safeHeap-output.js

@@ -14,6 +14,10 @@ SAFE_HEAP_STORE_D(x * 4, 7, 4);
 
 SAFE_HEAP_STORE_D(x * 8, 8, 8);
 
+SAFE_HEAP_STORE(x * 8, 9n, 8);
+
+SAFE_HEAP_STORE(x * 8, 10n, 8);
+
 a1 = SAFE_HEAP_LOAD(x, 1, 0);
 
 a2 = SAFE_HEAP_LOAD(x * 2, 2, 0);
@@ -30,6 +34,10 @@ a7 = SAFE_HEAP_LOAD_D(x * 4, 4, 0);
 
 a8 = SAFE_HEAP_LOAD_D(x * 8, 8, 0);
 
+a9 = SAFE_HEAP_LOAD(x * 8, 8, 0);
+
+a10 = SAFE_HEAP_LOAD(x * 8, 8, 1);
+
 foo = SAFE_HEAP_STORE(1337, 42, 1);
 
 SAFE_HEAP_LOAD(bar(SAFE_HEAP_LOAD_D(5 * 8, 8, 0)) * 2, 2, 0);