[Stack Switching] Simplify clearing of continuation store in the fuzzer (#7871)

Use RAII to ensure we don't miss any code paths when clearing
the continuation state after an export call.

Also remove an entirely unused function, that was confusing
during debugging.

Author: kripken

src/tools/execution-results.h

@@ -443,27 +443,14 @@ struct ExecutionResults {
 
   bool operator!=(ExecutionResults& other) { return !((*this) == other); }
 
-  FunctionResult run(Function* func, Module& wasm) {
-    LoggingExternalInterface interface(loggings, wasm);
-    try {
-      ModuleRunner instance(wasm, &interface);
-      instance.setRelaxedBehavior(ModuleRunner::RelaxedBehavior::Execute);
-      instance.instantiate();
-      interface.setModuleRunner(&instance);
-      return run(func, wasm, instance);
-    } catch (const TrapException&) {
-      // May throw in instance creation (init of offsets).
-      return {};
-    } catch (const HostLimitException&) {
-      // May throw in instance creation (e.g. array.new of huge size).
-      // This should be ignored and not compared with, as optimizations can
-      // change whether a host limit is reached.
-      ignore = true;
-      return {};
-    }
-  }
-
   FunctionResult run(Function* func, Module& wasm, ModuleRunner& instance) {
+    // Clear the continuation state after each run of an export.
+    struct CleanUp {
+      ModuleRunner& instance;
+      CleanUp(ModuleRunner& instance) : instance(instance) {}
+      ~CleanUp() { instance.clearContinuationStore(); }
+    } cleanUp(instance);
+
     try {
       // call the method
       Literals arguments;
@@ -472,30 +459,25 @@ struct ExecutionResults {
         if (!param.isDefaultable()) {
           std::cout << "[trap fuzzer can only send defaultable parameters to "
                        "exports]\n";
-          instance.clearContinuationStore();
           return Trap{};
         }
         arguments.push_back(Literal::makeZero(param));
       }
       auto flow = instance.callFunction(func->name, arguments);
       if (flow.suspendTag) {
         std::cout << "[exception thrown: unhandled suspend]" << std::endl;
-        instance.clearContinuationStore();
         return Exception{};
       }
       return flow.values;
     } catch (const TrapException&) {
-      instance.clearContinuationStore();
       return Trap{};
     } catch (const WasmException& e) {
-      instance.clearContinuationStore();
       std::cout << "[exception thrown: " << e << "]" << std::endl;
       return Exception{};
     } catch (const HostLimitException&) {
       // This should be ignored and not compared with, as optimizations can
       // change whether a host limit is reached.
       ignore = true;
-      instance.clearContinuationStore();
       return {};
     }
   }

test/lit/exec/cont_many_unhandled_2.wast

@@ -0,0 +1,51 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --output=fuzz-exec and should not be edited.
+
+;; RUN: foreach %s %t wasm-opt -all --fuzz-exec-before -q -o /dev/null 2>&1 | filecheck %s
+
+;; Three exports, one which suspends, another that does a resume-throw but
+;; catches it, and another that does a suspend through a call to JS, then a
+;; normal suspend. This is a regression test for a bug where the global state of
+;; continuations got into a confused state in the middle, and asserted.
+
+(module
+ (type $func (func))
+ (type $cont (cont $func))
+
+ (import "fuzzing-support" "call-export-catch" (func $call-export-catch (param i32) (result i32)))
+
+ (tag $tag (type $func))
+
+ ;; CHECK:      [fuzz-exec] calling suspend
+ ;; CHECK-NEXT: [exception thrown: unhandled suspend]
+ (func $suspend (export "suspend")
+  (suspend $tag)
+ )
+
+ ;; CHECK:      [fuzz-exec] calling try-resume
+ (func $try-resume (export "try-resume")
+  (block $block
+   (try_table (catch_all $block)
+    (resume_throw $cont $tag
+     (cont.new $cont
+      (ref.func $nop)
+     )
+    )
+   )
+  )
+ )
+
+ ;; CHECK:      [fuzz-exec] calling call-suspend
+ ;; CHECK-NEXT: [exception thrown: unhandled suspend]
+ (func $call-suspend (export "call-suspend")
+  (drop
+   (call $call-export-catch
+    (i32.const 0)
+   )
+  )
+  (suspend $tag)
+ )
+
+ (func $nop
+ )
+)
+