test/lit/passes/duplicate-function-elimination_annotations.wast

;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
;; NOTE: This test was ported using port_passes_tests_to_lit.py and could be cleaned up.

;; RUN: foreach %s %t wasm-opt --duplicate-function-elimination --all-features                               -S -o - | filecheck %s
;; RUN: foreach %s %t wasm-opt --duplicate-function-elimination --all-features --expect-later-toolchain-opts -S -o - | filecheck %s --check-prefix=LATER

;; One function has the js.called hint, so we merge only if we do not expect
;; later toolchain opts (and keep the hint on the merged function).
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $a))

 ;; CHECK:      (@binaryen.js.called)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.js.called)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.js.called)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; LATER:      (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Flipped, now other has it. Again, we merge only if we do not expect later
;; toolchain opts (and keep the hint on the merged function).
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $a))

 ;; CHECK:      (@binaryen.js.called)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; LATER:      (@binaryen.js.called)
 ;; LATER-NEXT: (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.js.called)
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Both have it, so we always merge.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $a))

 ;; CHECK:      (@binaryen.js.called)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $a))

 ;; LATER:      (@binaryen.js.called)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.js.called)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 (@binaryen.js.called)
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Just one function has removable.if.unused, so we do not merge. Unlike
;; js.called, we cannot merge and apply the annotation, as the annotation alters
;; semantics (whereas js.called just warns about something we should not break,
;; so applying it to more places can inhibit opts, but not break things). We
;; could *remove* it after merging, however TODO
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $b))

 ;; CHECK:      (@binaryen.removable.if.unused)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.removable.if.unused)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.removable.if.unused)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; CHECK:      (func $b (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Mix-and-match of hints, each with a different one. We do not merge.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $b))

 ;; CHECK:      (@binaryen.removable.if.unused)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.removable.if.unused)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.removable.if.unused)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; CHECK:      (@binaryen.js.called)
 ;; CHECK-NEXT: (func $b (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (@binaryen.js.called)
 ;; LATER-NEXT: (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.js.called)
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Identical on one hint, different on another, so we do not merge.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $b))

 ;; CHECK:      (@binaryen.removable.if.unused)
 ;; CHECK-NEXT: (@binaryen.js.called)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.removable.if.unused)
 ;; LATER-NEXT: (@binaryen.js.called)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.removable.if.unused)
 (@binaryen.js.called)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; CHECK:      (@binaryen.js.called)
 ;; CHECK-NEXT: (func $b (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (@binaryen.js.called)
 ;; LATER-NEXT: (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.js.called)
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; Both hints are present, so we do merge. Note the order differs and does not
;; confuse us.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $a))

 ;; CHECK:      (@binaryen.removable.if.unused)
 ;; CHECK-NEXT: (@binaryen.js.called)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $a))

 ;; LATER:      (@binaryen.removable.if.unused)
 ;; LATER-NEXT: (@binaryen.js.called)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.removable.if.unused)
 (@binaryen.js.called)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 (@binaryen.js.called)
 (@binaryen.removable.if.unused)
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; One function has the idempotent hint, so we do not merge.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $b))

 ;; CHECK:      (@binaryen.idempotent)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.idempotent)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.idempotent)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; CHECK:      (func $b (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)

;; One function has the noreturn hint, so we do not merge.
(module
 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (export "a" (func $a))

 ;; CHECK:      (export "b" (func $b))

 ;; CHECK:      (@binaryen.noreturn)
 ;; CHECK-NEXT: (func $a (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (type $0 (func (param i32)))

 ;; LATER:      (export "a" (func $a))

 ;; LATER:      (export "b" (func $b))

 ;; LATER:      (@binaryen.noreturn)
 ;; LATER-NEXT: (func $a (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (@binaryen.noreturn)
 (func $a (export "a") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )

 ;; CHECK:      (func $b (type $0) (param $x i32)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:   (then
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 ;; LATER:      (func $b (type $0) (param $x i32)
 ;; LATER-NEXT:  (if
 ;; LATER-NEXT:   (local.get $x)
 ;; LATER-NEXT:   (then
 ;; LATER-NEXT:    (unreachable)
 ;; LATER-NEXT:   )
 ;; LATER-NEXT:  )
 ;; LATER-NEXT: )
 (func $b (export "b") (param $x i32)
  (if
   (local.get $x)
   (then
    (unreachable)
   )
  )
 )
)