Simplify ASan JS transform (#24314)

Leverages ASan's C API for arbitrary loads/stores instead of custom C
code with separate variants for each possible type.

Similar to #24295 and
#24291.

Author: RReverser

src/runtime_asan.js

@@ -8,111 +8,22 @@
 #error "should only be inclded in USE_ASAN mode"
 #endif
 
-// C versions of asan_js_{load|store}_* will be used from compiled code, which have
+// C versions of asan_js_{load|store} will be used from compiled code, which have
 // ASan instrumentation on them. However, until the wasm module is ready, we
 // must access things directly.
 
-/** @suppress{duplicate} */
-function _asan_js_load_1(ptr) {
-  if (runtimeInitialized) return __asan_c_load_1(ptr);
-  return HEAP8[ptr];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_1u(ptr) {
-  if (runtimeInitialized) return __asan_c_load_1u(ptr);
-  return HEAPU8[ptr];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_2(ptr) {
-  if (runtimeInitialized) return __asan_c_load_2(ptr);
-  return HEAP16[ptr];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_2u(ptr) {
-  if (runtimeInitialized) return __asan_c_load_2u(ptr);
-  return HEAPU16[ptr];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_4(ptr) {
-  if (runtimeInitialized) return __asan_c_load_4(ptr);
-  return HEAP32[ptr];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_4u(ptr) {
-  if (runtimeInitialized) return __asan_c_load_4u(ptr) >>> 0;
-  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];
-}
-/** @suppress{duplicate} */
-function _asan_js_load_d(ptr) {
-  if (runtimeInitialized) return __asan_c_load_d(ptr);
-  return HEAPF64[ptr];
+function _asan_js_load(arr, index) {
+  if (runtimeInitialized) {
+    const elemSize = arr.BYTES_PER_ELEMENT;
+    ___asan_loadN(index * elemSize, elemSize);
+  }
+  return arr[index];
 }
 
-/** @suppress{duplicate} */
-function _asan_js_store_1(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_1(ptr, val);
-  return HEAP8[ptr] = val;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_1u(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_1u(ptr, val);
-  return HEAPU8[ptr] = val;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_2(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_2(ptr, val);
-  return HEAP16[ptr] = val;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_2u(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_2u(ptr, val);
-  return HEAPU16[ptr] = val;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_4(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_4(ptr, val);
-  return HEAP32[ptr] = val;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_4u(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_4u(ptr, val) >>> 0;
-  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) {
+function _asan_js_store(arr, index, value) {
   if (runtimeInitialized) {
-    __asan_c_store_8u(ptr, val);
-    return val;
+    const elemSize = arr.BYTES_PER_ELEMENT;
+    ___asan_storeN(index * elemSize, elemSize);
   }
-  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;
-}
-/** @suppress{duplicate} */
-function _asan_js_store_d(ptr, val) {
-  if (runtimeInitialized) return __asan_c_store_d(ptr, val);
-  return HEAPF64[ptr] = val;
+  return arr[index] = value;
 }

system/lib/asan_js.c

@@ -1,57 +1,57 @@
-_asan_js_store_1(x, 1);
+_asan_js_store(HEAP8, x, 1);
 
-_asan_js_store_2(x, 2);
+_asan_js_store(HEAP16, x, 2);
 
-_asan_js_store_4(x, 3);
+_asan_js_store(HEAP32, x, 3);
 
-_asan_js_store_1u(x, 4);
+_asan_js_store(HEAPU8, x, 4);
 
-_asan_js_store_2u(x, 5);
+_asan_js_store(HEAPU16, x, 5);
 
-_asan_js_store_4u(x, 6);
+_asan_js_store(HEAPU32, x, 6);
 
-_asan_js_store_f(x, 7);
+_asan_js_store(HEAPF32, x, 7);
 
-_asan_js_store_d(x, 8);
+_asan_js_store(HEAPF64, x, 8);
 
-_asan_js_store_8(x, 9n);
+_asan_js_store(HEAP64, x, 9n);
 
-_asan_js_store_8u(x, 10n);
+_asan_js_store(HEAPU64, x, 10n);
 
-a1 = _asan_js_load_1(x);
+a1 = _asan_js_load(HEAP8, x);
 
-a2 = _asan_js_load_2(x);
+a2 = _asan_js_load(HEAP16, x);
 
-a3 = _asan_js_load_4(x);
+a3 = _asan_js_load(HEAP32, x);
 
-a4 = _asan_js_load_1u(x);
+a4 = _asan_js_load(HEAPU8, x);
 
-a5 = _asan_js_load_2u(x);
+a5 = _asan_js_load(HEAPU16, x);
 
-a6 = _asan_js_load_4u(x);
+a6 = _asan_js_load(HEAPU32, x);
 
-a7 = _asan_js_load_f(x);
+a7 = _asan_js_load(HEAPF32, x);
 
-a8 = _asan_js_load_d(x);
+a8 = _asan_js_load(HEAPF64, x);
 
-a9 = _asan_js_load_8(x);
+a9 = _asan_js_load(HEAP64, x);
 
-a10 = _asan_js_load_8u(x);
+a10 = _asan_js_load(HEAPU64, x);
 
-foo = _asan_js_store_1u(1337, 42);
+foo = _asan_js_store(HEAPU8, 1337, 42);
 
-_asan_js_load_2(bar(_asan_js_load_d(5)));
+_asan_js_load(HEAP16, bar(_asan_js_load(HEAPF64, 5)));
 
-_asan_js_store_f(x, _asan_js_load_4(y));
+_asan_js_store(HEAPF32, x, _asan_js_load(HEAP32, y));
 
-function _asan_js_load_1(ptr) {
+function _asan_js_load(ptr) {
   return HEAP8[ptr];
 }
 
 function somethingElse() {
-  return _asan_js_load_1(ptr);
+  return _asan_js_load(HEAP8, ptr);
 }
 
 HEAP8.length;
 
-_asan_js_load_1(length);
+_asan_js_load(HEAP8, length);

test/js_optimizer/asanify-output.js

@@ -37,7 +37,7 @@ HEAPF32[x] = HEAP32[y];
 // access in these functions, as then we'd get infinite recursion - this is
 // where we do actually need to still do a HEAP8[..] etc. operation without
 // any ASan instrumentation.
-function _asan_js_load_1(ptr) {
+function _asan_js_load(ptr) {
   return HEAP8[ptr];
 }