test/lit/passes/optimize-instructions-struct-rmw.wast - external/github.com/WebAssembly/binaryen.git - Git at Google

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

 ;; RUN: wasm-opt %s -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 $array (array (mut i32)))
   (type $array (array (mut i32)))

   ;; CHECK:      (func $rmw-skip-non-null-cast (type $7) (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 $8) (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 $9) (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 $10) (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 $11) (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 $11) (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 $11) (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 $11) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $12) (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 $7) (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 $7) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $13) (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 $14) (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 $14) (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 $15) (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 $15) (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 $15) (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 $15) (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 $15) (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 $12) (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 $16) (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 $16) (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 $16) (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 $16) (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 $16) (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 $16) (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 $16) (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 $16) (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 $16) (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 $17) (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 $17) (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 $17) (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 $17) (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 $17) (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 $17) (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 $17) (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 $18) (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 $18) (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 $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 $16) (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 $16) (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)
     )
   )
 )