test/lit/passes/optimize-instructions-struct-rmw.wast

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

;; RUN: foreach %s %t wasm-opt -all --optimize-instructions --preserve-type-order -S -o - | filecheck %s

(module
  ;; CHECK:      (type $i32 (shared (struct (field (mut i32)))))
  (type $i32 (shared (struct (field (mut i32)))))
  ;; CHECK:      (type $i64 (shared (struct (field (mut i64)))))
  (type $i64 (shared (struct (field (mut i64)))))
  ;; CHECK:      (type $struct (shared (struct (field (mut (ref null $struct))))))
  (type $struct (shared (struct (field (mut (ref null $struct))))))
  ;; CHECK:      (type $unshared-i32 (struct (field (mut i32))))
  (type $unshared-i32 (struct (field (mut i32))))
  ;; CHECK:      (type $unshared-i64 (struct (field (mut i64))))
  (type $unshared-i64 (struct (field (mut i64))))
  ;; CHECK:      (type $unshared-struct (struct (field (mut (ref null $unshared-struct)))))
  (type $unshared-struct (struct (field (mut (ref null $unshared-struct)))))

  ;; CHECK:      (type $super (sub (struct)))
  (type $super (sub (struct)))
  ;; CHECK:      (type $sub (sub $super (struct)))
  (type $sub (sub $super (struct)))
  ;; CHECK:      (type $holds-sub (struct (field (mut (ref $sub)))))
  (type $holds-sub (struct (field (mut (ref $sub)))))

  ;; CHECK:      (type $shared-super (sub (shared (struct))))
  (type $shared-super (sub (shared (struct))))
  ;; CHECK:      (type $shared-sub (sub $shared-super (shared (struct))))
  (type $shared-sub (sub $shared-super (shared (struct))))
  ;; CHECK:      (type $holds-shared-sub (struct (field (mut (ref $shared-sub)))))
  (type $holds-shared-sub (struct (field (mut (ref $shared-sub)))))

  ;; CHECK:      (type $array (array (mut i32)))
  (type $array (array (mut i32)))

  ;; CHECK:      (func $rmw-skip-non-null-cast (type $13) (param $0 (ref null $i32)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.add $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-skip-non-null-cast (param (ref null $i32) i32) (result i32)
    (struct.atomic.rmw.add $i32 0
      (ref.as_non_null
        (local.get 0)
      )
      (local.get 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-skip-non-null-cast (type $14) (param $0 (ref null $i32)) (param $1 i32) (param $2 i32) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-skip-non-null-cast (param (ref null $i32) i32 i32) (result i32)
    (struct.atomic.rmw.cmpxchg $i32 0
      (ref.as_non_null
        (local.get 0)
      )
      (local.get 1)
      (local.get 2)
    )
  )

  ;; CHECK:      (func $array-rmw-skip-non-null-cast (type $15) (param $0 (ref null $array)) (param $1 i32) (param $2 i32) (result i32)
  ;; CHECK-NEXT:  (array.atomic.rmw.add $array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $array-rmw-skip-non-null-cast (param (ref null $array) i32 i32) (result i32)
    (array.atomic.rmw.add $array
      (ref.as_non_null
        (local.get 0)
      )
      (local.get 1)
      (local.get 2)
    )
  )

  ;; CHECK:      (func $array-cmpxchg-skip-non-null-cast (type $16) (param $0 (ref null $array)) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
  ;; CHECK-NEXT:  (array.atomic.rmw.cmpxchg $array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $3)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $array-cmpxchg-skip-non-null-cast (param (ref null $array) i32 i32 i32) (result i32)
    (array.atomic.rmw.cmpxchg $array
      (ref.as_non_null
        (local.get 0)
      )
      (local.get 1)
      (local.get 2)
      (local.get 3)
    )
  )

  ;; CHECK:      (func $rmw-trap-on-null (type $17) (result i32)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $rmw-trap-on-null (result i32)
    (struct.atomic.rmw.add $i32 0
      (ref.null (shared none))
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-trap-on-null (type $17) (result i32)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $cmpxchg-trap-on-null (result i32)
    (struct.atomic.rmw.cmpxchg $i32 0
      (ref.null (shared none))
      (i32.const 1)
      (i32.const 2)
    )
  )

  ;; CHECK:      (func $array-rmw-trap-on-null (type $17) (result i32)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $array-rmw-trap-on-null (result i32)
    (array.atomic.rmw.add $array
      (ref.null none)
      (i32.const 1)
      (i32.const 2)
    )
  )

  ;; CHECK:      (func $array-cmpxchg-trap-on-null (type $17) (result i32)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $array-cmpxchg-trap-on-null (result i32)
    (array.atomic.rmw.cmpxchg $array
      (ref.null none)
      (i32.const 1)
      (i32.const 2)
      (i32.const 3)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-ident (param (ref null $i32)) (result i32)
    ;; This can be optimized to just an atomic load.
    (struct.atomic.rmw.add acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.add acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-noident (param (ref null $i32)) (result i32)
    ;; But this cannot be optimized at all.
    (struct.atomic.rmw.add acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-sub-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-sub-i32-ident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.sub acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-sub-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.sub acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-sub-i32-noident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.sub acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-and-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const -1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-and-i32-ident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.and acqrel acqrel $i32 0
      (local.get 0)
      (i32.const -1)
    )
  )

  ;; CHECK:      (func $rmw-and-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.and acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-and-i32-noident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.and acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-or-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-or-i32-ident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.or acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-or-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.or acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const -1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-or-i32-noident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.or acqrel acqrel $i32 0
      (local.get 0)
      (i32.const -1)
    )
  )

  ;; CHECK:      (func $rmw-xor-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xor-i32-ident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.xor acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-xor-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xor acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const -1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xor-i32-noident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.xor acqrel acqrel $i32 0
      (local.get 0)
      (i32.const -1)
    )
  )

  ;; CHECK:      (func $rmw-xchg-i32-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (struct.get $i32 0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i32-ident (param (ref null $i32)) (result i32)
    ;; TODO: Optimize this case.
    (struct.atomic.rmw.xchg acqrel acqrel $i32 0
      (local.get 0)
      (struct.get $i32 0
        (local.get 0)
      )
    )
  )

  ;; CHECK:      (func $rmw-xchg-i32-noident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i32-noident (param (ref null $i32)) (result i32)
    (struct.atomic.rmw.xchg acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $cmpxchg-i32-ident (type $13) (param $0 (ref null $i32)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i32 0
  ;; CHECK-NEXT:   (block (result (ref null $i32))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-i32-ident (param (ref null $i32) i32) (result i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $i32 0
      (local.get 0)
      (local.get 1)
      (local.get 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-i32-noident (type $13) (param $0 (ref null $i32)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-i32-noident (param (ref null $i32) i32) (result i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $i32 0
      (local.get 0)
      (i32.const 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-add-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i64.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i64-ident (param (ref null $i64)) (result i64)
    ;; This can be optimized to just an atomic load.
    (struct.atomic.rmw.add acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.add acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i64-noident (param (ref null $i64)) (result i64)
    ;; But this cannot be optimized at all.
    (struct.atomic.rmw.add acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-sub-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i64.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-sub-i64-ident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.sub acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $rmw-sub-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.sub acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-sub-i64-noident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.sub acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-and-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i64.const -1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-and-i64-ident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.and acqrel acqrel $i64 0
      (local.get 0)
      (i64.const -1)
    )
  )

  ;; CHECK:      (func $rmw-and-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.and acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-and-i64-noident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.and acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $rmw-or-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i64.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-or-i64-ident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.or acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $rmw-or-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.or acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const -1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-or-i64-noident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.or acqrel acqrel $i64 0
      (local.get 0)
      (i64.const -1)
    )
  )

  ;; CHECK:      (func $rmw-xor-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i64.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xor-i64-ident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.xor acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $rmw-xor-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xor acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const -1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xor-i64-noident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.xor acqrel acqrel $i64 0
      (local.get 0)
      (i64.const -1)
    )
  )

  ;; CHECK:      (func $rmw-xchg-i64-ident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (struct.get $i64 0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i64-ident (param (ref null $i64)) (result i64)
    ;; TODO: Optimize this case.
    (struct.atomic.rmw.xchg acqrel acqrel $i64 0
      (local.get 0)
      (struct.get $i64 0
        (local.get 0)
      )
    )
  )

  ;; CHECK:      (func $rmw-xchg-i64-noident (type $19) (param $0 (ref null $i64)) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i64-noident (param (ref null $i64)) (result i64)
    (struct.atomic.rmw.xchg acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
    )
  )

  ;; CHECK:      (func $cmpxchg-i64-ident (type $20) (param $0 (ref null $i64)) (param $1 i64) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $i64 0
  ;; CHECK-NEXT:   (block (result (ref null $i64))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-i64-ident (param (ref null $i64) i64) (result i64)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $i64 0
      (local.get 0)
      (local.get 1)
      (local.get 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-i64-noident (type $20) (param $0 (ref null $i64)) (param $1 i64) (result i64)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $i64 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i64.const 0)
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-i64-noident (param (ref null $i64) i64) (result i64)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $i64 0
      (local.get 0)
      (i64.const 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-xchg-ref-ident (type $21) (param $0 (ref null $struct)) (result (ref null $struct))
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (struct.get $struct 0
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-ref-ident (param (ref null $struct)) (result (ref null $struct))
    ;; TODO: Optimize this case.
    (struct.atomic.rmw.xchg acqrel acqrel $struct 0
      (local.get 0)
      (struct.get $struct 0
        (local.get 0)
      )
    )
  )

  ;; CHECK:      (func $rmw-xchg-ref-noident (type $21) (param $0 (ref null $struct)) (result (ref null $struct))
  ;; CHECK-NEXT:  (struct.atomic.rmw.xchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-xchg-ref-noident (param (ref null $struct)) (result (ref null $struct))
    (struct.atomic.rmw.xchg acqrel acqrel $struct 0
      (local.get 0)
      (local.get 0)
    )
  )

  ;; CHECK:      (func $cmpxchg-ref-ident (type $21) (param $0 (ref null $struct)) (result (ref null $struct))
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref null $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-ref-ident (param (ref null $struct)) (result (ref null $struct))
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get 0)
      (local.get 0)
      (local.get 0)
    )
  )

  ;; CHECK:      (func $cmpxchg-ref-ident-null (type $21) (param $0 (ref null $struct)) (result (ref null $struct))
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref null $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (ref.null (shared none))
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (ref.null (shared none))
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-ref-ident-null (param (ref null $struct)) (result (ref null $struct))
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get 0)
      (ref.null (shared none))
      (ref.null (shared none))
    )
  )

  ;; CHECK:      (func $cmpxchg-ref-noident (type $21) (param $0 (ref null $struct)) (result (ref null $struct))
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (ref.null (shared none))
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-ref-noident (param (ref null $struct)) (result (ref null $struct))
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get 0)
      (ref.null (shared none))
      (local.get 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-seqcst-ident (type $18) (param $0 (ref null $i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.add $i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-seqcst-ident (param (ref null $i32)) (result i32)
    ;; Check that seqcst rmws are not optimized to acquire gets.
    (struct.atomic.rmw.add $i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-unshared-ident (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get $unshared-i32 0
  ;; CHECK-NEXT:   (block (result (ref null $unshared-i32))
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-unshared-ident (param (ref null $unshared-i32)) (result i32)
    ;; Check just one unshared seqcst case to make sure we do the same identity
    ;; optimizations tested above.
    (struct.atomic.rmw.add $unshared-i32 0
      (local.get 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $cmpxchg-i32-unshared-ident (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get $unshared-i32 0
  ;; CHECK-NEXT:   (block (result (ref null $unshared-i32))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-i32-unshared-ident (param (ref null $unshared-i32)) (result i32)
    ;; Check the same for cmpxchg.
    (struct.atomic.rmw.cmpxchg $unshared-i32 0
      (local.get 0)
      (i32.const 0)
      (i32.const 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.add $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-sub-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.sub
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-sub-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.sub $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-and-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.and
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-and-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.and $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-or-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.or
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-or-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.or $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-xor-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.xor
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-xor-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.xor $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $rmw-xchg-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.xchg $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-i32-lower (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local $4 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.eq
  ;; CHECK-NEXT:    (local.tee $4
  ;; CHECK-NEXT:     (struct.get $unshared-i32 0
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (struct.set $unshared-i32 0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $4)
  ;; CHECK-NEXT: )
  (func $cmpxchg-i32-lower (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.cmpxchg $unshared-i32 0
      (local.get 0)
      (i32.const 1)
      (i32.const 2)
    )
  )

  ;; CHECK:      (func $rmw-add-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i64.add
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-add-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.add $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-sub-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i64.sub
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-sub-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.sub $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-and-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i64.and
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-and-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.and $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-or-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i64.or
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-or-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.or $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-xor-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i64.xor
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-xor-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.xor $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $rmw-xchg-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i64 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i64 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-xchg-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.xchg $unshared-i64 0
      (local.get 0)
      (i64.const 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-i64-lower (type $23) (param $0 (ref null $unshared-i64)) (result i64)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i64))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i64)
  ;; CHECK-NEXT:  (local $4 i64)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i64.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (i64.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i64.eq
  ;; CHECK-NEXT:    (local.tee $4
  ;; CHECK-NEXT:     (struct.get $unshared-i64 0
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (struct.set $unshared-i64 0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $4)
  ;; CHECK-NEXT: )
  (func $cmpxchg-i64-lower (param (ref null $unshared-i64)) (result i64)
    (struct.atomic.rmw.cmpxchg $unshared-i64 0
      (local.get 0)
      (i64.const 1)
      (i64.const 2)
    )
  )

  ;; CHECK:      (func $rmw-xchg-ref-lower (type $24) (param $0 (ref null $unshared-struct)) (result (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $2 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $3 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (ref.null none)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-struct 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-struct 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-xchg-ref-lower (param (ref null $unshared-struct)) (result (ref null $unshared-struct))
    (struct.atomic.rmw.xchg $unshared-struct 0
      (local.get 0)
      (ref.null none)
    )
  )

  ;; CHECK:      (func $cmpxchg-ref-lower (type $24) (param $0 (ref null $unshared-struct)) (result (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $2 eqref)
  ;; CHECK-NEXT:  (local $3 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local $4 (ref null $unshared-struct))
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (ref.null none)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (ref.eq
  ;; CHECK-NEXT:    (local.tee $4
  ;; CHECK-NEXT:     (struct.get $unshared-struct 0
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (struct.set $unshared-struct 0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $4)
  ;; CHECK-NEXT: )
  (func $cmpxchg-ref-lower (param (ref null $unshared-struct)) (result (ref null $unshared-struct))
    (struct.atomic.rmw.cmpxchg $unshared-struct 0
      (local.get 0)
      (ref.null none)
      (local.get 0)
    )
  )

  ;; CHECK:      (func $rmw-add-i32-acqrel (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (struct.get $unshared-i32 0
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $3)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $3)
  ;; CHECK-NEXT: )
  (func $rmw-add-i32-acqrel (param (ref null $unshared-i32)) (result i32)
    ;; Check that the lowering of an acqrel RMW works the same way.
    (struct.atomic.rmw.add acqrel acqrel $unshared-i32 0
      (local.get 0)
      (i32.const 1)
    )
  )

  ;; CHECK:      (func $cmpxchg-i32-acqrel (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (local $1 (ref null $unshared-i32))
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local $4 i32)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $2
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.eq
  ;; CHECK-NEXT:    (local.tee $4
  ;; CHECK-NEXT:     (struct.get $unshared-i32 0
  ;; CHECK-NEXT:      (local.get $1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (struct.set $unshared-i32 0
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $4)
  ;; CHECK-NEXT: )
  (func $cmpxchg-i32-acqrel (param (ref null $unshared-i32)) (result i32)
    ;; Same for an cmpxchg.
    (struct.atomic.rmw.cmpxchg acqrel acqrel $unshared-i32 0
      (local.get 0)
      (i32.const 1)
      (i32.const 2)
    )
  )

  ;; CHECK:      (func $struct-rmw-unreachable-lowering (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.add $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $struct-rmw-unreachable-lowering (param (ref null $unshared-i32)) (result i32)
    ;; Check that we skip lowering if an operand is unreachable.
    (struct.atomic.rmw.add $unshared-i32 0
      (local.get 0)
      (unreachable)
    )
  )

  ;; CHECK:      (func $struct-cmpxchg-unreachable-lowering (type $22) (param $0 (ref null $unshared-i32)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg $unshared-i32 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $struct-cmpxchg-unreachable-lowering (param (ref null $unshared-i32)) (result i32)
    (struct.atomic.rmw.cmpxchg $unshared-i32 0
      (local.get 0)
      (i32.const 1)
      (unreachable)
    )
  )

  ;; CHECK:      (func $array-rmw-unreachable-lowering (type $25) (param $0 (ref null $array)) (result i32)
  ;; CHECK-NEXT:  (array.atomic.rmw.add $array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $array-rmw-unreachable-lowering (param (ref null $array)) (result i32)
    ;; Check that we skip lowering if an operand is unreachable.
    (array.atomic.rmw.add $array
      (local.get 0)
      (i32.const 0)
      (unreachable)
    )
  )

  ;; CHECK:      (func $cmpxchg-unreachable-lowering (type $25) (param $0 (ref null $array)) (result i32)
  ;; CHECK-NEXT:  (array.atomic.rmw.cmpxchg $array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $cmpxchg-unreachable-lowering (param (ref null $array)) (result i32)
    (array.atomic.rmw.cmpxchg $array
      (local.get 0)
      (i32.const 0)
      (i32.const 1)
      (unreachable)
    )
  )

  ;; CHECK:      (func $cmpxchg-expected-supertype (type $26) (param $ref (ref $holds-sub)) (param $expected (ref $super)) (param $replacement (ref $sub)) (result (ref $sub))
  ;; CHECK-NEXT:  (local $3 (ref $holds-sub))
  ;; CHECK-NEXT:  (local $4 eqref)
  ;; CHECK-NEXT:  (local $5 (ref $sub))
  ;; CHECK-NEXT:  (local $6 (ref $sub))
  ;; CHECK-NEXT:  (local.set $3
  ;; CHECK-NEXT:   (local.get $ref)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $4
  ;; CHECK-NEXT:   (local.get $expected)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.set $5
  ;; CHECK-NEXT:   (local.get $replacement)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (ref.eq
  ;; CHECK-NEXT:    (local.tee $6
  ;; CHECK-NEXT:     (struct.get $holds-sub 0
  ;; CHECK-NEXT:      (local.get $3)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $4)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (struct.set $holds-sub 0
  ;; CHECK-NEXT:     (local.get $3)
  ;; CHECK-NEXT:     (local.get $5)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (local.get $6)
  ;; CHECK-NEXT: )
  (func $cmpxchg-expected-supertype (param $ref (ref $holds-sub))
                                    (param $expected (ref $super))
                                    (param $replacement (ref $sub))
                                    (result (ref $sub))
    ;; `expected` can be a supertype of the field type as long as it is an
    ;; eqref. We should handle this correctly by creating an eqref scratch
    ;; local for it.
    (struct.atomic.rmw.cmpxchg $holds-sub 0
      (local.get $ref)
      (local.get $expected)
      (local.get $replacement)
    )
  )

    ;; CHECK:      (func $cmpxchg-expected-supertype-shared (type $27) (param $ref (ref $holds-shared-sub)) (param $expected (ref $shared-super)) (param $replacement (ref $shared-sub)) (result (ref $shared-sub))
    ;; CHECK-NEXT:  (local $3 (ref $holds-shared-sub))
    ;; CHECK-NEXT:  (local $4 (ref null (shared eq)))
    ;; CHECK-NEXT:  (local $5 (ref $shared-sub))
    ;; CHECK-NEXT:  (local $6 (ref $shared-sub))
    ;; CHECK-NEXT:  (local.set $3
    ;; CHECK-NEXT:   (local.get $ref)
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT:  (local.set $4
    ;; CHECK-NEXT:   (local.get $expected)
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT:  (local.set $5
    ;; CHECK-NEXT:   (local.get $replacement)
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT:  (if
    ;; CHECK-NEXT:   (ref.eq
    ;; CHECK-NEXT:    (local.tee $6
    ;; CHECK-NEXT:     (struct.get $holds-shared-sub 0
    ;; CHECK-NEXT:      (local.get $3)
    ;; CHECK-NEXT:     )
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:    (local.get $4)
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:   (then
    ;; CHECK-NEXT:    (struct.set $holds-shared-sub 0
    ;; CHECK-NEXT:     (local.get $3)
    ;; CHECK-NEXT:     (local.get $5)
    ;; CHECK-NEXT:    )
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT:  (local.get $6)
    ;; CHECK-NEXT: )
    (func $cmpxchg-expected-supertype-shared (param $ref (ref $holds-shared-sub))
                                             (param $expected (ref $shared-super))
                                             (param $replacement (ref $shared-sub))
                                             (result (ref $shared-sub))
    ;; Same, but now with a shared type. The scratch local needs to be a shared
    ;; eqref.
    (struct.atomic.rmw.cmpxchg $holds-shared-sub 0
      (local.get $ref)
      (local.get $expected)
      (local.get $replacement)
    )
  )
)

;; Test the effect analysis in areConsecutiveInputsEqual by optimizing (or not)
;; cmpxchg operations with matching expected and replacement operands.
(module
  ;; CHECK:      (type $struct (shared (struct (field (mut i32)))))
  (type $struct (shared (struct (field (mut i32)))))
  ;; CHECK:      (type $array (shared (array (mut i32))))
  (type $array (shared (array (mut i32))))

  ;; CHECK:      (func $release-store-before (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (local $temp i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.tee $temp
  ;; CHECK-NEXT:       (block (result i32)
  ;; CHECK-NEXT:        (array.atomic.set acqrel $array
  ;; CHECK-NEXT:         (local.get $array)
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (struct.get $struct 0
  ;; CHECK-NEXT:         (local.get $struct)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (struct.get $struct 0
  ;; CHECK-NEXT:       (local.get $struct)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $release-store-before (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (local $temp i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      ;; This tee does not affect the value of the right-hand side, so we can
      ;; ignore it.
      (local.tee $temp
        (block (result i32)
          ;; This release store is not ordered before the struct.get, so we know
          ;; it cannot influence the struct.get's value, so we can optimize.
          (array.atomic.set acqrel $array (local.get $array) (i32.const 0) (i32.const 0))
          (struct.get $struct 0 (local.get $struct))
        )
      )
      (struct.get $struct 0 (local.get $struct))
    )
  )

  ;; CHECK:      (func $acquire-load-before (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (local $temp i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.tee $temp
  ;; CHECK-NEXT:       (block (result i32)
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (array.atomic.get acqrel $array
  ;; CHECK-NEXT:          (local.get $array)
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (struct.get $struct 0
  ;; CHECK-NEXT:         (local.get $struct)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (struct.get $struct 0
  ;; CHECK-NEXT:       (local.get $struct)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $acquire-load-before (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (local $temp i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      ;; This tee does not affect the value of the right-hand side, so we can
      ;; ignore it.
      (local.tee $temp
        (block (result i32)
          ;; This acquire load is ordered before the struct.get, so can affect
          ;; its value. However, it affects both struct.gets equally, so we can
          ;; optimize anyway. (The code used to do a coarser check for ordering
          ;; here that would prevent optimization.)
          (drop (array.atomic.get acqrel $array (local.get $array) (i32.const 0)))
          (struct.get $struct 0 (local.get $struct))
        )
      )
      (struct.get $struct 0 (local.get $struct))
    )
  )

  ;; CHECK:      (func $release-store-middle-lhs (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:    (block (result (ref $struct))
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (br_if $l
  ;; CHECK-NEXT:        (struct.get $struct 0
  ;; CHECK-NEXT:         (local.get $struct)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (block (result i32)
  ;; CHECK-NEXT:         (array.atomic.set acqrel $array
  ;; CHECK-NEXT:          (local.get $array)
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (struct.get $struct 0
  ;; CHECK-NEXT:        (local.get $struct)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $release-store-middle-lhs (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (br_if $l
          ;; This is the fallthrough value.
          (struct.get $struct 0 (local.get $struct))
          ;; The condition is executed after the fallthrough, so its effects can
          ;; affect the right-hand side in principle. However, the release store
          ;; does not affect the value, so we can still optimize.
          (block (result i32)
            (array.atomic.set acqrel $array (local.get $array) (i32.const 0) (i32.const 0))
            (i32.const 0)
          )
        )
        (struct.get $struct 0 (local.get $struct))
      )
    )
  )

  ;; CHECK:      (func $acquire-load-middle-lhs (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:    (br_if $l
  ;; CHECK-NEXT:     (struct.get $struct 0
  ;; CHECK-NEXT:      (local.get $struct)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (array.atomic.get acqrel $array
  ;; CHECK-NEXT:        (local.get $array)
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (struct.get $struct 0
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $acquire-load-middle-lhs (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (br_if $l
          ;; This is the fallthrough value.
          (struct.get $struct 0 (local.get $struct))
          ;; The acquire load could form a synchronization edge that forces the
          ;; the right-hand struct.get to observe a different value, so it
          ;; blocks optimization.
          (block (result i32)
            (drop (array.atomic.get acqrel $array (local.get $array) (i32.const 0)))
            (i32.const 0)
          )
        )
        (struct.get $struct 0 (local.get $struct))
      )
    )
  )

  ;; CHECK:      (func $release-store-middle-rhs (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (struct.get $struct 0
  ;; CHECK-NEXT:       (local.get $struct)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (block (result i32)
  ;; CHECK-NEXT:       (array.atomic.set acqrel $array
  ;; CHECK-NEXT:        (local.get $array)
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (struct.get $struct 0
  ;; CHECK-NEXT:        (local.get $struct)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $release-store-middle-rhs (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (struct.get $struct 0 (local.get $struct))
      (block (result i32)
        ;; This release store is executed between the LHS and RHS struct.gets,
        ;; but does not change the value observed by the RHS, so does not block
        ;; optimization.
        (array.atomic.set acqrel $array (local.get $array) (i32.const 0) (i32.const 0))
        (struct.get $struct 0 (local.get $struct))
      )
    )
  )

  ;; CHECK:      (func $acquire-load-middle-rhs (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:   (struct.get $struct 0
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result i32)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (array.atomic.get acqrel $array
  ;; CHECK-NEXT:      (local.get $array)
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (struct.get $struct 0
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $acquire-load-middle-rhs (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (struct.get $struct 0 (local.get $struct))
      (block (result i32)
        ;; This acquire load is executed between the LHS and RHS struct.gets and
        ;; can create a synchronization edge forcing the RHS to observe a
        ;; different value, so it blocks optimization.
        (drop (array.atomic.get acqrel $array (local.get $array) (i32.const 0)))
        (struct.get $struct 0 (local.get $struct))
      )
    )
  )

  ;; CHECK:      (func $release-store-after (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:    (struct.get $struct 0
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br_if $l
  ;; CHECK-NEXT:     (struct.get $struct 0
  ;; CHECK-NEXT:      (local.get $struct)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (array.atomic.set acqrel $array
  ;; CHECK-NEXT:       (local.get $array)
  ;; CHECK-NEXT:       (i32.const 0)
  ;; CHECK-NEXT:       (i32.const 0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $release-store-after (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (struct.get $struct 0 (local.get $struct))
        (br_if $l
          ;; This is the RHS value.
          (struct.get $struct 0 (local.get $struct))
          ;; The condition is executed after the RHS value is computed, so its
          ;; effects cannot affect the values seen by the cmpxchg and can never
          ;; block optimization.
          ;; TODO: getImmediateFallthroughPtr "helpfully" only allows
          ;; fallthrough via br_if when the value and condition can be
          ;; reordered, so unnecessarily blocks this optimization.
          (block (result i32)
            (array.atomic.set acqrel $array (local.get $array) (i32.const 0) (i32.const 0))
            (i32.const 0)
          )
        )
      )
    )
  )

  ;; CHECK:      (func $acquire-load-after (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:    (block (result (ref $struct))
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (struct.get $struct 0
  ;; CHECK-NEXT:        (local.get $struct)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (br_if $l
  ;; CHECK-NEXT:        (struct.get $struct 0
  ;; CHECK-NEXT:         (local.get $struct)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (block (result i32)
  ;; CHECK-NEXT:         (drop
  ;; CHECK-NEXT:          (array.atomic.get acqrel $array
  ;; CHECK-NEXT:           (local.get $array)
  ;; CHECK-NEXT:           (i32.const 0)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $acquire-load-after (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (struct.get $struct 0 (local.get $struct))
        (br_if $l
          ;; This is the RHS value.
          (struct.get $struct 0 (local.get $struct))
          ;; The condition is executed after the RHS value is computed, so its
          ;; effects cannot affect the values seen by the cmpxchg and can never
          ;; block optimization.
          (block (result i32)
            (drop (array.atomic.get acqrel $array (local.get $array) (i32.const 0)))
            (i32.const 0)
          )
        )
      )
    )
  )

  ;; CHECK:      (func $outer-tee-match (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.tee $x
  ;; CHECK-NEXT:       (local.tee $y
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $x)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $outer-tee-match (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (local $y i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (local.tee $x
        (local.tee $y
          (i32.const 0)
        )
      )
      ;; We recognize that this comes from the LHS tee and can optimize.
      (local.get $x)
    )
  )

  ;; CHECK:      (func $inner-tee-match (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.tee $x
  ;; CHECK-NEXT:       (local.tee $y
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $y)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $inner-tee-match (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (local $y i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (local.tee $x
        (local.tee $y
          (i32.const 0)
        )
      )
      ;; We recognize that this comes from the LHS tee and can optimize.
      (local.get $y)
    )
  )

  ;; CHECK:      (func $br_if-after-tee (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:    (br_if $l
  ;; CHECK-NEXT:     (local.tee $x
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (local.set $x
  ;; CHECK-NEXT:       (i32.const 2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $br_if-after-tee (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (br_if $l
          (local.tee $x
            (i32.const 0)
          )
          ;; The br_if condition is evaluated after the local.tee, so it
          ;; interferes and blocks optimization.
          (block (result i32)
            (local.set $x (i32.const 2))
            (i32.const 0)
          )
        )
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $tee-interference (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (i32.add
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $tee-interference (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (local.tee $x
        ;; The fallthrough values depend on $x, so the optimization is blocked.
        (i32.add (local.get $x) (i32.const 1))
      )
      (i32.add (local.get $x) (i32.const 1))
    )
  )

  ;; CHECK:      (func $tee-set-before (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:   (block (result (ref $struct))
  ;; CHECK-NEXT:    (block
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.tee $x
  ;; CHECK-NEXT:       (block (result i32)
  ;; CHECK-NEXT:        (local.set $x
  ;; CHECK-NEXT:         (i32.const 1)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (drop
  ;; CHECK-NEXT:      (local.get $x)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $tee-set-before (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (local.tee $x
        (block (result i32)
          ;; This set is executed before the tee, so it does not block
          ;; optimization.
          (local.set $x (i32.const 1))
          (i32.const 0)
        )
      )
      (local.get $x)
    )
  )

  ;; CHECK:      (func $tee-set-middle-lhs (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.get acqrel $struct 0
  ;; CHECK-NEXT:    (block (result (ref $struct))
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (local.tee $x
  ;; CHECK-NEXT:        (br_if $l
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:         (block (result i32)
  ;; CHECK-NEXT:          (local.set $x
  ;; CHECK-NEXT:           (i32.const 1)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (local.get $x)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.get $struct)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $tee-set-middle-lhs (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (local.tee $x
          (br_if $l
            (i32.const 0)
            ;; The condition is evaluated after the LHS value, so this would
            ;; normally block optimization. However, it is evaluated before the
            ;; local.tee, so actually it is fine.
            (block (result i32)
              (local.set $x (i32.const 1))
              (i32.const 0)
            )
          )
        )
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $tee-set-middle-rhs (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:   (local.get $struct)
  ;; CHECK-NEXT:   (local.tee $x
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block (result i32)
  ;; CHECK-NEXT:    (local.set $x
  ;; CHECK-NEXT:     (i32.const 2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (local.get $x)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $tee-set-middle-rhs (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
      (local.get $struct)
      (local.tee $x
        (i32.const 1)
      )
      (block (result i32)
        ;; This set changes the value of $x and blocks optimization.
        (local.set $x (i32.const 2))
        (local.get $x)
      )
    )
  )

  ;; CHECK:      (func $tee-set-after (type $3) (param $struct (ref $struct)) (result i32)
  ;; CHECK-NEXT:  (local $x i32)
  ;; CHECK-NEXT:  (block $l (result i32)
  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
  ;; CHECK-NEXT:    (local.get $struct)
  ;; CHECK-NEXT:    (local.tee $x
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br_if $l
  ;; CHECK-NEXT:     (local.get $x)
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (local.set $x
  ;; CHECK-NEXT:       (i32.const 2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (i32.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $tee-set-after (param $struct (ref $struct)) (result i32)
    (local $x i32)
    (block $l (result i32)
      (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
        (local.get $struct)
        (local.tee $x
          (i32.const 1)
        )
        (br_if $l
          (local.get $x)
          ;; The condition is evaluated after the value, so its effects do not
          ;; block optimization.
          ;; TODO: getImmediateFallthroughPtr once again blocks this
          ;; optimization.
          (block (result i32)
            (local.set $x (i32.const 2))
            (i32.const 0)
          )
        )
      )
    )
  )
)