[wasm] Add stack checks to loops.

test/cctest/wasm/test-run-wasm-module.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-module-builder.h"
@@ skipping 292 matching lines @@
   Zone zone(&allocator);
 
   WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
   WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
   ExportAsMain(f);
   byte code[] = {WASM_GROW_MEMORY(WASM_I32V(0))};
   f->EmitCode(code, sizeof(code));
   TestModule(&zone, builder, kExpectedValue);
 }
 
+class InterruptThread : public v8::base::Thread {
+ public:
+  explicit InterruptThread(Isolate* isolate, int32_t* memory)
+      : Thread(Options("TestInterruptLoop")),
+        isolate_(isolate),
+        memory_(memory) {}
+
+  static void OnInterrupt(v8::Isolate* isolate, void* data) {
+    int32_t* m = reinterpret_cast<int32_t*>(data);
+    // Set the interrupt location to 0 to break the loop in {TestInterruptLoop}.
+    m[interrupt_location_] = interrupt_value_;
+  }
+
+  virtual void Run() {
+    // Wait for the main thread to write the signal value.
+    while (memory_[0] != signal_value_) {
+    }
+    isolate_->RequestInterrupt(&OnInterrupt, const_cast<int32_t*>(memory_));
+  }
+
+  Isolate* isolate_;
+  volatile int32_t* memory_;
+  static const int32_t interrupt_location_ = 10;
+  static const int32_t interrupt_value_ = 154;
+  static const int32_t signal_value_ = 1221;
+};
+
+TEST(TestInterruptLoop) {
+  // This test tests that WebAssembly loops can be interrupted, i.e. that if an
+  // InterruptCallback is registered by {Isolate::RequestInterrupt}, then the
+  // InterruptCallback is eventually called even if a loop in WebAssembly code
+  // is executed.
+  // Test setup:
+  // The main thread executes a WebAssembly function with a loop. In the loop
+  // {signal_value_} is written to memory to signal a helper thread that the
+  // main thread reached the loop in the WebAssembly program. When the helper
+  // thread reads {signal_value_} from memory, it registers the
+  // InterruptCallback. Upon exeution, the InterruptCallback write into the
+  // WebAssemblyMemory to end the loop in the WebAssembly program.
+  TestSignatures sigs;
+  Isolate* isolate = CcTest::InitIsolateOnce();
+  v8::internal::AccountingAllocator allocator;
+  Zone zone(&allocator);
+
+  WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
+  WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
+  ExportAsMain(f);
+  byte code[] = {WASM_LOOP(WASM_IFB(
+                     WASM_NOT(WASM_LOAD_MEM(
+                         MachineType::Int32(),
+                         WASM_I32V(InterruptThread::interrupt_location_ * 4))),
+                     WASM_STORE_MEM(MachineType::Int32(), WASM_ZERO,
+                                    WASM_I32V(InterruptThread::signal_value_)),
+                     WASM_BR(1))),
+                 WASM_I32V(121)};
+  f->EmitCode(code, sizeof(code));
+  ZoneBuffer buffer(&zone);
+  builder->WriteTo(buffer);
+
+  HandleScope scope(isolate);
+  testing::SetupIsolateForWasmModule(isolate);
+  ErrorThrower thrower(isolate, "Test");
+  const Handle<JSObject> instance =
+      testing::CompileInstantiateWasmModuleForTesting(
+          isolate, &thrower, &zone, buffer.begin(), buffer.end(),
+          ModuleOrigin::kWasmOrigin);
+  CHECK(!instance.is_null());
+
+  MaybeHandle<JSArrayBuffer> maybe_memory =
+      GetInstanceMemory(isolate, instance);
+  Handle<JSArrayBuffer> memory = maybe_memory.ToHandleChecked();
+  int32_t* memory_array = reinterpret_cast<int32_t*>(memory->backing_store());
+
+  InterruptThread thread(isolate, memory_array);
+  thread.Start();
+  testing::RunWasmModuleForTesting(isolate, instance, 0, nullptr,
+                                   ModuleOrigin::kWasmOrigin);
+  CHECK_EQ(InterruptThread::interrupt_value_,
+           memory_array[InterruptThread::interrupt_location_]);
+}
+
 TEST(Run_WasmModule_GrowMemoryInIf) {
   TestSignatures sigs;
   v8::internal::AccountingAllocator allocator;
   Zone zone(&allocator);
   WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
   WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
   ExportAsMain(f);
   byte code[] = {WASM_IF_ELSE_I(WASM_I32V(0), WASM_GROW_MEMORY(WASM_I32V(1)),
                                 WASM_I32V(12))};
   f->EmitCode(code, sizeof(code));
@@ skipping 35 matching lines @@
       WASM_GROW_MEMORY(WASM_GET_LOCAL(0)), WASM_DROP,
       WASM_STORE_MEM(MachineType::Int32(), WASM_I32V(index), WASM_I32V(value)),
       WASM_LOAD_MEM(MachineType::Int32(), WASM_I32V(index))};
   f->EmitCode(code, sizeof(code));
 
   HandleScope scope(isolate);
   ZoneBuffer buffer(&zone);
   builder->WriteTo(buffer);
   testing::SetupIsolateForWasmModule(isolate);
 
+  ErrorThrower thrower(isolate, "Test");
   Handle<JSObject> instance = testing::CompileInstantiateWasmModuleForTesting(
-      isolate, &zone, buffer.begin(), buffer.end(), ModuleOrigin::kWasmOrigin);
+      isolate, &thrower, &zone, buffer.begin(), buffer.end(),
+      ModuleOrigin::kWasmOrigin);
   CHECK(!instance.is_null());
 
   // Initial memory size is 16 pages, should trap till index > MemSize on
   // consecutive GrowMem calls
   for (uint32_t i = 1; i < 5; i++) {
     Handle<Object> params[1] = {Handle<Object>(Smi::FromInt(i), isolate)};
     v8::TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate));
     testing::RunWasmModuleForTesting(isolate, instance, 1, params,
                                      ModuleOrigin::kWasmOrigin);
     CHECK(try_catch.HasCaught());
@@ skipping 21 matching lines @@
       WASM_GROW_MEMORY(WASM_I8(1)), WASM_DROP,
       WASM_STORE_MEM(MachineType::Int32(), WASM_GET_LOCAL(0), WASM_I32V(value)),
       WASM_LOAD_MEM(MachineType::Int32(), WASM_GET_LOCAL(0))};
   f->EmitCode(code, sizeof(code));
 
   HandleScope scope(isolate);
   ZoneBuffer buffer(&zone);
   builder->WriteTo(buffer);
   testing::SetupIsolateForWasmModule(isolate);
 
+  ErrorThrower thrower(isolate, "Test");
   Handle<JSObject> instance = testing::CompileInstantiateWasmModuleForTesting(
-      isolate, &zone, buffer.begin(), buffer.end(), ModuleOrigin::kWasmOrigin);
+      isolate, &thrower, &zone, buffer.begin(), buffer.end(),
+      ModuleOrigin::kWasmOrigin);
 
   CHECK(!instance.is_null());
 
   // Initial memory size is 16 pages, should trap till index > MemSize on
   // consecutive GrowMem calls
   for (int i = 1; i < 5; i++) {
     Handle<Object> params[1] = {
         Handle<Object>(Smi::FromInt((16 + i) * kPageSize - 3), isolate)};
     v8::TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate));
     testing::RunWasmModuleForTesting(isolate, instance, 1, params,
@@ skipping 102 matching lines @@
 
 TEST(Run_WasmModule_Global_f32) {
   RunWasmModuleGlobalInitTest<float>(kAstF32, -983.9f);
   RunWasmModuleGlobalInitTest<float>(kAstF32, 1122.99f);
 }
 
 TEST(Run_WasmModule_Global_f64) {
   RunWasmModuleGlobalInitTest<double>(kAstF64, -833.9);
   RunWasmModuleGlobalInitTest<double>(kAstF64, 86374.25);
 }