[SIMD] Fix relaxed SIMD in wasm-ctor-eval (#7495)

Relaxed SIMD is a new class of "nonconstant" (too variable to execute at
compile time) code. Throw a non-constant exception in the right place in
the interpreter. This requires moving the NonconstantException class to
a higher place.

Author: kripken

src/binaryen-c.cpp

@@ -6144,7 +6144,7 @@ ExpressionRunnerRunAndDispose(ExpressionRunnerRef runner,
     if (!flow.breaking() && !flow.values.empty()) {
       ret = flow.getConstExpression(*R->getModule());
     }
-  } catch (CExpressionRunner::NonconstantException&) {
+  } catch (NonconstantException&) {
   }
   delete R;
   return ret;

src/passes/Precompute.cpp

@@ -728,7 +728,7 @@ struct Precompute
       flow = PrecomputingExpressionRunner(
                getModule(), getValues, heapValues, replaceExpression)
                .visit(curr);
-    } catch (PrecomputingExpressionRunner::NonconstantException&) {
+    } catch (NonconstantException&) {
       return Flow(NONCONSTANT_FLOW);
     }
     // If we are replacing the expression, then the resulting value must be of

src/tools/wasm-ctor-eval.cpp

@@ -1113,6 +1113,11 @@ EvalCtorOutcome evalCtor(EvallingModuleRunner& instance,
           }
         }
         break;
+      } catch (NonconstantException& fail) {
+        if (!quiet) {
+          std::cout << "  ...stopping due to non-constant code\n";
+        }
+        break;
       }
 
       if (flow.breakTo == RETURN_CALL_FLOW) {

src/wasm-interpreter.h

@@ -51,6 +51,12 @@ struct WasmException {
 };
 std::ostream& operator<<(std::ostream& o, const WasmException& exn);
 
+// An exception thrown when we try to execute non-constant code, that is, code
+// that we cannot properly evaluate at compile time (e.g. if it refers to an
+// import, or we are optimizing and it uses relaxed SIMD).
+// TODO: use a flow with a special name, as this is likely very slow
+struct NonconstantException {};
+
 // Utilities
 
 extern Name WASM, RETURN_FLOW, RETURN_CALL_FLOW, NONCONSTANT_FLOW;
@@ -2457,9 +2463,6 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   std::unordered_map<Name, Literals> globalValues;
 
 public:
-  struct NonconstantException {
-  }; // TODO: use a flow with a special name, as this is likely very slow
-
   ConstantExpressionRunner(Module* module,
                            Flags flags,
                            Index maxDepth,
@@ -4540,6 +4543,10 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
       arguments = flow.values;
     }
 
+    if (flow.breaking() && flow.breakTo == NONCONSTANT_FLOW) {
+      throw NonconstantException();
+    }
+
     // cannot still be breaking, it means we missed our stop
     assert(!flow.breaking() || flow.breakTo == RETURN_FLOW);
     auto type = flow.getType();

test/lit/ctor-eval/relaxed.wast

@@ -0,0 +1,51 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+;; RUN: wasm-ctor-eval %s --ctors=return,drop,passthrough --quiet -all -S -o - | filecheck %s
+
+;; The relaxed SIMD operation here cannot be optimized by wasm-ctor-eval, as we
+;; do not know how the VM that the code will run on should execute it. We can
+;; optimize nothing here, and should not error.
+
+(module
+ ;; CHECK:      (type $0 (func (result v128)))
+
+ ;; CHECK:      (type $1 (func))
+
+ ;; CHECK:      (export "drop" (func $drop))
+
+ ;; CHECK:      (export "passthrough" (func $passthrough))
+
+ ;; CHECK:      (func $return (type $0) (result v128)
+ ;; CHECK-NEXT:  (f32x4.relaxed_max
+ ;; CHECK-NEXT:   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+ ;; CHECK-NEXT:   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $return (export "return") (result v128)
+  ;; This function returns a nonconstant value directly.
+  (f32x4.relaxed_max
+   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+  )
+ )
+
+ ;; CHECK:      (func $drop (type $1)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (call $return)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $drop (export "drop")
+  ;; This function swallows a nonconstant value.
+  (drop
+   (call $return)
+  )
+ )
+
+ ;; CHECK:      (func $passthrough (type $0) (result v128)
+ ;; CHECK-NEXT:  (call $return)
+ ;; CHECK-NEXT: )
+ (func $passthrough (export "passthrough") (result v128)
+  ;; This function passes through a nonconstant value.
+  (call $return)
+ )
+)
+