;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
;; RUN: wasm-opt %s -all -S -o - | filecheck %s
;; RUN: wasm-opt %s -all --roundtrip -S -o - | filecheck %s --check-prefix=RTRIP

;; Check that we can roundtrip through the text format as well.

;; RUN: wasm-opt %s -all -S -o - | wasm-opt -all -S -o -

(module

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

  ;; CHECK:      (type $i8_array (array (mut i8)))
  ;; RTRIP:      (type $0 (func))

  ;; RTRIP:      (type $i8_array (array (mut i8)))
  (type $i8_array (array (mut i8)))

  ;; CHECK:      (type $i16_array (array (mut i16)))

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

  ;; CHECK:      (type $i64_array (array (mut i64)))

  ;; CHECK:      (type $f32_array (array (mut f32)))

  ;; CHECK:      (type $f64_array (array (mut f64)))

  ;; CHECK:      (type $v128_array (array (mut v128)))

  ;; CHECK:      (type $imm_i8_array (array i8))

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

  ;; CHECK:      (type $10 (func (param (ref $i16_array) (ref $i32_array) (ref $i64_array) (ref $f32_array) (ref $f64_array) (ref $v128_array))))

  ;; CHECK:      (type $11 (func (param (ref $i8_array))))

  ;; CHECK:      (type $12 (func (param (ref $imm_i8_array) (ref $imm_i32_array))))

  ;; CHECK:      (global $arr (ref $i8_array) (array.new_default $i8_array
  ;; CHECK-NEXT:  (i32.const 4)
  ;; CHECK-NEXT: ))
  ;; RTRIP:      (type $i16_array (array (mut i16)))

  ;; RTRIP:      (type $i32_array (array (mut i32)))

  ;; RTRIP:      (type $i64_array (array (mut i64)))

  ;; RTRIP:      (type $f32_array (array (mut f32)))

  ;; RTRIP:      (type $f64_array (array (mut f64)))

  ;; RTRIP:      (type $v128_array (array (mut v128)))

  ;; RTRIP:      (type $imm_i8_array (array i8))

  ;; RTRIP:      (type $imm_i32_array (array i32))

  ;; RTRIP:      (type $10 (func (param (ref $i16_array) (ref $i32_array) (ref $i64_array) (ref $f32_array) (ref $f64_array) (ref $v128_array))))

  ;; RTRIP:      (type $11 (func (param (ref $i8_array))))

  ;; RTRIP:      (type $12 (func (param (ref $imm_i8_array) (ref $imm_i32_array))))

  ;; RTRIP:      (global $arr (ref $i8_array) (array.new_default $i8_array
  ;; RTRIP-NEXT:  (i32.const 4)
  ;; RTRIP-NEXT: ))
  (global $arr (ref $i8_array)
    (array.new_default $i8_array (i32.const 4))
  )

  ;; CHECK:      (func $stores (type $0)
  ;; CHECK-NEXT:  (i32.store8 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.store16 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.store (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (f32.store (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (f32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i64.store8 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i64.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i64.store16 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i64.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i64.store32 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (i64.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (f64.store (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (f64.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $stores (type $0)
  ;; RTRIP-NEXT:  (i32.store8 (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i32.store16 (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i32.store (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (f32.store (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (f32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i64.store8 (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i64.store16 (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i64.store32 (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (f64.store (type $i8_array)
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:   (f64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $stores
    (i32.store8 (type $i8_array) (global.get $arr) (i32.const 1) (i32.const 2))
    (i32.store16 (type $i8_array) (global.get $arr) (i32.const 1) (i32.const 2))
    (i32.store (type $i8_array) (global.get $arr) (i32.const 1) (i32.const 2))
    (f32.store (type $i8_array) (global.get $arr) (i32.const 1) (f32.const 2.0))

    (i64.store8 (type $i8_array) (global.get $arr) (i32.const 1) (i64.const 2))
    (i64.store16 (type $i8_array) (global.get $arr) (i32.const 1) (i64.const 2))
    (i64.store32 (type $i8_array) (global.get $arr) (i32.const 1) (i64.const 2))
    (f64.store (type $i8_array) (global.get $arr) (i32.const 1) (f64.const 2.0))
  )

  ;; CHECK:      (func $stores_null (type $0)
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (f32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (ref.null none)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (f64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $stores_null (type $0)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f64.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT: )
  (func $stores_null
    (i32.store8 (type $i8_array) (ref.null $i8_array) (i32.const 1) (i32.const 2))
    (i32.store16 (type $i8_array) (ref.null $i8_array) (i32.const 1) (i32.const 2))
    (i32.store (type $i8_array) (ref.null $i8_array) (i32.const 1) (i32.const 2))
    (f32.store (type $i8_array) (ref.null $i8_array) (i32.const 1) (f32.const 2.0))

    (i64.store8 (type $i8_array) (ref.null $i8_array) (i32.const 1) (i64.const 2))
    (i64.store16 (type $i8_array) (ref.null $i8_array) (i32.const 1) (i64.const 2))
    (i64.store32 (type $i8_array) (ref.null $i8_array) (i32.const 1) (i64.const 2))
    (f64.store (type $i8_array) (ref.null $i8_array) (i32.const 1) (f64.const 2.0))
  )

  ;; CHECK:      (func $stores_unreachable (type $0)
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (f32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (block ;; (replaces unreachable ArrayStore we can't emit)
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (f64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $stores_unreachable (type $0)
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT: )
  (func $stores_unreachable
    (i32.store8 (type $i8_array) (unreachable) (i32.const 1) (i32.const 2))
    (i32.store16 (type $i8_array) (unreachable) (i32.const 1) (i32.const 2))
    (i32.store (type $i8_array) (unreachable) (i32.const 1) (i32.const 2))
    (f32.store (type $i8_array) (unreachable) (i32.const 1) (f32.const 2.0))

    (i64.store8 (type $i8_array) (unreachable) (i32.const 1) (i64.const 2))
    (i64.store16 (type $i8_array) (unreachable) (i32.const 1) (i64.const 2))
    (i64.store32 (type $i8_array) (unreachable) (i32.const 1) (i64.const 2))
    (f64.store (type $i8_array) (unreachable) (i32.const 1) (f64.const 2.0))
  )
  ;; CHECK:      (func $loads (type $0)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load8_u (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load8_s (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load16_u (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load16_s (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (f32.load (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.load8_u (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.load16_u (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.load32_u (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.load (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (f64.load (type $i8_array)
  ;; CHECK-NEXT:    (global.get $arr)
  ;; CHECK-NEXT:    (i32.const 1)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $loads (type $0)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load8_u (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load8_s (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load16_u (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load16_s (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f32.load (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.load8_u (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.load16_u (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.load32_u (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.load (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f64.load (type $i8_array)
  ;; RTRIP-NEXT:    (global.get $arr)
  ;; RTRIP-NEXT:    (i32.const 1)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $loads
    (drop (i32.load8_u (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i32.load8_s (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i32.load16_u (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i32.load16_s (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i32.load (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (f32.load (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i64.load8_u (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i64.load16_u (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i64.load32_u (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (i64.load (type $i8_array) (global.get $arr) (i32.const 1)))
    (drop (f64.load (type $i8_array) (global.get $arr) (i32.const 1)))
  )

  ;; CHECK:      (func $loads_null (type $0)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (ref.null none)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $loads_null (type $0)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (ref.null none)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (unreachable)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $loads_null
    (drop (i32.load8_u (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i32.load8_s (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i32.load16_u (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i32.load16_s (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i32.load (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (f32.load (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i64.load8_u (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i64.load16_u (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i64.load32_u (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (i64.load (type $i8_array) (ref.null $i8_array) (i32.const 1)))
    (drop (f64.load (type $i8_array) (ref.null $i8_array) (i32.const 1)))
  )

  ;; CHECK:      (func $loads_unreachable (type $0)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (block ;; (replaces unreachable ArrayLoad we can't emit)
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (unreachable)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (unreachable)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $loads_unreachable (type $0)
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT: )
  (func $loads_unreachable
    (drop (i32.load8_u (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i32.load8_s (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i32.load16_u (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i32.load16_s (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i32.load (type $i8_array) (unreachable) (i32.const 1)))
    (drop (f32.load (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i64.load8_u (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i64.load16_u (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i64.load32_u (type $i8_array) (unreachable) (i32.const 1)))
    (drop (i64.load (type $i8_array) (unreachable) (i32.const 1)))
    (drop (f64.load (type $i8_array) (unreachable) (i32.const 1)))
  )

  ;; CHECK:      (func $stores_index_unreachable (type $0)
  ;; CHECK-NEXT:  (i32.store8 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $stores_index_unreachable (type $0)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT: )
  (func $stores_index_unreachable
    (i32.store8 (type $i8_array) (global.get $arr) (unreachable) (i32.const 2))
  )

  ;; CHECK:      (func $stores_value_unreachable (type $0)
  ;; CHECK-NEXT:  (i32.store8 (type $i8_array)
  ;; CHECK-NEXT:   (global.get $arr)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $stores_value_unreachable (type $0)
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (global.get $arr)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (unreachable)
  ;; RTRIP-NEXT: )
  (func $stores_value_unreachable
    (i32.store8 (type $i8_array) (global.get $arr) (i32.const 1) (unreachable))
  )

  (type $i16_array (array (mut i16)))
  (type $i32_array (array (mut i32)))
  (type $i64_array (array (mut i64)))
  (type $f32_array (array (mut f32)))
  (type $f64_array (array (mut f64)))
  (type $v128_array (array (mut v128)))
  (type $imm_i8_array (array i8))
  (type $imm_i32_array (array i32))

  ;; CHECK:      (func $expanded_types (type $10) (param $a16 (ref $i16_array)) (param $a32 (ref $i32_array)) (param $a64 (ref $i64_array)) (param $af32 (ref $f32_array)) (param $af64 (ref $f64_array)) (param $av (ref $v128_array))
  ;; CHECK-NEXT:  (i32.store16 (type $i16_array)
  ;; CHECK-NEXT:   (local.get $a16)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load16_u (type $i16_array)
  ;; CHECK-NEXT:    (local.get $a16)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.store (type $i32_array)
  ;; CHECK-NEXT:   (local.get $a32)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load (type $i32_array)
  ;; CHECK-NEXT:    (local.get $a32)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i64.store (type $i64_array)
  ;; CHECK-NEXT:   (local.get $a64)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i64.const 3)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.load (type $i64_array)
  ;; CHECK-NEXT:    (local.get $a64)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (f32.store (type $f32_array)
  ;; CHECK-NEXT:   (local.get $af32)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (f32.const 4)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (f32.load (type $f32_array)
  ;; CHECK-NEXT:    (local.get $af32)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (f64.store (type $f64_array)
  ;; CHECK-NEXT:   (local.get $af64)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (f64.const 5)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (f64.load (type $f64_array)
  ;; CHECK-NEXT:    (local.get $af64)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (v128.store (type $v128_array)
  ;; CHECK-NEXT:   (local.get $av)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (v128.const i32x4 0x00000001 0x00000002 0x00000003 0x00000004)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (v128.load (type $v128_array)
  ;; CHECK-NEXT:    (local.get $av)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $expanded_types (type $10) (param $a16 (ref $i16_array)) (param $a32 (ref $i32_array)) (param $a64 (ref $i64_array)) (param $af32 (ref $f32_array)) (param $af64 (ref $f64_array)) (param $av (ref $v128_array))
  ;; RTRIP-NEXT:  (i32.store16 (type $i16_array)
  ;; RTRIP-NEXT:   (local.get $a16)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i32.const 1)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load16_u (type $i16_array)
  ;; RTRIP-NEXT:    (local.get $a16)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i32.store (type $i32_array)
  ;; RTRIP-NEXT:   (local.get $a32)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i32.const 2)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load (type $i32_array)
  ;; RTRIP-NEXT:    (local.get $a32)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i64.store (type $i64_array)
  ;; RTRIP-NEXT:   (local.get $a64)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i64.const 3)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i64.load (type $i64_array)
  ;; RTRIP-NEXT:    (local.get $a64)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (f32.store (type $f32_array)
  ;; RTRIP-NEXT:   (local.get $af32)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (f32.const 4)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f32.load (type $f32_array)
  ;; RTRIP-NEXT:    (local.get $af32)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (f64.store (type $f64_array)
  ;; RTRIP-NEXT:   (local.get $af64)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (f64.const 5)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (f64.load (type $f64_array)
  ;; RTRIP-NEXT:    (local.get $af64)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (v128.store (type $v128_array)
  ;; RTRIP-NEXT:   (local.get $av)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (v128.const i32x4 0x00000001 0x00000002 0x00000003 0x00000004)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (v128.load (type $v128_array)
  ;; RTRIP-NEXT:    (local.get $av)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $expanded_types (param $a16 (ref $i16_array)) (param $a32 (ref $i32_array)) (param $a64 (ref $i64_array)) (param $af32 (ref $f32_array)) (param $af64 (ref $f64_array)) (param $av (ref $v128_array))
    (i32.store16 (type $i16_array) (local.get $a16) (i32.const 0) (i32.const 1))
    (drop (i32.load16_u (type $i16_array) (local.get $a16) (i32.const 0)))
    (i32.store (type $i32_array) (local.get $a32) (i32.const 0) (i32.const 2))
    (drop (i32.load (type $i32_array) (local.get $a32) (i32.const 0)))
    (i64.store (type $i64_array) (local.get $a64) (i32.const 0) (i64.const 3))
    (drop (i64.load (type $i64_array) (local.get $a64) (i32.const 0)))
    (f32.store (type $f32_array) (local.get $af32) (i32.const 0) (f32.const 4.0))
    (drop (f32.load (type $f32_array) (local.get $af32) (i32.const 0)))
    (f64.store (type $f64_array) (local.get $af64) (i32.const 0) (f64.const 5.0))
    (drop (f64.load (type $f64_array) (local.get $af64) (i32.const 0)))
    (v128.store (type $v128_array) (local.get $av) (i32.const 0) (v128.const i32x4 1 2 3 4))
    (drop (v128.load (type $v128_array) (local.get $av) (i32.const 0)))
  )

  ;; CHECK:      (func $immediates (type $11) (param $arr (ref $i8_array))
  ;; CHECK-NEXT:  (i32.store8 (type $i8_array) offset=4
  ;; CHECK-NEXT:   (local.get $arr)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 42)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.store (type $i8_array) offset=8
  ;; CHECK-NEXT:   (local.get $arr)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 1337)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.store (type $i8_array) offset=12 align=2
  ;; CHECK-NEXT:   (local.get $arr)
  ;; CHECK-NEXT:   (i32.const 0)
  ;; CHECK-NEXT:   (i32.const 1337)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load8_u (type $i8_array) offset=4
  ;; CHECK-NEXT:    (local.get $arr)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load (type $i8_array) offset=8
  ;; CHECK-NEXT:    (local.get $arr)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load (type $i8_array) offset=12 align=2
  ;; CHECK-NEXT:    (local.get $arr)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $immediates (type $11) (param $arr (ref $i8_array))
  ;; RTRIP-NEXT:  (i32.store8 (type $i8_array) offset=4
  ;; RTRIP-NEXT:   (local.get $arr)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i32.const 42)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i32.store (type $i8_array) offset=8
  ;; RTRIP-NEXT:   (local.get $arr)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i32.const 1337)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (i32.store (type $i8_array) offset=12 align=2
  ;; RTRIP-NEXT:   (local.get $arr)
  ;; RTRIP-NEXT:   (i32.const 0)
  ;; RTRIP-NEXT:   (i32.const 1337)
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load8_u (type $i8_array) offset=4
  ;; RTRIP-NEXT:    (local.get $arr)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load (type $i8_array) offset=8
  ;; RTRIP-NEXT:    (local.get $arr)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load (type $i8_array) offset=12 align=2
  ;; RTRIP-NEXT:    (local.get $arr)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $immediates (param $arr (ref $i8_array))
    (i32.store8 (type $i8_array) offset=4 align=1 (local.get $arr) (i32.const 0) (i32.const 42))
    (i32.store (type $i8_array) offset=8 align=4 (local.get $arr) (i32.const 0) (i32.const 1337))
    (i32.store (type $i8_array) offset=12 align=2 (local.get $arr) (i32.const 0) (i32.const 1337))
    (drop (i32.load8_u (type $i8_array) offset=4 align=1 (local.get $arr) (i32.const 0)))
    (drop (i32.load (type $i8_array) offset=8 align=4 (local.get $arr) (i32.const 0)))
    (drop (i32.load (type $i8_array) offset=12 align=2 (local.get $arr) (i32.const 0)))
  )

  ;; CHECK:      (func $immutable_loads (type $12) (param $imm8 (ref $imm_i8_array)) (param $imm32 (ref $imm_i32_array))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load8_u (type $imm_i8_array)
  ;; CHECK-NEXT:    (local.get $imm8)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.load (type $imm_i32_array)
  ;; CHECK-NEXT:    (local.get $imm32)
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $immutable_loads (type $12) (param $imm8 (ref $imm_i8_array)) (param $imm32 (ref $imm_i32_array))
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load8_u (type $imm_i8_array)
  ;; RTRIP-NEXT:    (local.get $imm8)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT:  (drop
  ;; RTRIP-NEXT:   (i32.load (type $imm_i32_array)
  ;; RTRIP-NEXT:    (local.get $imm32)
  ;; RTRIP-NEXT:    (i32.const 0)
  ;; RTRIP-NEXT:   )
  ;; RTRIP-NEXT:  )
  ;; RTRIP-NEXT: )
  (func $immutable_loads (param $imm8 (ref $imm_i8_array)) (param $imm32 (ref $imm_i32_array))
    (drop (i32.load8_u (type $imm_i8_array) (local.get $imm8) (i32.const 0)))
    (drop (i32.load (type $imm_i32_array) (local.get $imm32) (i32.const 0)))
  )
)