DeadArgumentElimination: Do not error on bottom types in result refining (#5763)

More generally, the LUB computation that code relies on did not handle
bottom types properly.

1 files changed, 36 insertions, 0 deletions

diff --git a/test/lit/passes/dae_all-features.wast b/test/lit/passes/dae_all-features.wast
index 3e628d6af..71af5a0bc 100644
--- a/test/lit/passes/dae_all-features.wast
+++ b/test/lit/passes/dae_all-features.wast
@@ -692,3 +692,39 @@
   )
  )
 )
+
+(module
+ ;; CHECK:      (type $A (func (result (ref $A))))
+ (type $A (func (result (ref $A))))
+
+ ;; CHECK:      (type $none_=>_none (func))
+
+ ;; CHECK:      (func $no-caller (type $A) (result (ref $A))
+ ;; CHECK-NEXT:  (block ;; (replaces something unreachable we can't emit)
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (ref.null nofunc)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (unreachable)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $no-caller (type $A) (result (ref $A))
+  ;; This return_call is to a bottom type, which we should ignore and not error
+  ;; on. There is nothing to optimize here (other passes will turn this call
+  ;; into an unreachable). In particular we should not be confused by the fact
+  ;; that this expression itself is unreachable (as a return call).
+  (return_call_ref $A
+   (ref.null nofunc)
+  )
+ )
+
+ ;; CHECK:      (func $caller (type $none_=>_none)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (call $no-caller)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $caller
+  (drop
+   (call $no-caller)
+  )
+ )
+)