[StackIR] Allow StackIR to be disabled from the commandline (#6725)

Normally we use it when optimizing (above a certain level). This lets the user
prevent it from being used even then.

Also add optimization options to wasm-metadce so that this is possible
there as well and not just in wasm-opt (this also opens the door to running
more passes in metadce, which may be useful later).

scripts/fuzz_opt.py

@@ -1565,6 +1565,7 @@ def write_commands(commands, filename):
     ('--merge-locals',),
     ('--monomorphize',),
     ('--monomorphize-always',),
+    ('--no-stack-ir',),
     ('--once-reduction',),
     ("--optimize-casts",),
     ("--optimize-instructions",),

src/tools/optimization-options.h

@@ -26,12 +26,17 @@
 namespace wasm {
 
 struct OptimizationOptions : public ToolOptions {
+  // By default we allow StackIR and enable it by default in higher optimization
+  // levels, but users can disallow it as well.
+  bool allowStackIR = true;
+
   void parse(int argc, const char* argv[]) {
     ToolOptions::parse(argc, argv);
 
     // After parsing the arguments, update defaults based on the optimize/shrink
     // levels.
-    if (passOptions.optimizeLevel >= 2 || passOptions.shrinkLevel >= 1) {
+    if (allowStackIR &&
+        (passOptions.optimizeLevel >= 2 || passOptions.shrinkLevel >= 1)) {
       passOptions.generateStackIR = true;
       passOptions.optimizeStackIR = true;
     }
@@ -191,6 +196,16 @@ struct OptimizationOptions : public ToolOptions {
            [&](Options* o, const std::string& arguments) {
              passOptions.debugInfo = true;
            })
+      .add("--no-stack-ir",
+           "",
+           "do not use StackIR (even when it is the default)",
+           ToolOptionsCategory,
+           Options::Arguments::Zero,
+           [&](Options* o, const std::string& arguments) {
+             allowStackIR = false;
+             passOptions.generateStackIR = false;
+             passOptions.optimizeStackIR = false;
+           })
       .add("--always-inline-max-function-size",
            "-aimfs",
            "Max size of functions that are always inlined (default " +

src/tools/wasm-metadce.cpp

@@ -29,11 +29,11 @@
 #include "asmjs/shared-constants.h"
 #include "ir/element-utils.h"
 #include "ir/module-utils.h"
+#include "optimization-options.h"
 #include "pass.h"
 #include "support/colors.h"
 #include "support/file.h"
 #include "support/json.h"
-#include "tool-options.h"
 #include "wasm-builder.h"
 #include "wasm-io.h"
 #include "wasm-validator.h"
@@ -371,7 +371,7 @@ int main(int argc, const char* argv[]) {
 
   const std::string WasmMetaDCEOption = "wasm-opt options";
 
-  ToolOptions options(
+  OptimizationOptions options(
     "wasm-metadce",
     "This tool performs dead code elimination (DCE) on a larger space "
     "that the wasm module is just a part of. For example, if you have "

test/lit/help/wasm-opt.test

@@ -759,6 +759,9 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
+;; CHECK-NEXT:                                                 is the default)
+;; CHECK-NEXT:
 ;; CHECK-NEXT:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------

test/lit/help/wasm2js.test

@@ -713,6 +713,9 @@
 ;; CHECK-NEXT:
 ;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
+;; CHECK-NEXT:                                                 is the default)
+;; CHECK-NEXT:
 ;; CHECK-NEXT:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------

test/lit/passes/stack-ir-defaults.wast

@@ -0,0 +1,66 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+
+;; Request StackIR explicitly. This optimizes.
+;; RUN: wasm-opt %s --generate-stack-ir --optimize-stack-ir -all               --print-stack-ir | filecheck %s --check-prefix=REQUESTED
+
+;; As above, but disallow it later. This does not optimize.
+;; RUN: wasm-opt %s --generate-stack-ir --optimize-stack-ir -all --no-stack-ir --print-stack-ir | filecheck %s --check-prefix=DISALLOWD
+
+;; As above, but flip it, so we allow it after disallowing. This optimizes.
+;; RUN: wasm-opt %s --no-stack-ir --generate-stack-ir --optimize-stack-ir -all --print-stack-ir | filecheck %s --check-prefix=REALLOWED
+
+;; Running -O will use StackIR by default. This optimizes.
+;; RUN: wasm-opt %s -O               -all --print-stack-ir | filecheck %s --check-prefix=O_DEFAULT
+
+;; As above, but disallow it. This does not optimize.
+;; RUN: wasm-opt %s -O --no-stack-ir -all --print-stack-ir | filecheck %s --check-prefix=O__DENIED
+
+;; As above, but flip it. This still does not optimize, as the global state of
+;; --no-stack-ir is not overridden (before we explicitly overrode it, while here
+;; we -O only requests StackIR if allowed).
+;; RUN: wasm-opt %s --no-stack-ir -O -all --print-stack-ir | filecheck %s --check-prefix=O_REALLOW
+
+(module
+  ;; REQUESTED:      (import "a" "b" (func $import (type $0) (result i32)))
+  ;; DISALLOWD:      (import "a" "b" (func $import (type $0) (result i32)))
+  ;; REALLOWED:      (import "a" "b" (func $import (type $0) (result i32)))
+  ;; O_DEFAULT:      (import "a" "b" (func $import (type $0) (result i32)))
+  ;; O__DENIED:      (import "a" "b" (func $import (type $0) (result i32)))
+  ;; O_REALLOW:      (import "a" "b" (func $import (type $0) (result i32)))
+  (import "a" "b" (func $import (result i32)))
+
+  ;; REQUESTED:      (func $func (type $0) (result i32)
+  ;; REQUESTED-NEXT:  call $import
+  ;; REQUESTED-NEXT:  unreachable
+  ;; REQUESTED-NEXT: )
+  ;; DISALLOWD:      (func $func (type $0) (result i32)
+  ;; DISALLOWD-NEXT:  call $import
+  ;; DISALLOWD-NEXT:  drop
+  ;; DISALLOWD-NEXT:  unreachable
+  ;; DISALLOWD-NEXT: )
+  ;; REALLOWED:      (func $func (type $0) (result i32)
+  ;; REALLOWED-NEXT:  call $import
+  ;; REALLOWED-NEXT:  unreachable
+  ;; REALLOWED-NEXT: )
+  ;; O_DEFAULT:      (func $func (type $0) (result i32)
+  ;; O_DEFAULT-NEXT:  call $import
+  ;; O_DEFAULT-NEXT:  unreachable
+  ;; O_DEFAULT-NEXT: )
+  ;; O__DENIED:      (func $func (type $0) (result i32)
+  ;; O__DENIED-NEXT:  call $import
+  ;; O__DENIED-NEXT:  drop
+  ;; O__DENIED-NEXT:  unreachable
+  ;; O__DENIED-NEXT: )
+  ;; O_REALLOW:      (func $func (type $0) (result i32)
+  ;; O_REALLOW-NEXT:  call $import
+  ;; O_REALLOW-NEXT:  drop
+  ;; O_REALLOW-NEXT:  unreachable
+  ;; O_REALLOW-NEXT: )
+  (func $func (export "func") (result i32)
+    ;; This drop can be removed when we optimize using StackIR.
+    (drop
+      (call $import)
+    )
+    (unreachable)
+  )
+)