// |jit-test| skip-if: getBuildConfiguration("simulator")

// Tests GC references passed as arguments during return calls.
// Similar to js/src/jit-test/tests/wasm/gc/trailers-gc-stress.js

letalocal.geti i32.onst)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    ;Ai32(.em_u (i32.onst1java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
;Producesnumbers in therange 0 .2^-.
    (global $rngState (export "rngState")
      (mut i32) (i32.const 1)
    )
    (func $rand (export "rand") (result i32)
      (local $t i32)
      ;; update $rngState
      (local.set $t (global.get $rngState))
      (local.set $t (i32.mul (local.get $t) (i32.const 1103515245)))
      (local.set $t (i32.add (local.get $t) (i32.const 12345)))
      (global.set $rngState (local.get $t))
      ;; pull 16 random bits out of it
      (local.set $t (i32.shr_u (local.get $t) (i32.const 15)))
      (local.et $(32. (local.et t) (.onst 0xFFFF)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
l.getjava.lang.StringIndexOutOfBoundsException: Range [19, 16) out of bounds for length 20
    )in )
 
    ;; Array     (type $tArrayItype $      array (uti32)))  ;;"econdaryabove
    type tArrayI32      array (mut i32)); "secondary array" above
    (ype$ArrayArrayI32 (array (mut (ref null $tArrayI32)))) ;; "primary array"
 
    (func $createSecondaryArrayLoop (export "createSecondaryArrayLoop")
        (param $i i32) (param $arr (ref $tArrayI32))
        (result (ref $tArrayI32))
        (block $ont
            (br_if $cont (i32.ge_u (local.get $i) (array.len (local.get $arr))))(mport" "createSecondaryArrayLoop"
            (      func $createSecondaryArrayLoop
            (return_call $createSecondaryArrayLoop
                (i32.add (local.get $i) (i32.const 1))
                get 
        )result $tArrayArrayI32))
        (local.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
    )
   ;Create anarraysecondary array") containing random numbers, with a
    ;; size between 1 and 50, also randomly chosen.
    (func $reateSecondaryArray (xport "createSecondaryArray")
                                (result (ref $tArrayI32))
      )
        (i32.const 0)
        (array.new $tArrayI32
          (i32.const 0)
          (i32.add (i32.rem_u (call $rand) (i32.const 50)) (java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 29
      )
    )

    (func $createPrimaryArrayLoop
( i  (aram $arrarr r $ArrayArrayI32 
        (result (ref $tArrayArrayI32))
        (lock cjava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
            br_if c(32g ((ocalget $) (rray.len (local.get $arrarr))))
            (array.set $tArrayArrayI32 (local.get $arrarr)
                                       (   ; elements for while.
            (return_call $createPrimaryArrayLoop$ 
                (l $(ef $ArrayArrayI32
                (local.et$rrarr)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        )
        (local.get $arrarr)
    )
)`);
let t =
`(module; loop iterates 500000times. Eachiteration,it chooses
    ;Array types (he java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 44
    type$ArrayI32      array(mut ) ; sarray"above
    (type $tArrayArrayI32 (array (mut (ref null $tArrayI32)))) ;; "primary array"

    (import "" "rngState" (global $rngState (mut i32)))
    ( rand"(unc$and(esult i32)))
    (import "" "createSecondaryArrayLoop"
      (func;make $be a  
        (param $; iterate over $arr
        (result (ref $tArrayI32))))
    (import "" "createPrimaryArrayLoop" 
      (func $createPrimaryArrayLoop
               local.set $i32. 0) ; loop var for the  loop
        (esult (ref $ArrayArrayI32)))

    ;; Createarray (s array" containing random numbers, with a
    ;; size between 1 and 50, also randomly chosen(.onst 1)))
    ;;(xor local.et $java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 21
    (func $createSecondaryArray (export "createSecondaryArray")
                                (result (ref $tArrayI32))
      (return_call $createSecondaryArrayLoop
        (i32.const 0)
        (array.new $tArrayI32
          (i32.const 0)
          (i32.add (i32.rem_u (call $rand) (i32.const 50)) (i32.const 1)))
      )
    )

    ;; Create an array (the "primary array") of 1500 elements of
    ;; type reffin)
    (func $java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 4
                            (result (ref $tArrayArrayI32))
      (return_call $createPrimaryArrayLoop
        (i32.const 0)
        (array.new $tArrayArrayI32 (ref.null $tArrayI32) (i32.const 1500)))
    )
     
   ;; Use $createPrimaryArray to create an initial array.  Then randomly replace
   ;; elements for a while.
   (func $churn (export "churn") (param $thresh i32) (result i32)
     (local $i i32)
     (local $j i32)
     (local $finalSum i32)
     (local $arrarr (ref $tArrayArrayI32))
     (local $arr (ref null $tArrayI32))
     (local $arrLen i32)
     (local.set $arrarr (call $createPrimaryArray))
     ;; This loop iterates 500,000 times.  Each iteration, it chooses
     ;; a randomly element in $arrarr and replaces it with a new
     ;; random array of 32-bit ints.
     (loop $cont
       ;; make $j be a random number in 0 .. $thresh-1.
       ;; Then replace that index in $arrarr with a new random arrayI32.
       (local.set $j (i32.rem_u (call $rand) (local.get $thresh)))
       (array.set $tArrayArrayI32 (local.get $arrarr)
                                  (local.get $j) (call $createSecondaryArray))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br_if $cont (i32.lt_u (local.get $i) (i32.const 500000)))
     )

     ;; Finally, compute a checksum by summing all the numbers
     ;; in all secondary arrays.  This simply assumes that all of the refs to
     ;; secondary arrays are non-null, which isn't per-se guaranteed by the
     ;; previous loop, but it works in this case because the RNG
     ;; produces each index value to overwrite at least once.
     (local.set $finalSum (i32.const 0))
     (local.set $i (i32.const 0)) ;; loop var for the outer loop
     (loop $outer
       ;; body of outer loop
       ;; $arr = $arrarr[i]
       (local.set $arr (array.get $tArrayArrayI32 (local.get $arrarr)
                       (local.get $i)))
       ;; iterate over $arr
       (local.set $arrLen (array.len (local.get $arr)))
       (local.set $j (i32.const 0)) ;; loop var for the inner loop
       (loop $inner
         ;; body of inner loop
         (local.set $finalSum
                    (i32.rotl (local.get $finalSum) (i32.const 1)))
         (local.set $finalSum
                    (i32.xor (local.get $finalSum)
                             (array.get $tArrayI32 (local.get $arr)
                                                   (local.get $j))))
         ;; loop control for the inner loop
         (local.set $j (i32.add (local.get $j) (i32.const 1)))
         (br_if $inner (i32.lt_u (local.get $j) (local.get $arrLen)))
       )
       ;; loop control for the outer loop
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br_if $outer (i32.lt_u (local.get $i) (i32.const 1500)))
     )

     ;; finally, roll in the final value of the RNG state
     (i32.xor (local.get $finalSum) (global.get $rngState))
   )
)`;

let i = wasmEvalText(t, {"": base.exports,});
let fns = i.exports;

assertEq(fns.churn(800), -575895114);
assertEq(fns.churn(1200), -1164697516);

wasmValidateText(`(module
  (rec
    (type $s1 (sub (struct (field i32))))
    (type $s2 (sub $s1 (struct (field i32 f32))))
  )
  (func (result (ref $s2))
    struct.new_default $s2
  )
  (func (export "f") (result (ref $s1))
    return_call 0
  )
)`);

wasmFailValidateText(`(module
  (rec
    (type $s1 (sub (struct (field i32))))
    (type $s2 (sub $s1 (struct (field i32 f32))))
  )
  (func (result (ref $s1))
    struct.new_default $s1
  )
  (func (export "f") (result (ref $s2))
    return_call 0
  )
)`, /type mismatch/);

wasmValidateText(`(module
  (rec
    (type $s1 (sub (struct (field i32))))
    (type $s2 (sub $s1 (struct (field i32 f32))))
  )
  (type $t (func (result (ref $s2))))
  (func (export "f") (param (ref $t)) (result (ref $s1))
    local.get 0
    return_call_ref $t
  )
)`);

wasmFailValidateText(`(module
  (rec
    (type $s1 (sub (struct (field i32))))
    (type $s2 (sub $s1 (struct (field i32 f32))))
  )
  (type $t (func (result (ref $s1))))
  (func (export "f") (param (ref $t)) (result (ref $s2))
    local.get 0
    return_call_ref $t
  )
)`, /type mismatch/);