test/lit/passes/licm.wast

;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.

;; RUN: foreach %s %t wasm-opt -all --licm -S -o - | filecheck %s

(module
 (memory 10 20)

 ;; CHECK:      (type $0 (func (param i32)))

 ;; CHECK:      (type $1 (func (param i32) (result i32)))

 ;; CHECK:      (type $struct (struct (field (mut i32))))
 (type $struct (struct (field (mut i32))))

 ;; CHECK:      (type $3 (func))

 ;; CHECK:      (memory $0 10 20)

 ;; CHECK:      (func $unreachable-get (type $3)
 ;; CHECK-NEXT:  (local $x i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (loop $loop
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $unreachable-get
  (local $x i32)
  (loop $loop
   (unreachable)
   ;; This loop is unreachable. We should not error on handling it (because it
   ;; is unreachable it does not have a basic block, which the analysis uses).
   ;; In this case it is fine to move it out of the loop (though it does not
   ;; really help much).
   (drop
    (local.get $x)
   )
  )
 )

 ;; CHECK:      (func $unreachable-get-call (type $0) (param $p i32)
 ;; CHECK-NEXT:  (local $x i32)
 ;; CHECK-NEXT:  (loop $loop
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (call $unreachable-get-call
 ;; CHECK-NEXT:    (local.get $x)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $unreachable-get-call (param $p i32)
  (local $x i32)
  ;; As above, but now the get is in a call. We cannot move the call out, as it
  ;; may have side effects.
  (loop $loop
   (unreachable)
   (call $unreachable-get-call
    (local.get $x)
   )
  )
 )

 ;; CHECK:      (func $unreachable-get-store (type $0) (param $p i32)
 ;; CHECK-NEXT:  (local $x i32)
 ;; CHECK-NEXT:  (loop $loop
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (i32.store
 ;; CHECK-NEXT:    (local.get $x)
 ;; CHECK-NEXT:    (i32.const 10)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $unreachable-get-store (param $p i32)
  (local $x i32)
  ;; As above, but now the get is stored. This is a different effect than the
  ;; call in the function before us, and it too cannot be moved.
  (loop $loop
   (unreachable)
   (i32.store
    (local.get $x)
    (i32.const 10)
   )
  )
 )

 ;; CHECK:      (func $pause (type $0) (param $p i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (loop $loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (pause)
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (br $loop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $pause (param $p i32)
  ;; We don't want pause to be moved out of loops. In principle we should be
  ;; able to move side-effect-free expressions back before the pause, but we
  ;; currently do not. Pause is rare and specialized enough that this shouldn't
  ;; be a problem.
  (loop $loop
   (drop (i32.const 0))
   (pause)
   (drop (i32.const 1))
   (br $loop)
  )
 )

  ;; CHECK:      (func $bug-inversion (type $1) (param $z i32) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (local.set $y
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $x
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (loop $loop
  ;; CHECK-NEXT:   (local.set $y
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.set $x
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (local.get $y)
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (br_if $loop
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $x)
  ;; CHECK-NEXT: )
  (func $bug-inversion (param $z i32) (result i32)
    (local $x i32)
    (local $y i32)
    (local.set $y (i32.const 0))
    (local.set $x (i32.const 0))
    (loop $loop
      (local.set $y (i32.const 2))
      (local.set $x (i32.add (local.get $y) (i32.const 1)))
      (br_if $loop (i32.const 0))
    )
    (local.get $x)
  )

  ;; CHECK:      (func $bug-cross-statement-dependency (type $1) (param $z i32) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (local.set $x
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $y
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (loop $loop
  ;; CHECK-NEXT:   (local.set $y
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.set $x
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (local.get $z)
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (br_if $loop
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $y)
  ;; CHECK-NEXT: )
  (func $bug-cross-statement-dependency (param $z i32) (result i32)
    (local $x i32)
    (local $y i32)
    (local.set $x (i32.const 0))
    (local.set $y (i32.const 0))
    (loop $loop
      (local.set $y (local.get $x))
      (local.set $x (i32.add (local.get $z) (i32.const 1)))
      (br_if $loop (i32.const 0))
    )
    (local.get $y)
  )

  ;; CHECK:      (func $hoist-trap-before-backedge (type $1) (param $x i32) (result i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (local.set $y
  ;; CHECK-NEXT:    (i32.load
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (loop $loop
  ;; CHECK-NEXT:    (nop)
  ;; CHECK-NEXT:    (br_if $loop
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $y)
  ;; CHECK-NEXT: )
  (func $hoist-trap-before-backedge (param $x i32) (result i32)
    (local $y i32)
    ;; A trapping instruction before the loop's own backedge can still be
    ;; hoisted, because the first iteration always executes it.
    (loop $loop
      (local.set $y
        (i32.load
          (i32.const 0)
        )
      )
      (br_if $loop
        (local.get $x)
      )
    )
    (local.get $y)
  )

  ;; CHECK:      (func $no-hoist-trap-past-inner-loop (type $1) (param $x i32) (result i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (loop $outer
  ;; CHECK-NEXT:   (loop $inner
  ;; CHECK-NEXT:    (br_if $inner
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (local.set $y
  ;; CHECK-NEXT:    (i32.load
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (br_if $outer
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $y)
  ;; CHECK-NEXT: )
  (func $no-hoist-trap-past-inner-loop (param $x i32) (result i32)
    (local $y i32)
    ;; A trapping instruction after an inner loop cannot be hoisted before the
    ;; outer loop, because the inner loop might not terminate.
    (loop $outer
      (loop $inner
        (br_if $inner
          (local.get $x)
        )
      )
      (local.set $y
        (i32.load
          (i32.const 0)
        )
      )
      (br_if $outer
        (local.get $x)
      )
    )
    (local.get $y)
  )

  ;; CHECK:      (func $no-hoist-struct-new (type $0) (param $x i32)
  ;; CHECK-NEXT:  (local $ref (ref null $struct))
  ;; CHECK-NEXT:  (loop $loop
  ;; CHECK-NEXT:   (local.set $ref
  ;; CHECK-NEXT:    (struct.new $struct
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (struct.set $struct 0
  ;; CHECK-NEXT:    (local.get $ref)
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (struct.get $struct 0
  ;; CHECK-NEXT:      (local.get $ref)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (br_if $loop
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $no-hoist-struct-new (param $x i32)
    (local $ref (ref null $struct))
    ;; Each iteration allocates a new struct, so we cannot hoist the allocation
    ;; out of the loop: that would make all iterations use the same struct.
    (loop $loop
      (local.set $ref
        (struct.new $struct
          (i32.const 0)
        )
      )
      (struct.set $struct 0
        (local.get $ref)
        (i32.add
          (struct.get $struct 0
            (local.get $ref)
          )
          (i32.const 1)
        )
      )
      (br_if $loop
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $hoist-ref-i31 (type $0) (param $x i32)
  ;; CHECK-NEXT:  (local $ref i31ref)
  ;; CHECK-NEXT:  (local.set $ref
  ;; CHECK-NEXT:   (ref.i31
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (loop $loop
  ;; CHECK-NEXT:   (nop)
  ;; CHECK-NEXT:   (br_if $loop
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $hoist-ref-i31 (param $x i32)
    (local $ref i31ref)
    ;; In comparison, ref.i31 is not an allocation, so we can hoist it.
    (loop $loop
      (local.set $ref
        (ref.i31
          (i32.const 0)
        )
      )
      (br_if $loop
        (local.get $x)
      )
    )
  )
)