Generalize PossibleConstantValues for immutable globals (#4549)

This moves more logic from ConstantFieldPropagation into PossibleConstantValues,
that is, instead of handling the two cases of a Literal or a Name before calling
PossibleConstantValues, move that code into the helper class. That way all users of
PossibleConstantValues can benefit from it. In particular, this makes
DeadArgumentElimination now support optimizing immutable globals, as well as
ref.func and ref.null.

(Changes to test/lit/passes/dae-gc-refine-params.wast are to avoid the new
optimizations from kicking in, so that it still tests what it tested before.)

1 files changed, 112 insertions, 0 deletions

diff --git a/test/lit/passes/dae_all-features.wast b/test/lit/passes/dae_all-features.wast
index 42a47eb68..41655d849 100644
--- a/test/lit/passes/dae_all-features.wast
+++ b/test/lit/passes/dae_all-features.wast
@@ -538,3 +538,115 @@
   )
  )
 )
+
+;; Arguments that read an immutable global can be optimized, as that is a
+;; constant value.
+(module
+ ;; CHECK:      (type $none_=>_none (func))
+
+ ;; CHECK:      (type $i32_=>_none (func (param i32)))
+
+ ;; CHECK:      (type $i32_i32_=>_none (func (param i32 i32)))
+
+ ;; CHECK:      (global $immut i32 (i32.const 42))
+ (global $immut i32 (i32.const 42))
+
+ ;; CHECK:      (global $immut2 i32 (i32.const 43))
+ (global $immut2 i32 (i32.const 43))
+
+ ;; CHECK:      (global $mut (mut i32) (i32.const 1337))
+ (global $mut (mut i32) (i32.const 1337))
+
+ ;; CHECK:      (func $foo (param $0 i32)
+ ;; CHECK-NEXT:  (local $1 i32)
+ ;; CHECK-NEXT:  (local.set $1
+ ;; CHECK-NEXT:   (global.get $immut)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $foo (param $x i32) (param $y i32)
+  ;; "Use" the params to avoid other optimizations kicking in.
+  (drop (local.get $x))
+  (drop (local.get $y))
+ )
+
+ ;; CHECK:      (func $foo-caller
+ ;; CHECK-NEXT:  (global.set $mut
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (call $foo
+ ;; CHECK-NEXT:   (global.get $mut)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (global.set $mut
+ ;; CHECK-NEXT:   (i32.const 2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (call $foo
+ ;; CHECK-NEXT:   (global.get $mut)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $foo-caller
+  ;; Note how the mutable param has a different value in each call, which shows
+  ;; the reason that we cannot optimize in this case. But we can optimize the
+  ;; immutable param.
+  (global.set $mut (i32.const 1))
+  (call $foo
+   (global.get $immut)
+   (global.get $mut)
+  )
+  (global.set $mut (i32.const 2))
+  (call $foo
+   (global.get $immut)
+   (global.get $mut)
+  )
+ )
+
+ ;; CHECK:      (func $bar (param $x i32) (param $y i32)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (local.get $x)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (local.get $y)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $bar (param $x i32) (param $y i32)
+  (drop (local.get $x))
+  (drop (local.get $y))
+ )
+
+ ;; CHECK:      (func $bar-caller
+ ;; CHECK-NEXT:  (global.set $mut
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (call $bar
+ ;; CHECK-NEXT:   (global.get $immut)
+ ;; CHECK-NEXT:   (global.get $immut)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (global.set $mut
+ ;; CHECK-NEXT:   (i32.const 2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (call $bar
+ ;; CHECK-NEXT:   (global.get $mut)
+ ;; CHECK-NEXT:   (global.get $immut2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $bar-caller
+  ;; Corner cases of mixing mutable with immutable and mixing two immutables.
+  (global.set $mut (i32.const 1))
+  (call $bar
+   (global.get $immut)
+   (global.get $immut)
+  )
+  (global.set $mut (i32.const 2))
+  (call $bar
+   (global.get $mut)
+   (global.get $immut2)
+  )
+ )
+)