allow combined options to work

Author: slavek-kucera

src/runtime_asan.js

@@ -21,14 +21,5 @@ function _asan_js_check_index(arr, index, asanFn) {
     const elemSize = arr.BYTES_PER_ELEMENT;
     asanFn(index * elemSize, elemSize);
   }
-}
-
-function _asan_js_load(arr, index) {
-  _asan_js_check_index(arr, index, ___asan_loadN);
-  return arr[index];
-}
-
-function _asan_js_store(arr, index, value) {
-  _asan_js_check_index(arr, index, ___asan_storeN);
-  return arr[index] = value;
+  return index;
 }

src/runtime_safe_heap.js

@@ -35,14 +35,6 @@ function SAFE_HEAP_INDEX(arr, idx, action) {
   return idx;
 }
 
-function SAFE_HEAP_LOAD(arr, idx) {
-  return arr[SAFE_HEAP_INDEX(arr, idx, 'loading')];
-}
-
-function SAFE_HEAP_STORE(arr, idx, value) {
-  return arr[SAFE_HEAP_INDEX(arr, idx, 'storing')] = value;
-}
-
 function segfault() {
   abort('segmentation fault');
 }

test/js_optimizer/LittleEndianGrowableSafeHeap-output.js

@@ -0,0 +1,55 @@
+a = (growMemViews(), HEAP8)[SAFE_HEAP_INDEX((growMemViews(), HEAP8), x, "loading")];
+
+(growMemViews(), HEAP8)[SAFE_HEAP_INDEX((growMemViews(), HEAP8), x, "storing")] = a;
+
+a = (growMemViews(), HEAPU8)[SAFE_HEAP_INDEX((growMemViews(), HEAPU8), x, "loading")];
+
+(growMemViews(), HEAPU8)[SAFE_HEAP_INDEX((growMemViews(), HEAPU8), x, "storing")] = a;
+
+a = LE_HEAP_LOAD_I16((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAP16), x, "loading") * 2));
+
+LE_HEAP_STORE_I16((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAP16), x, "storing") * 2), a);
+
+a = LE_HEAP_LOAD_U16((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPU16), x, "loading") * 2));
+
+LE_HEAP_STORE_U16((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPU16), x, "storing") * 2), a);
+
+a = LE_HEAP_LOAD_I32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAP32), x, "loading") * 4));
+
+LE_HEAP_STORE_I32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAP32), x, "storing") * 4), a);
+
+a = LE_HEAP_LOAD_U32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPU32), x, "loading") * 4));
+
+LE_HEAP_STORE_U32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPU32), x, "storing") * 4), a);
+
+a = LE_HEAP_LOAD_F32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPF32), x, "loading") * 4));
+
+LE_HEAP_STORE_F32((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPF32), x, "storing") * 4), a);
+
+a = LE_HEAP_LOAD_F64((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPF64), x, "loading") * 8));
+
+LE_HEAP_STORE_F64((growMemViews(), SAFE_HEAP_INDEX((growMemViews(), HEAPF64), x, "storing") * 8), a);
+
+HEAP[x];
+
+HeAp[x];
+
+LE_ATOMICS_ADD(heap, offset, value);
+
+LE_ATOMICS_AND(heap, offset, value);
+
+LE_ATOMICS_COMPAREEXCHANGE(heap, offset, expected, replacement);
+
+LE_ATOMICS_EXCHANGE(heap, offset, value);
+
+LE_ATOMICS_LOAD(heap, offset);
+
+LE_ATOMICS_OR(heap, offset, value);
+
+LE_ATOMICS_SUB(heap, offset, value);
+
+LE_ATOMICS_WAIT(heap, offset, value, timeout);
+
+LE_ATOMICS_WAITASYNC(heap, offset, value, timeout);
+
+LE_ATOMICS_XOR(heap, offset, value);

test/js_optimizer/LittleEndianGrowableSafeHeap.js

@@ -0,0 +1,28 @@
+a = HEAP8[x];     // HEAP8
+HEAP8[x] = a;
+a = HEAPU8[x];    // HEAPU8
+HEAPU8[x] = a;
+a = HEAP16[x];    // HEAP16
+HEAP16[x] = a;
+a = HEAPU16[x];   // HEAPU16
+HEAPU16[x] = a;
+a = HEAP32[x];    // HEAPI32
+HEAP32[x] = a;
+a = HEAPU32[x];   // HEAPU32
+HEAPU32[x] = a;
+a = HEAPF32[x];   // HEAPF32
+HEAPF32[x] = a;
+a = HEAPF64[x];   // HEAPF64
+HEAPF64[x] = a;
+HEAP[x];          // should not be changed
+HeAp[x];
+Atomics.add(heap, offset, value);
+Atomics.and(heap, offset, value);
+Atomics.compareExchange(heap, offset, expected, replacement);
+Atomics.exchange(heap, offset, value);
+Atomics.load(heap, offset);
+Atomics.or(heap, offset, value);
+Atomics.sub(heap, offset, value);
+Atomics.wait(heap, offset, value, timeout);
+Atomics.waitAsync(heap, offset, value, timeout);
+Atomics.xor(heap, offset, value);

test/js_optimizer/asanify-output.js

@@ -1,57 +1,53 @@
-_asan_js_store(HEAP8, x, 1);
+HEAP8[_asan_js_check_index(HEAP8, x, ___asan_storeN)] = 1;
 
-_asan_js_store(HEAP16, x, 2);
+HEAP16[_asan_js_check_index(HEAP16, x, ___asan_storeN)] = 2;
 
-_asan_js_store(HEAP32, x, 3);
+HEAP32[_asan_js_check_index(HEAP32, x, ___asan_storeN)] = 3;
 
-_asan_js_store(HEAPU8, x, 4);
+HEAPU8[_asan_js_check_index(HEAPU8, x, ___asan_storeN)] = 4;
 
-_asan_js_store(HEAPU16, x, 5);
+HEAPU16[_asan_js_check_index(HEAPU16, x, ___asan_storeN)] = 5;
 
-_asan_js_store(HEAPU32, x, 6);
+HEAPU32[_asan_js_check_index(HEAPU32, x, ___asan_storeN)] = 6;
 
-_asan_js_store(HEAPF32, x, 7);
+HEAPF32[_asan_js_check_index(HEAPF32, x, ___asan_storeN)] = 7;
 
-_asan_js_store(HEAPF64, x, 8);
+HEAPF64[_asan_js_check_index(HEAPF64, x, ___asan_storeN)] = 8;
 
-_asan_js_store(HEAP64, x, 9n);
+HEAP64[_asan_js_check_index(HEAP64, x, ___asan_storeN)] = 9n;
 
-_asan_js_store(HEAPU64, x, 10n);
+HEAPU64[_asan_js_check_index(HEAPU64, x, ___asan_storeN)] = 10n;
 
-a1 = _asan_js_load(HEAP8, x);
+a1 = HEAP8[_asan_js_check_index(HEAP8, x, ___asan_loadN)];
 
-a2 = _asan_js_load(HEAP16, x);
+a2 = HEAP16[_asan_js_check_index(HEAP16, x, ___asan_loadN)];
 
-a3 = _asan_js_load(HEAP32, x);
+a3 = HEAP32[_asan_js_check_index(HEAP32, x, ___asan_loadN)];
 
-a4 = _asan_js_load(HEAPU8, x);
+a4 = HEAPU8[_asan_js_check_index(HEAPU8, x, ___asan_loadN)];
 
-a5 = _asan_js_load(HEAPU16, x);
+a5 = HEAPU16[_asan_js_check_index(HEAPU16, x, ___asan_loadN)];
 
-a6 = _asan_js_load(HEAPU32, x);
+a6 = HEAPU32[_asan_js_check_index(HEAPU32, x, ___asan_loadN)];
 
-a7 = _asan_js_load(HEAPF32, x);
+a7 = HEAPF32[_asan_js_check_index(HEAPF32, x, ___asan_loadN)];
 
-a8 = _asan_js_load(HEAPF64, x);
+a8 = HEAPF64[_asan_js_check_index(HEAPF64, x, ___asan_loadN)];
 
-a9 = _asan_js_load(HEAP64, x);
+a9 = HEAP64[_asan_js_check_index(HEAP64, x, ___asan_loadN)];
 
-a10 = _asan_js_load(HEAPU64, x);
+a10 = HEAPU64[_asan_js_check_index(HEAPU64, x, ___asan_loadN)];
 
-foo = _asan_js_store(HEAPU8, 1337, 42);
+foo = HEAPU8[_asan_js_check_index(HEAPU8, 1337, ___asan_storeN)] = 42;
 
-_asan_js_load(HEAP16, bar(_asan_js_load(HEAPF64, 5)));
+HEAP16[_asan_js_check_index(HEAP16, bar(HEAPF64[_asan_js_check_index(HEAPF64, 5, ___asan_loadN)]), ___asan_loadN)];
 
-_asan_js_store(HEAPF32, x, _asan_js_load(HEAP32, y));
-
-function _asan_js_load(ptr) {
-  return HEAP8[ptr];
-}
+HEAPF32[_asan_js_check_index(HEAPF32, x, ___asan_storeN)] = HEAP32[_asan_js_check_index(HEAP32, y, ___asan_loadN)];
 
 function somethingElse() {
-  return _asan_js_load(HEAP8, ptr);
+  return HEAP8[_asan_js_check_index(HEAP8, ptr, ___asan_loadN)];
 }
 
 HEAP8.length;
 
-_asan_js_load(HEAP8, length);
+HEAP8[_asan_js_check_index(HEAP8, length, ___asan_loadN)];

test/js_optimizer/asanify.js

@@ -29,18 +29,6 @@ foo = HEAPU8[1337] = 42;
 HEAP16[bar(HEAPF64[5])];
 HEAPF32[x] = HEAP32[y];
 
-// Ignore the special asan functions themselves. that is, any JS memory access
-// will turn into a function call to _asan_js_load_1 etc., which then does
-// the memory access for it. It either calls into wasm to get the proper
-// asan-instrumented operation, or before the wasm is ready to be called into,
-// we must do the access in JS, unsafely. We should not instrument a heap
-// 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(ptr) {
-  return HEAP8[ptr];
-}
-
 // but do handle everything else
 function somethingElse() {
   return HEAP8[ptr];

test/js_optimizer/safeHeap-output.js

@@ -1,57 +1,53 @@
-SAFE_HEAP_STORE(HEAP8, x, 1);
+HEAP8[SAFE_HEAP_INDEX(HEAP8, x, "storing")] = 1;
 
-SAFE_HEAP_STORE(HEAP16, x, 2);
+HEAP16[SAFE_HEAP_INDEX(HEAP16, x, "storing")] = 2;
 
-SAFE_HEAP_STORE(HEAP32, x, 3);
+HEAP32[SAFE_HEAP_INDEX(HEAP32, x, "storing")] = 3;
 
-SAFE_HEAP_STORE(HEAPU8, x, 4);
+HEAPU8[SAFE_HEAP_INDEX(HEAPU8, x, "storing")] = 4;
 
-SAFE_HEAP_STORE(HEAPU16, x, 5);
+HEAPU16[SAFE_HEAP_INDEX(HEAPU16, x, "storing")] = 5;
 
-SAFE_HEAP_STORE(HEAPU32, x, 6);
+HEAPU32[SAFE_HEAP_INDEX(HEAPU32, x, "storing")] = 6;
 
-SAFE_HEAP_STORE(HEAPF32, x, 7);
+HEAPF32[SAFE_HEAP_INDEX(HEAPF32, x, "storing")] = 7;
 
-SAFE_HEAP_STORE(HEAPF64, x, 8);
+HEAPF64[SAFE_HEAP_INDEX(HEAPF64, x, "storing")] = 8;
 
-SAFE_HEAP_STORE(HEAP64, x, 9n);
+HEAP64[SAFE_HEAP_INDEX(HEAP64, x, "storing")] = 9n;
 
-SAFE_HEAP_STORE(HEAPU64, x, 10n);
+HEAPU64[SAFE_HEAP_INDEX(HEAPU64, x, "storing")] = 10n;
 
-a1 = SAFE_HEAP_LOAD(HEAP8, x);
+a1 = HEAP8[SAFE_HEAP_INDEX(HEAP8, x, "loading")];
 
-a2 = SAFE_HEAP_LOAD(HEAP16, x);
+a2 = HEAP16[SAFE_HEAP_INDEX(HEAP16, x, "loading")];
 
-a3 = SAFE_HEAP_LOAD(HEAP32, x);
+a3 = HEAP32[SAFE_HEAP_INDEX(HEAP32, x, "loading")];
 
-a4 = SAFE_HEAP_LOAD(HEAPU8, x);
+a4 = HEAPU8[SAFE_HEAP_INDEX(HEAPU8, x, "loading")];
 
-a5 = SAFE_HEAP_LOAD(HEAPU16, x);
+a5 = HEAPU16[SAFE_HEAP_INDEX(HEAPU16, x, "loading")];
 
-a6 = SAFE_HEAP_LOAD(HEAPU32, x);
+a6 = HEAPU32[SAFE_HEAP_INDEX(HEAPU32, x, "loading")];
 
-a7 = SAFE_HEAP_LOAD(HEAPF32, x);
+a7 = HEAPF32[SAFE_HEAP_INDEX(HEAPF32, x, "loading")];
 
-a8 = SAFE_HEAP_LOAD(HEAPF64, x);
+a8 = HEAPF64[SAFE_HEAP_INDEX(HEAPF64, x, "loading")];
 
-a9 = SAFE_HEAP_LOAD(HEAP64, x);
+a9 = HEAP64[SAFE_HEAP_INDEX(HEAP64, x, "loading")];
 
-a10 = SAFE_HEAP_LOAD(HEAPU64, x);
+a10 = HEAPU64[SAFE_HEAP_INDEX(HEAPU64, x, "loading")];
 
-foo = SAFE_HEAP_STORE(HEAPU8, 1337, 42);
+foo = HEAPU8[SAFE_HEAP_INDEX(HEAPU8, 1337, "storing")] = 42;
 
-SAFE_HEAP_LOAD(HEAP16, bar(SAFE_HEAP_LOAD(HEAPF64, 5)));
+HEAP16[SAFE_HEAP_INDEX(HEAP16, bar(HEAPF64[SAFE_HEAP_INDEX(HEAPF64, 5, "loading")]), "loading")];
 
-SAFE_HEAP_STORE(HEAPF32, x, SAFE_HEAP_LOAD(HEAP32, y));
-
-function SAFE_HEAP_FOO(ptr) {
-  return HEAP8[ptr];
-}
+HEAPF32[SAFE_HEAP_INDEX(HEAPF32, x, "storing")] = HEAP32[SAFE_HEAP_INDEX(HEAP32, y, "loading")];
 
 function somethingElse() {
-  return SAFE_HEAP_LOAD(HEAP8, ptr);
+  return HEAP8[SAFE_HEAP_INDEX(HEAP8, ptr, "loading")];
 }
 
 HEAP8.length;
 
-SAFE_HEAP_LOAD(HEAP8, length);
+HEAP8[SAFE_HEAP_INDEX(HEAP8, length, "loading")];

test/js_optimizer/safeHeap.js

@@ -29,18 +29,6 @@ foo = HEAPU8[1337] = 42;
 HEAP16[bar(HEAPF64[5])];
 HEAPF32[x] = HEAP32[y];
 
-// Ignore the special functions themselves. that is, any JS memory access
-// will turn into a function call to _asan_js_load_1 etc., which then does
-// the memory access for it. It either calls into wasm to get the proper
-// asan-instrumented operation, or before the wasm is ready to be called into,
-// we must do the access in JS, unsafely. We should not instrument a heap
-// 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 SAFE_HEAP_FOO(ptr) {
-  return HEAP8[ptr];
-}
-
 // but do handle everything else
 function somethingElse() {
   return HEAP8[ptr];

test/test_other.py

@@ -2970,6 +2970,7 @@ def test_extern_prepost(self):
     'object-literals': ([],),
     'LittleEndianHeap': (['littleEndianHeap'],),
     'LittleEndianGrowableHeap': (['growableHeap','littleEndianHeap'],),
+    'LittleEndianGrowableSafeHeap': (['safeHeap','growableHeap','littleEndianHeap'],),
   })
   @crossplatform
   def test_js_optimizer(self, passes, filename=None):