diff options
Diffstat (limited to 'test')
35 files changed, 582 insertions, 467 deletions
diff --git a/test/ctor-eval/gc-2.wast b/test/ctor-eval/gc-2.wast index fed45abac..6a21be99e 100644 --- a/test/ctor-eval/gc-2.wast +++ b/test/ctor-eval/gc-2.wast @@ -38,7 +38,7 @@ (func "keepalive" (result i32) (select (struct.get $struct 0 - (ref.cast_static $struct + (ref.cast null $struct (global.get $global1) ) ) diff --git a/test/ctor-eval/gc-2.wast.out b/test/ctor-eval/gc-2.wast.out index c6d8931b8..a333cdf30 100644 --- a/test/ctor-eval/gc-2.wast.out +++ b/test/ctor-eval/gc-2.wast.out @@ -14,7 +14,7 @@ (func $1 (type $none_=>_i32) (result i32) (select (struct.get $struct 0 - (ref.cast_static $struct + (ref.cast null $struct (global.get $global1) ) ) diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt index c4dd09168..41f96c184 100644 --- a/test/example/c-api-kitchen-sink.txt +++ b/test/example/c-api-kitchen-sink.txt @@ -2165,12 +2165,12 @@ BinaryenFeatureAll: 126975 ) ) (drop - (ref.test_static $[mut:i8] + (ref.test $[mut:i8] (global.get $i8Array-global) ) ) (drop - (ref.cast_static $[mut:i8] + (ref.cast null $[mut:i8] (global.get $i8Array-global) ) ) diff --git a/test/heap-types.wast b/test/heap-types.wast index b3c1b0650..9366dca01 100644 --- a/test/heap-types.wast +++ b/test/heap-types.wast @@ -323,15 +323,15 @@ (local $temp.A (ref null $struct.A)) (local $temp.B (ref null $struct.B)) (drop - (ref.test_static $struct.B (ref.null $struct.A)) + (ref.test $struct.B (ref.null $struct.A)) ) (drop - (ref.cast_static $struct.B (ref.null $struct.A)) + (ref.cast null $struct.B (ref.null $struct.A)) ) (drop (block $out-B (result (ref $struct.B)) (local.set $temp.A - (br_on_cast_static $out-B $struct.B (ref.null $struct.A)) + (br_on_cast $out-B $struct.B (ref.null $struct.A)) ) (unreachable) ) @@ -339,7 +339,7 @@ (drop (block $out-A (result (ref null $struct.A)) (local.set $temp.B - (br_on_cast_static_fail $out-A $struct.B (ref.null $struct.A)) + (br_on_cast_fail $out-A $struct.B (ref.null $struct.A)) ) (unreachable) ) diff --git a/test/heap-types.wast.from-wast b/test/heap-types.wast.from-wast index 3d7be5461..9f1a28d13 100644 --- a/test/heap-types.wast.from-wast +++ b/test/heap-types.wast.from-wast @@ -396,19 +396,19 @@ (local $temp.A (ref null $struct.A)) (local $temp.B (ref null $struct.B)) (drop - (ref.test_static $struct.B + (ref.test $struct.B (ref.null none) ) ) (drop - (ref.cast_static $struct.B + (ref.cast null $struct.B (ref.null none) ) ) (drop (block $out-B (result (ref $struct.B)) (local.set $temp.A - (br_on_cast_static $out-B $struct.B + (br_on_cast $out-B $struct.B (ref.null none) ) ) @@ -418,7 +418,7 @@ (drop (block $out-A (result (ref null $struct.A)) (local.set $temp.B - (br_on_cast_static_fail $out-A $struct.B + (br_on_cast_fail $out-A $struct.B (ref.null none) ) ) diff --git a/test/heap-types.wast.fromBinary b/test/heap-types.wast.fromBinary index 7bc780796..b217ebc2e 100644 --- a/test/heap-types.wast.fromBinary +++ b/test/heap-types.wast.fromBinary @@ -349,19 +349,19 @@ (local $temp.A (ref null $struct.A)) (local $temp.B (ref null $struct.B)) (drop - (ref.test_static $struct.B + (ref.test $struct.B (ref.null none) ) ) (drop - (ref.cast_static $struct.B + (ref.cast null $struct.B (ref.null none) ) ) (drop (block $label$1 (result (ref $struct.B)) (local.set $temp.A - (br_on_cast_static $label$1 $struct.B + (br_on_cast $label$1 $struct.B (ref.null none) ) ) @@ -371,7 +371,7 @@ (drop (block $label$2 (result (ref null $struct.A)) (local.set $temp.B - (br_on_cast_static_fail $label$2 $struct.B + (br_on_cast_fail $label$2 $struct.B (ref.null none) ) ) diff --git a/test/heap-types.wast.fromBinary.noDebugInfo b/test/heap-types.wast.fromBinary.noDebugInfo index 9ffc65080..89f0c676e 100644 --- a/test/heap-types.wast.fromBinary.noDebugInfo +++ b/test/heap-types.wast.fromBinary.noDebugInfo @@ -349,19 +349,19 @@ (local $0 (ref null ${i32_f32_f64})) (local $1 (ref null ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|})) (drop - (ref.test_static ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} + (ref.test ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} (ref.null none) ) ) (drop - (ref.cast_static ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} + (ref.cast null ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} (ref.null none) ) ) (drop (block $label$1 (result (ref ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|})) (local.set $0 - (br_on_cast_static $label$1 ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} + (br_on_cast $label$1 ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} (ref.null none) ) ) @@ -371,7 +371,7 @@ (drop (block $label$2 (result (ref null ${i32_f32_f64})) (local.set $1 - (br_on_cast_static_fail $label$2 ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} + (br_on_cast_fail $label$2 ${i8_mut:i16_ref|{i32_f32_f64}|_mut:ref|{i32_f32_f64}|} (ref.null none) ) ) diff --git a/test/lit/binary/legacy-static-casts.test b/test/lit/binary/legacy-static-casts.test new file mode 100644 index 000000000..53218ba65 --- /dev/null +++ b/test/lit/binary/legacy-static-casts.test @@ -0,0 +1,40 @@ +;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. + +;; Test that the opcodes for the deprecated *_static cast instructions still parse. + +;; RUN: wasm-opt %s.wasm -all -S -o - | filecheck %s +;; CHECK: (type ${} (struct )) + +;; CHECK: (type $none_=>_none (func)) + +;; CHECK: (func $0 (type $none_=>_none) +;; CHECK-NEXT: (drop +;; CHECK-NEXT: (ref.test ${} +;; CHECK-NEXT: (ref.null none) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: (drop +;; CHECK-NEXT: (ref.cast null ${} +;; CHECK-NEXT: (ref.null none) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: (drop +;; CHECK-NEXT: (ref.cast_nop ${} +;; CHECK-NEXT: (ref.null none) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: (drop +;; CHECK-NEXT: (block $label$1 (result (ref null ${})) +;; CHECK-NEXT: (br_on_cast $label$1 ${} +;; CHECK-NEXT: (ref.null none) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: (drop +;; CHECK-NEXT: (block $label$2 (result (ref null ${})) +;; CHECK-NEXT: (br_on_cast_fail $label$2 ${} +;; CHECK-NEXT: (ref.null none) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) +;; CHECK-NEXT: ) diff --git a/test/lit/binary/legacy-static-casts.test.wasm b/test/lit/binary/legacy-static-casts.test.wasm Binary files differnew file mode 100644 index 000000000..2dcfc9f01 --- /dev/null +++ b/test/lit/binary/legacy-static-casts.test.wasm diff --git a/test/lit/heap-types.wast b/test/lit/heap-types.wast index dc71eb41e..83926e573 100644 --- a/test/lit/heap-types.wast +++ b/test/lit/heap-types.wast @@ -15,21 +15,21 @@ (type $struct.B (struct i32)) ;; CHECK: (func $test (type $none_=>_none) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $struct.A + ;; CHECK-NEXT: (ref.test $struct.A ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $test (type $none_=>_none) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $struct.B + ;; NOMNL-NEXT: (ref.test $struct.B ;; NOMNL-NEXT: (ref.null none) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) (func $test (drop - (ref.test_static $struct.B (ref.null $struct.A)) + (ref.test $struct.B (ref.null $struct.A)) ) ) ) @@ -41,21 +41,21 @@ (type $struct.B (struct i32)) ;; CHECK: (func $test (type $none_=>_none) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct.A + ;; CHECK-NEXT: (ref.cast null $struct.A ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $test (type $none_=>_none) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct.B + ;; NOMNL-NEXT: (ref.cast null $struct.B ;; NOMNL-NEXT: (ref.null none) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) (func $test (drop - (ref.cast_static $struct.B (ref.null $struct.A)) + (ref.cast null $struct.B (ref.null $struct.A)) ) ) ) diff --git a/test/lit/legacy-static-casts.wast b/test/lit/legacy-static-casts.wast new file mode 100644 index 000000000..0cbd30a2d --- /dev/null +++ b/test/lit/legacy-static-casts.wast @@ -0,0 +1,75 @@ +;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. + +;; Check that the deprecated *_static instruction names are still parsed correctly. + +;; RUN: wasm-opt %s -all -S -o - | filecheck %s + +(module + ;; CHECK: (type $struct (struct )) + (type $struct (struct)) + + ;; CHECK: (type $none_=>_none (func)) + + ;; CHECK: (func $test (type $none_=>_none) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (ref.test $struct + ;; CHECK-NEXT: (ref.null none) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (ref.cast null $struct + ;; CHECK-NEXT: (ref.null none) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (ref.cast_nop $struct + ;; CHECK-NEXT: (ref.null none) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (block $l1 (result (ref null $struct)) + ;; CHECK-NEXT: (br_on_cast $l1 $struct + ;; CHECK-NEXT: (ref.null none) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (block $l2 (result (ref null $struct)) + ;; CHECK-NEXT: (br_on_cast_fail $l2 $struct + ;; CHECK-NEXT: (ref.null none) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $test + (drop + (ref.test_static $struct + (ref.null none) + ) + ) + (drop + (ref.cast_static $struct + (ref.null none) + ) + ) + (drop + (ref.cast_nop_static $struct + (ref.null none) + ) + ) + (drop + (block $l1 (result (ref null $struct)) + (br_on_cast_static $l1 $struct + (ref.null none) + ) + ) + ) + (drop + (block $l2 (result (ref null $struct)) + (br_on_cast_static_fail $l2 $struct + (ref.null none) + ) + ) + ) + ) +) diff --git a/test/lit/passes/gufa-refs.wast b/test/lit/passes/gufa-refs.wast index ab8e23502..f209cef88 100644 --- a/test/lit/passes/gufa-refs.wast +++ b/test/lit/passes/gufa-refs.wast @@ -1036,7 +1036,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref $none_=>_none)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $parent $parent + ;; CHECK-NEXT: (br_on_cast $parent $parent ;; CHECK-NEXT: (ref.func $func) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1093,7 +1093,7 @@ ;; contents in ref.cast, but not br_on_cast, so test both. (drop (struct.get $parent 0 - (ref.cast_static $parent + (ref.cast null $parent (ref.func $func) ) ) @@ -1102,7 +1102,7 @@ (struct.get $parent 0 (block $parent (result (ref $parent)) (drop - (br_on_cast_static $parent $parent + (br_on_cast $parent $parent (ref.func $func) ) ) @@ -1152,7 +1152,7 @@ ;; CHECK-NEXT: (br $block1 ;; CHECK-NEXT: (block (result nullref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $child + ;; CHECK-NEXT: (ref.cast null $child ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1198,13 +1198,13 @@ ) ) ;; Send a less specific type, via a cast. But all nulls are identical and - ;; ref.cast passes nulls through, so this is ok, but we must be careful to + ;; ref.cast null passes nulls through, so this is ok, but we must be careful to ;; emit a ref.null $child on the outside (to not change the outer type to a ;; less refined one). (drop (block $block (result (ref null $child)) (br $block - (ref.cast_static $child + (ref.cast null $child (ref.null $parent) ) ) @@ -1710,7 +1710,7 @@ (drop (ref.as_non_null (array.get $something-child - (ref.cast_static $something-child + (ref.cast null $something-child (array.new_default $something (i32.const 10) ) @@ -2532,7 +2532,7 @@ ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (struct.new $substruct ;; CHECK-NEXT: (i32.const 1) ;; CHECK-NEXT: (i32.const 2) @@ -2540,7 +2540,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (struct.new $subsubstruct ;; CHECK-NEXT: (i32.const 3) ;; CHECK-NEXT: (i32.const 4) @@ -2550,10 +2550,10 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) (func $test - ;; The cast here will fail, and the ref.cast allows nothing through, so we + ;; The cast here will fail, and the ref.cast null allows nothing through, so we ;; can emit an unreachable here. (drop - (ref.cast_static $substruct + (ref.cast null $substruct (struct.new $struct (i32.const 0) ) @@ -2562,7 +2562,7 @@ ;; This cast of a type to itself can succeed (in fact, it will), so we make ;; no changes here. (drop - (ref.cast_static $substruct + (ref.cast null $substruct (struct.new $substruct (i32.const 1) (i32.const 2) @@ -2571,7 +2571,7 @@ ) ;; This cast of a subtype will also succeed. As above, we make no changes. (drop - (ref.cast_static $substruct + (ref.cast null $substruct (struct.new $subsubstruct (i32.const 3) (i32.const 4) @@ -2585,7 +2585,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result nullref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (block (result nullref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (call $import) @@ -2600,7 +2600,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result nullref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (select (result i31ref) ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: (i31.new @@ -2614,7 +2614,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (select (result (ref null $struct)) ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: (struct.new $struct @@ -2629,7 +2629,7 @@ ;; Only a null can flow through the cast, which we can infer for the value ;; of the cast. (drop - (ref.cast_static $struct + (ref.cast null $struct (select (ref.null $struct) (ref.null $struct) @@ -2641,7 +2641,7 @@ ;; through (an i31 would fail the cast). Given that, we can infer a null for ;; the value of the cast. (drop - (ref.cast_static $struct + (ref.cast null $struct (select (ref.null $struct) (i31.new (i32.const 0)) @@ -2651,7 +2651,7 @@ ) ;; A null or a $struct may arrive, and so we cannot do anything here. (drop - (ref.cast_static $struct + (ref.cast null $struct (select (ref.null $struct) (struct.new $struct @@ -2665,7 +2665,7 @@ ;; CHECK: (func $test-cones (type $i32_=>_none) (param $x i32) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (select (result (ref null $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 0) @@ -2676,7 +2676,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (select (result (ref $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 1) @@ -2690,7 +2690,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (select (result (ref $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 4) @@ -2708,9 +2708,9 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) (func $test-cones (export "test-cones") (param $x i32) - ;; The input to the ref.cast is potentially null, so we cannot infer here. + ;; The input to the ref.cast null is potentially null, so we cannot infer here. (drop - (ref.cast_static $struct + (ref.cast null $struct (select (struct.new $struct (i32.const 0) @@ -2720,10 +2720,10 @@ ) ) ) - ;; The input to the ref.cast is either $struct or $substruct, both of which + ;; The input to the ref.cast null is either $struct or $substruct, both of which ;; work, so we cannot optimize anything here away. (drop - (ref.cast_static $struct + (ref.cast null $struct (select (struct.new $struct (i32.const 1) @@ -2739,7 +2739,7 @@ ;; As above, but now we test with $substruct, so one possibility fails and ;; one succeeds. We cannot infer here either. (drop - (ref.cast_static $substruct + (ref.cast null $substruct (select (struct.new $struct (i32.const 4) @@ -2756,7 +2756,7 @@ ;; can infer an unreachable. The combination of these two is a cone from ;; $struct of depth 1, which does not overlap with $subsubstruct. (drop - (ref.cast_static $subsubstruct + (ref.cast null $subsubstruct (select (struct.new $struct (i32.const 7) @@ -2786,7 +2786,7 @@ ;; This cast will fail: we know the exact type of the reference, and it is ;; not a subtype. (drop - (ref.test_static $substruct + (ref.test $substruct (struct.new $struct (i32.const 0) ) @@ -2794,7 +2794,7 @@ ) ;; Casting a thing to itself must succeed. (drop - (ref.test_static $substruct + (ref.test $substruct (struct.new $substruct (i32.const 1) (i32.const 2) @@ -2803,7 +2803,7 @@ ) ;; Casting a thing to a supertype must succeed. (drop - (ref.test_static $substruct + (ref.test $substruct (struct.new $subsubstruct (i32.const 3) (i32.const 4) @@ -2815,7 +2815,7 @@ ;; CHECK: (func $ref.test-inexact (type $i32_=>_none) (param $x i32) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $struct + ;; CHECK-NEXT: (ref.test $struct ;; CHECK-NEXT: (select (result (ref null $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 0) @@ -2829,7 +2829,7 @@ ;; CHECK-NEXT: (i32.const 1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $substruct + ;; CHECK-NEXT: (ref.test $substruct ;; CHECK-NEXT: (select (result (ref $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 4) @@ -2849,7 +2849,7 @@ (func $ref.test-inexact (export "ref.test-inexact") (param $x i32) ;; The input to the ref.test is potentially null, so we cannot infer here. (drop - (ref.test_static $struct + (ref.test $struct (select (struct.new $struct (i32.const 0) @@ -2864,7 +2864,7 @@ ;; combination of those two types is a cone on $struct of depth 1, and that ;; cone is 100% a subtype of $struct, so the test will succeed. (drop - (ref.test_static $struct + (ref.test $struct (select (struct.new $struct (i32.const 1) @@ -2880,7 +2880,7 @@ ;; As above, but now we test with $substruct, so one possibility fails and ;; one succeeds. We cannot infer here. (drop - (ref.test_static $substruct + (ref.test $substruct (select (struct.new $struct (i32.const 4) @@ -2897,7 +2897,7 @@ ;; can infer a 0. The combination of these two is a cone from $struct of ;; depth 1, which does not overlap with $subsubstruct. (drop - (ref.test_static $subsubstruct + (ref.test $subsubstruct (select (struct.new $struct (i32.const 7) @@ -3637,7 +3637,7 @@ ;; CHECK: (func $foo (type $none_=>_ref|$B|) (result (ref $B)) ;; CHECK-NEXT: (local $A (ref null $A)) - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (ref.as_non_null ;; CHECK-NEXT: (local.tee $A ;; CHECK-NEXT: (struct.new $B @@ -3653,7 +3653,7 @@ ;; Read the following from the most nested comment first. - (ref.cast_static $B ;; if we mistakenly think this contains content of + (ref.cast null $B ;; if we mistakenly think this contains content of ;; type $A, it would trap, but it should not, and we ;; have nothing to optimize here (ref.as_non_null ;; also $B, based on the child's *contents* (not type!) @@ -5310,27 +5310,27 @@ ;; An imported global has a known type, at least, which in this case is ;; enough for us to infer a result of 1. (drop - (ref.test_static $A + (ref.test $A (global.get $A) ) ) ;; Likewise, a function result. (drop - (ref.test_static $A + (ref.test $A (call $A) ) ) ;; Likewise, a parameter to this function, which is exported, but we do ;; still know the type it will be called with, and can optimize to 1. (drop - (ref.test_static $A + (ref.test $A (local.get $A) ) ) ;; Likewise, an exported mutable global can be modified by the outside, but ;; the type remains known, and we can optimize to 1. (drop - (ref.test_static $A + (ref.test $A (global.get $A) ) ) @@ -5338,22 +5338,22 @@ ;; CHECK: (func $no (type $ref|$A|_=>_none) (param $A (ref $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (global.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (call $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (global.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -5362,22 +5362,22 @@ ;; Identical to the above function, but now all tests are vs type $B. We ;; cannot optimize any of these, as all we know is the type is $A. (drop - (ref.test_static $B + (ref.test $B (global.get $A) ) ) (drop - (ref.test_static $B + (ref.test $B (call $A) ) ) (drop - (ref.test_static $B + (ref.test $B (local.get $A) ) ) (drop - (ref.test_static $B + (ref.test $B (global.get $A) ) ) @@ -5389,7 +5389,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block $B (result (ref $B)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $B $B + ;; CHECK-NEXT: (br_on_cast $B $B ;; CHECK-NEXT: (struct.new $A ;; CHECK-NEXT: (i32.const 100) ;; CHECK-NEXT: ) @@ -5406,7 +5406,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block $A (result (ref $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $A $A + ;; CHECK-NEXT: (br_on_cast $A $A ;; CHECK-NEXT: (struct.new $A ;; CHECK-NEXT: (i32.const 200) ;; CHECK-NEXT: ) @@ -5432,7 +5432,7 @@ (drop (block $B (result (ref $B)) (drop - (br_on_cast_static $B $B + (br_on_cast $B $B (struct.new $A (i32.const 100) ) @@ -5444,10 +5444,10 @@ ;; But casting to $A will succeed, so the block is reachable, and also the ;; cast will return 1. (drop - (ref.test_static $A + (ref.test $A (block $A (result (ref $A)) (drop - (br_on_cast_static $A $A + (br_on_cast $A $A (struct.new $A (i32.const 200) ) diff --git a/test/lit/passes/gufa-vs-cfp.wast b/test/lit/passes/gufa-vs-cfp.wast index 359f0a83b..1cd0a7212 100644 --- a/test/lit/passes/gufa-vs-cfp.wast +++ b/test/lit/passes/gufa-vs-cfp.wast @@ -529,7 +529,7 @@ ;; As the get must trap, we can optimize to an unreachable here. (drop (struct.get $substruct 0 - (ref.cast_static $substruct + (ref.cast null $substruct (call $create) ) ) @@ -588,7 +588,7 @@ (func $get (drop (struct.get $substruct 0 - (ref.cast_static $substruct + (ref.cast null $substruct (call $create) ) ) @@ -642,7 +642,7 @@ ;; to $struct. But no null is possible since the local gets written a ;; non-null value before we get here, so we can optimize this to an ;; unreachable. - (ref.cast_static $substruct + (ref.cast null $substruct (local.get $ref) ) ) @@ -802,7 +802,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (select (result (ref $struct)) ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (i32.const 10) @@ -823,7 +823,7 @@ (drop (struct.get $struct 0 ;; This cast is added, ensuring only a $substruct can reach the get. - (ref.cast_static $substruct + (ref.cast null $substruct (select (struct.new $struct (i32.const 10) @@ -875,7 +875,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get $substruct 0 - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (local.get $ref) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -903,7 +903,7 @@ ) (drop (struct.get $substruct 0 - (ref.cast_static $substruct + (ref.cast null $substruct (local.get $ref) ) ) @@ -949,7 +949,7 @@ ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get $substruct 0 - ;; CHECK-NEXT: (ref.cast_static $substruct + ;; CHECK-NEXT: (ref.cast null $substruct ;; CHECK-NEXT: (local.get $ref) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -980,7 +980,7 @@ ) (drop (struct.get $substruct 0 - (ref.cast_static $substruct + (ref.cast null $substruct (local.get $ref) ) ) @@ -2041,7 +2041,7 @@ ) ;; CHECK: (func $set (type $none_=>_none) ;; CHECK-NEXT: (struct.set $A 0 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (call $create-C) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (i32.const 20) @@ -2052,7 +2052,7 @@ ;; the type is $A, which should not confuse us: this set does alias the data ;; in $C, which means we cannot optimize in the function $get below. (struct.set $A 0 - (ref.cast_static $A + (ref.cast null $A (call $create-C) ) (i32.const 20) ;; different value than in $create diff --git a/test/lit/passes/inlining-optimizing.wast b/test/lit/passes/inlining-optimizing.wast index c72d6a88b..4bc2dd573 100644 --- a/test/lit/passes/inlining-optimizing.wast +++ b/test/lit/passes/inlining-optimizing.wast @@ -33,7 +33,7 @@ (call $0) (drop (call_ref $none_=>_i32 - (ref.cast_static $none_=>_i32 + (ref.cast null $none_=>_i32 (ref.func $0) ) ) diff --git a/test/lit/passes/inlining_vacuum_optimize-instructions.wast b/test/lit/passes/inlining_vacuum_optimize-instructions.wast index 11e51b203..42b354fee 100644 --- a/test/lit/passes/inlining_vacuum_optimize-instructions.wast +++ b/test/lit/passes/inlining_vacuum_optimize-instructions.wast @@ -19,7 +19,7 @@ ;; CHECK: (func $target (type $ref?|$A|_=>_none) (param $0 (ref null $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -27,7 +27,7 @@ ;; CHECK-NEXT: ) (func $target (param $0 (ref null $A)) (drop - (ref.cast_static $B + (ref.cast null $B (struct.get $A 0 (call $get-null) ) diff --git a/test/lit/passes/monomorphize.wast b/test/lit/passes/monomorphize.wast index 1f0eb0f87..6c4acce2d 100644 --- a/test/lit/passes/monomorphize.wast +++ b/test/lit/passes/monomorphize.wast @@ -405,7 +405,7 @@ ;; ALWAYS: (func $refinable (type $ref|$A|_=>_none) (param $ref (ref $A)) ;; ALWAYS-NEXT: (local $x (ref $A)) ;; ALWAYS-NEXT: (call $import - ;; ALWAYS-NEXT: (ref.cast_static $B + ;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $ref) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) @@ -417,17 +417,17 @@ ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import - ;; ALWAYS-NEXT: (ref.cast_static $B + ;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $x) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import - ;; ALWAYS-NEXT: (ref.cast_static $B + ;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $x) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import - ;; ALWAYS-NEXT: (ref.cast_static $B + ;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $ref) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) @@ -435,12 +435,12 @@ ;; CAREFUL: (func $refinable (type $ref|$A|_=>_none) (param $0 (ref $A)) ;; CAREFUL-NEXT: (local $1 (ref $A)) ;; CAREFUL-NEXT: (call $import - ;; CAREFUL-NEXT: (ref.cast_static $B + ;; CAREFUL-NEXT: (ref.cast null $B ;; CAREFUL-NEXT: (local.get $0) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: (call $import - ;; CAREFUL-NEXT: (ref.cast_static $B + ;; CAREFUL-NEXT: (ref.cast null $B ;; CAREFUL-NEXT: (local.tee $1 ;; CAREFUL-NEXT: (select (result (ref $A)) ;; CAREFUL-NEXT: (local.get $0) @@ -451,12 +451,12 @@ ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: (call $import - ;; CAREFUL-NEXT: (ref.cast_static $B + ;; CAREFUL-NEXT: (ref.cast null $B ;; CAREFUL-NEXT: (local.get $1) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: (call $import - ;; CAREFUL-NEXT: (ref.cast_static $B + ;; CAREFUL-NEXT: (ref.cast null $B ;; CAREFUL-NEXT: (local.get $0) ;; CAREFUL-NEXT: ) ;; CAREFUL-NEXT: ) @@ -470,7 +470,7 @@ ;; cast will remain since we monomorphize without bothering to optimize and ;; see if there is any benefit.) (call $import - (ref.cast_static $B + (ref.cast null $B (local.get $ref) ) ) @@ -485,18 +485,18 @@ ) ) (call $import - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) (call $import - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) ;; Another use of $ref, also to avoid opts merging $x and $ref. (call $import - (ref.cast_static $B + (ref.cast null $B (local.get $ref) ) ) @@ -506,7 +506,7 @@ ;; ALWAYS: (func $refinable_0 (type $ref|$B|_=>_none) (param $ref (ref $B)) ;; ALWAYS-NEXT: (local $x (ref $A)) ;; ALWAYS-NEXT: (call $import -;; ALWAYS-NEXT: (ref.cast_static $B +;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $ref) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) @@ -518,17 +518,17 @@ ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import -;; ALWAYS-NEXT: (ref.cast_static $B +;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $x) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import -;; ALWAYS-NEXT: (ref.cast_static $B +;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $x) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: (call $import -;; ALWAYS-NEXT: (ref.cast_static $B +;; ALWAYS-NEXT: (ref.cast null $B ;; ALWAYS-NEXT: (local.get $ref) ;; ALWAYS-NEXT: ) ;; ALWAYS-NEXT: ) diff --git a/test/lit/passes/optimize-casts.wast b/test/lit/passes/optimize-casts.wast index c75efd48f..3d18e281f 100644 --- a/test/lit/passes/optimize-casts.wast +++ b/test/lit/passes/optimize-casts.wast @@ -96,7 +96,7 @@ ;; CHECK-NEXT: (local $1 (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $1 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -112,7 +112,7 @@ ;; As $ref.as but with ref.casts: we should use the cast value after it has ;; been computed, in both gets. (drop - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -128,7 +128,7 @@ ;; CHECK-NEXT: (local $1 (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $1 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -145,7 +145,7 @@ ;; CHECK-NEXT: ) (func $not-past-set (param $x (ref struct)) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -166,7 +166,7 @@ ;; CHECK-NEXT: (local $2 (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $1 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -176,7 +176,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $2 - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -187,7 +187,7 @@ ;; CHECK-NEXT: ) (func $best (param $x (ref struct)) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -196,7 +196,7 @@ (local.get $x) ) (drop - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) @@ -210,7 +210,7 @@ ;; CHECK-NEXT: (local $1 (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $1 - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -219,7 +219,7 @@ ;; CHECK-NEXT: (local.get $1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -231,7 +231,7 @@ ;; As above, but with the casts reversed. Now we should use $B in both ;; gets. (drop - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) @@ -239,7 +239,7 @@ (local.get $x) ) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -252,7 +252,7 @@ ;; CHECK-NEXT: (local $1 (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $1 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (block (result (ref data)) ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) @@ -265,7 +265,7 @@ ;; CHECK-NEXT: ) (func $fallthrough (param $x (ref struct)) (drop - (ref.cast_static $A + (ref.cast null $A ;; We look through the block, and optimize. (block (result (ref struct)) (local.get $x) @@ -279,7 +279,7 @@ ;; CHECK: (func $past-basic-block (type $ref|data|_=>_none) (param $x (ref data)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -293,7 +293,7 @@ ;; CHECK-NEXT: ) (func $past-basic-block (param $x (ref struct)) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -321,14 +321,14 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $4 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $a) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $5 - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $b) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -360,12 +360,12 @@ (local.get $y) ) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $a) ) ) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $b) ) ) diff --git a/test/lit/passes/optimize-instructions-call_ref.wast b/test/lit/passes/optimize-instructions-call_ref.wast index a0da2e9e5..2b648df3b 100644 --- a/test/lit/passes/optimize-instructions-call_ref.wast +++ b/test/lit/passes/optimize-instructions-call_ref.wast @@ -175,7 +175,7 @@ ;; call_ref that returns nothing with a call that returns an i32. In fact, we ;; end up optimizing the cast into an unreachable. (call_ref $none_=>_i32 - (ref.cast_static $none_=>_i32 + (ref.cast null $none_=>_i32 (ref.func $return-nothing) ) ) diff --git a/test/lit/passes/optimize-instructions-gc-iit.wast b/test/lit/passes/optimize-instructions-gc-iit.wast index ce93b5d04..904925940 100644 --- a/test/lit/passes/optimize-instructions-gc-iit.wast +++ b/test/lit/passes/optimize-instructions-gc-iit.wast @@ -41,7 +41,7 @@ ;; CHECK-NEXT: (local.get $child) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $child + ;; CHECK-NEXT: (ref.cast null $child ;; CHECK-NEXT: (local.get $parent) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -62,7 +62,7 @@ ;; NOMNL-NEXT: (local.get $child) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $child + ;; NOMNL-NEXT: (ref.cast null $child ;; NOMNL-NEXT: (local.get $parent) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -83,7 +83,7 @@ ;; NOMNL-TNH-NEXT: (local.get $child) ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: (drop - ;; NOMNL-TNH-NEXT: (ref.cast_static $child + ;; NOMNL-TNH-NEXT: (ref.cast null $child ;; NOMNL-TNH-NEXT: (local.get $parent) ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: ) @@ -104,13 +104,13 @@ ;; a cast of parent to parent. We can optimize this as the new type will be ;; valid. (drop - (ref.cast_static $parent + (ref.cast null $parent (local.get $parent) ) ) ;; a cast of child to a supertype: again, we replace with a valid type. (drop - (ref.cast_static $parent + (ref.cast null $parent (local.get $child) ) ) @@ -118,13 +118,13 @@ ;; $child with one that is not equal or more specific, like $parent, so we ;; cannot optimize here. (drop - (ref.cast_static $child + (ref.cast null $child (local.get $parent) ) ) ;; a cast of child to an unrelated type: it will trap anyhow (drop - (ref.cast_static $other + (ref.cast null $other (local.get $child) ) ) @@ -138,7 +138,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $parent + ;; CHECK-NEXT: (ref.cast null $parent ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -151,7 +151,7 @@ ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $parent + ;; NOMNL-NEXT: (ref.cast null $parent ;; NOMNL-NEXT: (unreachable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -164,7 +164,7 @@ ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: (drop - ;; NOMNL-TNH-NEXT: (ref.cast_static $parent + ;; NOMNL-TNH-NEXT: (ref.cast null $parent ;; NOMNL-TNH-NEXT: (unreachable) ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: ) @@ -174,7 +174,7 @@ ;; optimizing this cast away requires reordering. (drop - (ref.cast_static $parent + (ref.cast null $parent (block (result (ref $parent)) (call $foo) (local.get $parent) @@ -184,7 +184,7 @@ ;; ignore unreachability (drop - (ref.cast_static $parent + (ref.cast null $parent (unreachable) ) ) @@ -206,11 +206,11 @@ ;; NOMNL-TNH-NEXT: ) ;; NOMNL-TNH-NEXT: ) (func $ref-eq-ref-cast (param $x eqref) - ;; we can look through a ref.cast if we ignore traps + ;; we can look through a ref.cast null if we ignore traps (drop (ref.eq (local.get $x) - (ref.cast_static $parent + (ref.cast null $parent (local.get $x) ) ) @@ -280,7 +280,7 @@ ;; NOMNL-TNH-NEXT: ) (func $test (param $C (ref $C)) (result anyref) (struct.get $B 0 - (ref.cast_static $B ;; Try to cast a $C to its parent, $B. That always + (ref.cast null $B ;; Try to cast a $C to its parent, $B. That always ;; works, so the cast can be removed. ;; Then once the cast is removed, the outer struct.get ;; will have a reference with a different type, diff --git a/test/lit/passes/optimize-instructions-gc-tnh.wast b/test/lit/passes/optimize-instructions-gc-tnh.wast index 1e38ec8c7..2d3e25b9b 100644 --- a/test/lit/passes/optimize-instructions-gc-tnh.wast +++ b/test/lit/passes/optimize-instructions-gc-tnh.wast @@ -16,7 +16,7 @@ ;; NO_TNH: (func $ref.eq (type $eqref_eqref_=>_i32) (param $a eqref) (param $b eqref) (result i32) ;; NO_TNH-NEXT: (ref.eq ;; NO_TNH-NEXT: (ref.as_non_null - ;; NO_TNH-NEXT: (ref.cast_static $struct + ;; NO_TNH-NEXT: (ref.cast null $struct ;; NO_TNH-NEXT: (local.get $a) ;; NO_TNH-NEXT: ) ;; NO_TNH-NEXT: ) @@ -31,7 +31,7 @@ (ref.eq (ref.as_data (ref.as_non_null - (ref.cast_static $struct + (ref.cast null $struct (local.get $a) ) ) @@ -78,7 +78,7 @@ ;; something that does not validate (as ref.eq inputs must be eqrefs). (drop (ref.eq - (ref.cast_static $struct + (ref.cast null $struct (ref.func $ref.eq-no) ;; *Not* an eqref! ) (ref.as_non_null @@ -94,7 +94,7 @@ ;; TNH: (func $ref.is (type $eqref_=>_i32) (param $a eqref) (result i32) ;; TNH-NEXT: (drop - ;; TNH-NEXT: (ref.cast_static $struct + ;; TNH-NEXT: (ref.cast null $struct ;; TNH-NEXT: (ref.as_data ;; TNH-NEXT: (local.get $a) ;; TNH-NEXT: ) @@ -104,7 +104,7 @@ ;; TNH-NEXT: ) ;; NO_TNH: (func $ref.is (type $eqref_=>_i32) (param $a eqref) (result i32) ;; NO_TNH-NEXT: (drop - ;; NO_TNH-NEXT: (ref.cast_static $struct + ;; NO_TNH-NEXT: (ref.cast null $struct ;; NO_TNH-NEXT: (ref.as_data ;; NO_TNH-NEXT: (local.get $a) ;; NO_TNH-NEXT: ) @@ -116,7 +116,7 @@ ;; In this case non-nullability is enough to tell that the ref.is will ;; return 0. TNH does not help here. (ref.is_null - (ref.cast_static $struct + (ref.cast null $struct (ref.as_non_null (ref.as_data (local.get $a) @@ -133,7 +133,7 @@ ;; TNH-NEXT: ) ;; NO_TNH: (func $ref.is_b (type $eqref_=>_i32) (param $a eqref) (result i32) ;; NO_TNH-NEXT: (ref.is_null - ;; NO_TNH-NEXT: (ref.cast_static $struct + ;; NO_TNH-NEXT: (ref.cast null $struct ;; NO_TNH-NEXT: (local.get $a) ;; NO_TNH-NEXT: ) ;; NO_TNH-NEXT: ) @@ -143,7 +143,7 @@ ;; to be non-nullable. That means we cannot remove the ref.is, but we can ;; remove the cast in TNH. (ref.is_null - (ref.cast_static $struct + (ref.cast null $struct (local.get $a) ) ) diff --git a/test/lit/passes/optimize-instructions-gc.wast b/test/lit/passes/optimize-instructions-gc.wast index 5d53374d1..61b558868 100644 --- a/test/lit/passes/optimize-instructions-gc.wast +++ b/test/lit/passes/optimize-instructions-gc.wast @@ -954,7 +954,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.eq ;; CHECK-NEXT: (local.get $x) - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -964,7 +964,7 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.eq ;; NOMNL-NEXT: (local.get $x) - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -976,7 +976,7 @@ (drop (ref.eq (local.get $x) - (ref.cast_static $struct + (ref.cast null $struct (local.get $x) ) ) @@ -986,27 +986,27 @@ ;; CHECK: (func $flip-cast-of-as-non-null (type $anyref_=>_none) (param $x anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get_u $struct $i8 - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (ref.as_func ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (ref.as_i31 ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) @@ -1016,27 +1016,27 @@ ;; NOMNL: (func $flip-cast-of-as-non-null (type $anyref_=>_none) (param $x anyref) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (struct.get_u $struct $i8 - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (ref.as_func ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (ref.as_i31 ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) @@ -1045,8 +1045,8 @@ ;; NOMNL-NEXT: ) (func $flip-cast-of-as-non-null (param $x anyref) (drop - (ref.cast_static $struct - ;; this can be moved through the ref.cast outward. + (ref.cast null $struct + ;; this can be moved through the ref.cast null outward. (ref.as_non_null (local.get $x) ) @@ -1055,8 +1055,8 @@ (drop ;; an example of how this helps: the struct.get will trap on null anyhow (struct.get_u $struct 0 - (ref.cast_static $struct - ;; this can be moved through the ref.cast outward. + (ref.cast null $struct + ;; this can be moved through the ref.cast null outward. (ref.as_non_null (local.get $x) ) @@ -1065,14 +1065,14 @@ ) ;; other ref.as* operations are ignored for now (drop - (ref.cast_static $struct + (ref.cast null $struct (ref.as_func (local.get $x) ) ) ) (drop - (ref.cast_static $struct + (ref.cast null $struct (ref.as_i31 (local.get $x) ) @@ -1285,14 +1285,14 @@ ;; CHECK: (func $ref-cast-squared (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-squared (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1300,8 +1300,8 @@ (func $ref-cast-squared (param $x eqref) ;; Identical ref.casts can be folded together. (drop - (ref.cast_static $struct - (ref.cast_static $struct + (ref.cast null $struct + (ref.cast null $struct (local.get $x) ) ) @@ -1309,9 +1309,9 @@ ) ;; CHECK: (func $ref-cast-squared-fallthrough (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.tee $x - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1320,9 +1320,9 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-squared-fallthrough (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.tee $x - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1332,9 +1332,9 @@ (func $ref-cast-squared-fallthrough (param $x eqref) ;; A fallthrough in the middle does not prevent this optimization. (drop - (ref.cast_static $struct + (ref.cast null $struct (local.tee $x - (ref.cast_static $struct + (ref.cast null $struct (local.get $x) ) ) @@ -1343,14 +1343,14 @@ ) ;; CHECK: (func $ref-cast-cubed (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-cubed (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1358,9 +1358,9 @@ (func $ref-cast-cubed (param $x eqref) ;; Three and more also work. (drop - (ref.cast_static $struct - (ref.cast_static $struct - (ref.cast_static $struct + (ref.cast null $struct + (ref.cast null $struct + (ref.cast null $struct (local.get $x) ) ) @@ -1369,8 +1369,8 @@ ) ;; CHECK: (func $ref-cast-squared-different (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct - ;; CHECK-NEXT: (ref.cast_static $empty + ;; CHECK-NEXT: (ref.cast null $struct + ;; CHECK-NEXT: (ref.cast null $empty ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1378,8 +1378,8 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-squared-different (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct - ;; NOMNL-NEXT: (ref.cast_static $empty + ;; NOMNL-NEXT: (ref.cast null $struct + ;; NOMNL-NEXT: (ref.cast null $empty ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1388,8 +1388,8 @@ (func $ref-cast-squared-different (param $x eqref) ;; Different casts cannot be folded. (drop - (ref.cast_static $struct - (ref.cast_static $empty + (ref.cast null $struct + (ref.cast null $empty (local.get $x) ) ) @@ -1455,10 +1455,10 @@ ;; CHECK: (func $ref-eq-possible (type $eqref_eqref_=>_none) (param $x eqref) (param $y eqref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.eq - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1467,10 +1467,10 @@ ;; NOMNL: (func $ref-eq-possible (type $eqref_eqref_=>_none) (param $x eqref) (param $y eqref) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.eq - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1481,10 +1481,10 @@ ;; they are both null, so we cannot optimize here. (drop (ref.eq - (ref.cast_static $struct + (ref.cast null $struct (local.get $x) ) - (ref.cast_static $array + (ref.cast null $array (local.get $y) ) ) @@ -1496,13 +1496,13 @@ ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1512,13 +1512,13 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1530,14 +1530,14 @@ ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1551,13 +1551,13 @@ ;; NOMNL-NEXT: (block (result i32) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1567,13 +1567,13 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (block (result i32) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1585,14 +1585,14 @@ ;; NOMNL-NEXT: (block (result i32) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1606,12 +1606,12 @@ ;; equal, and the result must be 0. (drop (ref.eq - (ref.cast_static $struct + (ref.cast null $struct (ref.as_non_null (local.get $x) ) ) - (ref.cast_static $array + (ref.cast null $array (local.get $y) ) ) @@ -1619,10 +1619,10 @@ ;; As above but the cast is on the other one. (drop (ref.eq - (ref.cast_static $struct + (ref.cast null $struct (local.get $x) ) - (ref.cast_static $array + (ref.cast null $array (ref.as_non_null (local.get $y) ) @@ -1632,12 +1632,12 @@ ;; As above but the cast is both. (drop (ref.eq - (ref.cast_static $struct + (ref.cast null $struct (ref.as_non_null (local.get $x) ) ) - (ref.cast_static $array + (ref.cast null $array (ref.as_non_null (local.get $y) ) @@ -1650,12 +1650,12 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.eq ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1664,12 +1664,12 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.eq ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $y) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1680,12 +1680,12 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.eq ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $A + ;; NOMNL-NEXT: (ref.cast null $A ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1694,12 +1694,12 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.eq ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $A + ;; NOMNL-NEXT: (ref.cast null $A ;; NOMNL-NEXT: (local.get $y) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1711,12 +1711,12 @@ ;; subtype of A, so we cannot optimize. (drop (ref.eq - (ref.cast_static $A + (ref.cast null $A (ref.as_non_null (local.get $x) ) ) - (ref.cast_static $B + (ref.cast null $B (ref.as_non_null (local.get $y) ) @@ -1726,12 +1726,12 @@ ;; As above but flipped. (drop (ref.eq - (ref.cast_static $B + (ref.cast null $B (ref.as_non_null (local.get $x) ) ) - (ref.cast_static $A + (ref.cast null $A (ref.as_non_null (local.get $y) ) @@ -1804,7 +1804,7 @@ ;; NOMNL-NEXT: ) (func $incompatible-cast-of-non-null (param $struct (ref $struct)) (drop - (ref.cast_static $array + (ref.cast null $array (local.get $struct) ) ) @@ -1856,12 +1856,12 @@ ;; NOMNL-NEXT: ) (func $incompatible-cast-of-null (drop - (ref.cast_static $array + (ref.cast null $array (ref.null $struct) ) ) (drop - (ref.cast_static $array + (ref.cast null $array ;; The fallthrough is null, but the node's child's type is non-nullable, ;; so we must add a ref.as_non_null on the outside to keep the type ;; identical. @@ -1874,21 +1874,21 @@ ;; CHECK: (func $incompatible-cast-of-unknown (type $ref?|$struct|_=>_none) (param $struct (ref null $struct)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $struct) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $incompatible-cast-of-unknown (type $ref?|$struct|_=>_none) (param $struct (ref null $struct)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $struct) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) (func $incompatible-cast-of-unknown (param $struct (ref null $struct)) (drop - (ref.cast_static $array + (ref.cast null $array (local.get $struct) ) ) @@ -1917,7 +1917,7 @@ (func $incompatible-test (param $struct (ref null $struct)) (drop ;; This test will definitely fail, so we can turn it into 0. - (ref.test_static $array + (ref.test $array (local.get $struct) ) ) @@ -1925,24 +1925,24 @@ ;; CHECK: (func $subtype-compatible (type $ref?|$A|_ref?|$B|_=>_none) (param $A (ref null $A)) (param $B (ref null $B)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $A + ;; CHECK-NEXT: (ref.test $A ;; CHECK-NEXT: (local.get $B) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $subtype-compatible (type $ref?|$A|_ref?|$B|_=>_none) (param $A (ref null $A)) (param $B (ref null $B)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $B + ;; NOMNL-NEXT: (ref.test $B ;; NOMNL-NEXT: (local.get $A) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $A + ;; NOMNL-NEXT: (ref.test $A ;; NOMNL-NEXT: (local.get $B) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1950,27 +1950,27 @@ (func $subtype-compatible (param $A (ref null $A)) (param $B (ref null $B)) (drop ;; B is a subtype of A, so this can work. - (ref.test_static $B + (ref.test $B (local.get $A) ) ) (drop ;; The other direction works too. - (ref.test_static $A + (ref.test $A (local.get $B) ) ) ) ;; CHECK: (func $ref.test-unreachable (type $ref?|$A|_=>_none) (param $A (ref null $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $A + ;; CHECK-NEXT: (ref.test $A ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref.test-unreachable (type $ref?|$A|_=>_none) (param $A (ref null $A)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $A + ;; NOMNL-NEXT: (ref.test $A ;; NOMNL-NEXT: (unreachable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1979,7 +1979,7 @@ (drop ;; We should ignore unreachable ref.tests and not try to compare their ;; HeapTypes. - (ref.test_static $A + (ref.test $A (unreachable) ) ) @@ -1987,7 +1987,7 @@ ;; CHECK: (func $consecutive-opts-with-unreachable (type $funcref_=>_none) (param $func funcref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (block (result (ref i31)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.get $func) @@ -1999,7 +1999,7 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $consecutive-opts-with-unreachable (type $funcref_=>_none) (param $func funcref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (block (result (ref i31)) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (local.get $func) @@ -2011,10 +2011,10 @@ ;; NOMNL-NEXT: ) (func $consecutive-opts-with-unreachable (param $func funcref) (drop - (ref.cast_static $struct + (ref.cast null $struct ;; Casting a funcref to i31 will definitely fail, so this will be ;; replaced with an unreachable. But it should be enclosed in a block of - ;; the previous type, so that the outside ref.cast is not confused. This + ;; the previous type, so that the outside ref.cast null is not confused. This ;; is a regression test for a bug where we replace this node with an ;; unreachable one, but we left refinalize til the end of all the other ;; opts - and that meant that we got to our parent, the ref.cast, with @@ -2106,23 +2106,23 @@ (local $a (ref null $A)) ;; Casting nulls results in a null. (drop - (ref.cast_static $A + (ref.cast null $A (ref.null $A) ) ) (drop - (ref.cast_static $A + (ref.cast null $A (ref.null $B) ) ) (drop - (ref.cast_static $B + (ref.cast null $B (ref.null $A) ) ) ;; A fallthrough works too. (drop - (ref.cast_static $A + (ref.cast null $A (local.tee $a (ref.null $A) ) @@ -2153,7 +2153,7 @@ (func $ref-cast-static-impossible (param $func (ref func)) ;; A func cannot be cast to a struct, so this will trap. (drop - (ref.cast_static $struct + (ref.cast null $struct (local.get $func) ) ) @@ -2167,7 +2167,7 @@ ;; CHECK-NEXT: (local.get $b) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $a) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2185,7 +2185,7 @@ ;; NOMNL-NEXT: (local.get $b) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $a) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2199,24 +2199,24 @@ ;; In the general case, a static cast of something simply succeeds if the ;; type is a subtype. (drop - (ref.cast_static $A + (ref.cast null $A (local.get $a) ) ) (drop - (ref.cast_static $A + (ref.cast null $A (local.get $b) ) ) ;; This is the only one that we cannot know for sure will succeed. (drop - (ref.cast_static $B + (ref.cast null $B (local.get $a) ) ) ;; A fallthrough works too. (drop - (ref.cast_static $A + (ref.cast null $A (local.tee $a (local.get $a) ) @@ -2226,34 +2226,34 @@ ;; CHECK: (func $ref-cast-static-squared (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-squared (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $A + ;; NOMNL-NEXT: (ref.cast null $A ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2261,23 +2261,23 @@ (func $ref-cast-static-squared (param $x eqref) ;; Identical ref.casts can be folded together. (drop - (ref.cast_static $A - (ref.cast_static $A + (ref.cast null $A + (ref.cast null $A (local.get $x) ) ) ) ;; When subtypes exist, we only need the stricter one. (drop - (ref.cast_static $A - (ref.cast_static $B + (ref.cast null $A + (ref.cast null $B (local.get $x) ) ) ) (drop - (ref.cast_static $B - (ref.cast_static $A + (ref.cast null $B + (ref.cast null $A (local.get $x) ) ) @@ -2286,64 +2286,64 @@ ;; CHECK: (func $ref-cast-static-many (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-many (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2352,54 +2352,54 @@ ;; We should optimize a long sequence of static casts when we can. All six ;; orderings of these casts should collapse into the strictest one. (drop - (ref.cast_static $A - (ref.cast_static $B - (ref.cast_static $B-child + (ref.cast null $A + (ref.cast null $B + (ref.cast null $B-child (local.get $x) ) ) ) ) (drop - (ref.cast_static $A - (ref.cast_static $B-child - (ref.cast_static $B + (ref.cast null $A + (ref.cast null $B-child + (ref.cast null $B (local.get $x) ) ) ) ) (drop - (ref.cast_static $B - (ref.cast_static $A - (ref.cast_static $B-child + (ref.cast null $B + (ref.cast null $A + (ref.cast null $B-child (local.get $x) ) ) ) ) (drop - (ref.cast_static $B - (ref.cast_static $B-child - (ref.cast_static $A + (ref.cast null $B + (ref.cast null $B-child + (ref.cast null $A (local.get $x) ) ) ) ) (drop - (ref.cast_static $B-child - (ref.cast_static $A - (ref.cast_static $B + (ref.cast null $B-child + (ref.cast null $A + (ref.cast null $B (local.get $x) ) ) ) ) (drop - (ref.cast_static $B-child - (ref.cast_static $B - (ref.cast_static $A + (ref.cast null $B-child + (ref.cast null $B + (ref.cast null $A (local.get $x) ) ) @@ -2409,14 +2409,14 @@ ;; CHECK: (func $ref-cast-static-very-many (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B-child + ;; CHECK-NEXT: (ref.cast null $B-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-very-many (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B-child + ;; NOMNL-NEXT: (ref.cast null $B-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2424,18 +2424,18 @@ (func $ref-cast-static-very-many (param $x eqref) ;; We should optimize an arbitrarily-long long sequence of static casts. (drop - (ref.cast_static $A - (ref.cast_static $B - (ref.cast_static $B-child - (ref.cast_static $A - (ref.cast_static $A - (ref.cast_static $B-child - (ref.cast_static $B-child - (ref.cast_static $B - (ref.cast_static $B - (ref.cast_static $B - (ref.cast_static $B-child - (ref.cast_static $A + (ref.cast null $A + (ref.cast null $B + (ref.cast null $B-child + (ref.cast null $A + (ref.cast null $A + (ref.cast null $B-child + (ref.cast null $B-child + (ref.cast null $B + (ref.cast null $B + (ref.cast null $B + (ref.cast null $B-child + (ref.cast null $A (local.get $x) ) ) @@ -2458,7 +2458,7 @@ ;; CHECK-NEXT: (call $ref-cast-static-fallthrough-remaining ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2470,7 +2470,7 @@ ;; NOMNL-NEXT: (call $ref-cast-static-fallthrough-remaining ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2478,7 +2478,7 @@ ;; NOMNL-NEXT: ) (func $ref-cast-static-fallthrough-remaining (param $x eqref) (drop - (ref.cast_static $A + (ref.cast null $A (block (result (ref null $B)) ;; Additional contents in between redundant casts must be preserved. ;; That is, when we see that the casts are redundant, by seeing that @@ -2491,7 +2491,7 @@ (call $ref-cast-static-fallthrough-remaining (local.get $x) ) - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) @@ -2501,12 +2501,12 @@ ;; CHECK: (func $ref-cast-static-fallthrough-remaining-child (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (block (result eqref) ;; CHECK-NEXT: (call $ref-cast-static-fallthrough-remaining-child ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2515,12 +2515,12 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-fallthrough-remaining-child (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (block (result eqref) ;; NOMNL-NEXT: (call $ref-cast-static-fallthrough-remaining-child ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) - ;; NOMNL-NEXT: (ref.cast_static $A + ;; NOMNL-NEXT: (ref.cast null $A ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2532,12 +2532,12 @@ ;; As above, but with $A and $B flipped. Now the inner cast is not needed. ;; However, we do not remove it, as it may be necessary for validation, ;; and we hope other opts help out here. - (ref.cast_static $B + (ref.cast null $B (block (result (eqref)) (call $ref-cast-static-fallthrough-remaining-child (local.get $x) ) - (ref.cast_static $A + (ref.cast null $A (local.get $x) ) ) @@ -2553,7 +2553,7 @@ ;; CHECK-NEXT: (call $ref-cast-static-fallthrough-remaining-impossible ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2570,7 +2570,7 @@ ;; NOMNL-NEXT: (call $ref-cast-static-fallthrough-remaining-impossible ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) - ;; NOMNL-NEXT: (ref.cast_static $struct + ;; NOMNL-NEXT: (ref.cast null $struct ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2584,12 +2584,12 @@ ;; As above, but with an impossible cast of an array to a struct. The ;; block with the side effects and the inner cast must be kept around and ;; dropped, and then we replace the outer cast with an unreachable. - (ref.cast_static $array + (ref.cast null $array (block (result (ref eq)) (call $ref-cast-static-fallthrough-remaining-impossible (local.get $x) ) - (ref.cast_static $struct + (ref.cast null $struct (local.get $x) ) ) @@ -2599,12 +2599,12 @@ ;; CHECK: (func $ref-cast-static-fallthrough-remaining-nonnull (type $ref|eq|_=>_none) (param $x (ref eq)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (block (result (ref eq)) ;; CHECK-NEXT: (call $ref-cast-static-fallthrough-remaining ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2613,12 +2613,12 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-fallthrough-remaining-nonnull (type $ref|eq|_=>_none) (param $x (ref eq)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $A + ;; NOMNL-NEXT: (ref.cast null $A ;; NOMNL-NEXT: (block (result (ref eq)) ;; NOMNL-NEXT: (call $ref-cast-static-fallthrough-remaining ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2632,12 +2632,12 @@ ;; the middle block prevents us from seeing that (after other opts run, ;; however, we would). (drop - (ref.cast_static $A + (ref.cast null $A (block (result (ref eq)) (call $ref-cast-static-fallthrough-remaining (local.get $x) ) - (ref.cast_static $B + (ref.cast null $B (local.get $x) ) ) @@ -2647,8 +2647,8 @@ ;; CHECK: (func $ref-cast-static-squared-impossible (type $eqref_=>_none) (param $x eqref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $struct - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $struct + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2657,7 +2657,7 @@ ;; CHECK-NEXT: (block (result (ref $struct)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null - ;; CHECK-NEXT: (ref.cast_static $array + ;; CHECK-NEXT: (ref.cast null $array ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2668,8 +2668,8 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-cast-static-squared-impossible (type $eqref_=>_none) (param $x eqref) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.cast_static $struct - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $struct + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2678,7 +2678,7 @@ ;; NOMNL-NEXT: (block (result (ref $struct)) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (ref.as_non_null - ;; NOMNL-NEXT: (ref.cast_static $array + ;; NOMNL-NEXT: (ref.cast null $array ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2690,15 +2690,15 @@ (func $ref-cast-static-squared-impossible (param $x eqref) ;; Impossible casts will trap unless the input is null. (drop - (ref.cast_static $struct - (ref.cast_static $array + (ref.cast null $struct + (ref.cast null $array (local.get $x) ) ) ) (drop - (ref.cast_static $struct - (ref.cast_static $array + (ref.cast null $struct + (ref.cast null $array (ref.as_non_null (local.get $x)) ) ) @@ -2707,7 +2707,7 @@ ;; CHECK: (func $ref-test-static-same-type (type $ref?|$A|_ref|$A|_=>_none) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $A + ;; CHECK-NEXT: (ref.test $A ;; CHECK-NEXT: (local.get $nullable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2722,7 +2722,7 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-test-static-same-type (type $ref?|$A|_ref|$A|_=>_none) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $A + ;; NOMNL-NEXT: (ref.test $A ;; NOMNL-NEXT: (local.get $nullable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2739,13 +2739,13 @@ ;; A nullable value cannot be optimized here even though it is the same ;; type. (drop - (ref.test_static $A + (ref.test $A (local.get $nullable) ) ) ;; But if it is non-nullable, it must succeed. (drop - (ref.test_static $A + (ref.test $A (local.get $non-nullable) ) ) @@ -2753,7 +2753,7 @@ ;; CHECK: (func $ref-test-static-subtype (type $ref?|$B|_ref|$B|_=>_none) (param $nullable (ref null $B)) (param $non-nullable (ref $B)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $A + ;; CHECK-NEXT: (ref.test $A ;; CHECK-NEXT: (local.get $nullable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2768,7 +2768,7 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-test-static-subtype (type $ref?|$B|_ref|$B|_=>_none) (param $nullable (ref null $B)) (param $non-nullable (ref $B)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $A + ;; NOMNL-NEXT: (ref.test $A ;; NOMNL-NEXT: (local.get $nullable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2784,12 +2784,12 @@ (func $ref-test-static-subtype (param $nullable (ref null $B)) (param $non-nullable (ref $B)) ;; As above, but the input is a subtype, so the same things happen. (drop - (ref.test_static $A + (ref.test $A (local.get $nullable) ) ) (drop - (ref.test_static $A + (ref.test $A (local.get $non-nullable) ) ) @@ -2797,24 +2797,24 @@ ;; CHECK: (func $ref-test-static-supertype (type $ref?|$A|_ref|$A|_=>_none) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (local.get $nullable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $B + ;; CHECK-NEXT: (ref.test $B ;; CHECK-NEXT: (local.get $non-nullable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; NOMNL: (func $ref-test-static-supertype (type $ref?|$A|_ref|$A|_=>_none) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $B + ;; NOMNL-NEXT: (ref.test $B ;; NOMNL-NEXT: (local.get $nullable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $B + ;; NOMNL-NEXT: (ref.test $B ;; NOMNL-NEXT: (local.get $non-nullable) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2823,12 +2823,12 @@ ;; As above, but the input is a supertype. We can't know at compile time ;; what to do here. (drop - (ref.test_static $B + (ref.test $B (local.get $nullable) ) ) (drop - (ref.test_static $B + (ref.test $B (local.get $non-nullable) ) ) @@ -2873,12 +2873,12 @@ (func $ref-test-static-impossible (param $nullable (ref null $array)) (param $non-nullable (ref $array)) ;; Testing an impossible cast will definitely fail. (drop - (ref.test_static $struct + (ref.test $struct (local.get $nullable) ) ) (drop - (ref.test_static $struct + (ref.test $struct (local.get $non-nullable) ) ) @@ -2897,7 +2897,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.test_static $A + ;; CHECK-NEXT: (ref.test $A ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -2915,7 +2915,7 @@ ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (ref.test_static $A + ;; NOMNL-NEXT: (ref.test $A ;; NOMNL-NEXT: (local.get $x) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -2942,7 +2942,7 @@ ) (drop (i32.and - (ref.test_static $A + (ref.test $A (local.get $x) ) (i32.const 1) diff --git a/test/lit/passes/optimize-instructions-iit-eh.wast b/test/lit/passes/optimize-instructions-iit-eh.wast index 6d8a8fe39..cf69e4b90 100644 --- a/test/lit/passes/optimize-instructions-iit-eh.wast +++ b/test/lit/passes/optimize-instructions-iit-eh.wast @@ -25,13 +25,13 @@ (do) (catch $e (throw $e - ;; Because --ignore-implicit-traps is given, this ref.cast_static is - ;; assumed not to throw so this ref.cast can be statically removed. + ;; Because --ignore-implicit-traps is given, this ref.cast null is + ;; assumed not to throw so this ref.cast null can be statically removed. ;; But that creates a block around this, making 'pop' nested into it, ;; which is invalid. We fix this up at the end up OptimizeInstruction, ;; assigning the 'pop' to a local at the start of this 'catch' body ;; and later using 'local.get' to get it. - (ref.cast_static $struct.A + (ref.cast null $struct.A (pop (ref null $struct.A)) ) ) diff --git a/test/lit/passes/precompute-gc-immutable.wast b/test/lit/passes/precompute-gc-immutable.wast index 2420a139c..5b0d4dffd 100644 --- a/test/lit/passes/precompute-gc-immutable.wast +++ b/test/lit/passes/precompute-gc-immutable.wast @@ -794,7 +794,7 @@ ;; We can precompute all these operations away into the final constants. (call $helper (struct.get $vtable-0 0 - (ref.cast_static $vtable-0 + (ref.cast null $vtable-0 (array.get $itable (struct.get $object 0 (local.get $ref) @@ -806,7 +806,7 @@ ) (call $helper (struct.get $vtable-1 0 - (ref.cast_static $vtable-1 + (ref.cast null $vtable-1 (array.get $itable (struct.get $object 0 (local.get $ref) diff --git a/test/lit/passes/precompute-gc.wast b/test/lit/passes/precompute-gc.wast index 7c4292ea2..26f22fa6a 100644 --- a/test/lit/passes/precompute-gc.wast +++ b/test/lit/passes/precompute-gc.wast @@ -1084,10 +1084,10 @@ (local $temp (ref null $B)) ;; Try to cast a null of A to B. While the types are incompatible, ref.cast ;; returns a null when given a null (and the null must have the type that the - ;; ref.cast instruction has, that is, the value is a null of type $B). So this + ;; ref.cast null instruction has, that is, the value is a null of type $B). So this ;; is an odd cast that "works". (local.set $temp - (ref.cast_static $B + (ref.cast null $B (ref.null $A) ) ) @@ -1139,7 +1139,7 @@ ;; As above, but with a tuple. (local.set $temp (tuple.make - (ref.cast_static $B + (ref.cast null $B (ref.null $A) ) (i32.const 10) @@ -1166,7 +1166,7 @@ ;; CHECK: (func $odd-cast-and-get-non-null (type $ref|$func-return-i32|_=>_none) (param $temp (ref $func-return-i32)) ;; CHECK-NEXT: (local.set $temp - ;; CHECK-NEXT: (ref.cast_static $func-return-i32 + ;; CHECK-NEXT: (ref.cast null $func-return-i32 ;; CHECK-NEXT: (ref.func $receive-f64) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1178,7 +1178,7 @@ ;; CHECK-NEXT: ) ;; NOMNL: (func $odd-cast-and-get-non-null (type $ref|$func-return-i32|_=>_none) (param $temp (ref $func-return-i32)) ;; NOMNL-NEXT: (local.set $temp - ;; NOMNL-NEXT: (ref.cast_static $func-return-i32 + ;; NOMNL-NEXT: (ref.cast null $func-return-i32 ;; NOMNL-NEXT: (ref.func $receive-f64) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1191,7 +1191,7 @@ (func $odd-cast-and-get-non-null (param $temp (ref $func-return-i32)) ;; Try to cast a function to an incompatible type. (local.set $temp - (ref.cast_static $func-return-i32 + (ref.cast null $func-return-i32 (ref.func $receive-f64) ) ) @@ -1238,7 +1238,7 @@ ;; CHECK: (func $br_on_cast-on-creation (type $none_=>_ref|$empty|) (result (ref $empty)) ;; CHECK-NEXT: (block $label (result (ref $empty)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $label $empty + ;; CHECK-NEXT: (br_on_cast $label $empty ;; CHECK-NEXT: (struct.new_default $empty) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -1248,7 +1248,7 @@ ;; NOMNL: (func $br_on_cast-on-creation (type $none_=>_ref|$empty|) (result (ref $empty)) ;; NOMNL-NEXT: (block $label (result (ref $empty)) ;; NOMNL-NEXT: (drop - ;; NOMNL-NEXT: (br_on_cast_static $label $empty + ;; NOMNL-NEXT: (br_on_cast $label $empty ;; NOMNL-NEXT: (struct.new_default $empty) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -1258,7 +1258,7 @@ (func $br_on_cast-on-creation (result (ref $empty)) (block $label (result (ref $empty)) (drop - (br_on_cast_static $label $empty + (br_on_cast $label $empty (struct.new_default $empty) ) ) diff --git a/test/lit/passes/remove-unused-brs-gc.wast b/test/lit/passes/remove-unused-brs-gc.wast index 3de48c441..c448a47c2 100644 --- a/test/lit/passes/remove-unused-brs-gc.wast +++ b/test/lit/passes/remove-unused-brs-gc.wast @@ -116,7 +116,7 @@ ) ) - ;; CHECK: (func $br_on_cast_static (type $none_=>_ref|$struct|) (result (ref $struct)) + ;; CHECK: (func $br_on_cast (type $none_=>_ref|$struct|) (result (ref $struct)) ;; CHECK-NEXT: (local $temp (ref null $struct)) ;; CHECK-NEXT: (block $block (result (ref $struct)) ;; CHECK-NEXT: (drop @@ -127,13 +127,13 @@ ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - (func $br_on_cast_static (result (ref $struct)) + (func $br_on_cast (result (ref $struct)) (local $temp (ref null $struct)) (block $block (result (ref $struct)) (drop ;; This static cast can be computed at compile time: it will definitely be ;; taken, so we can turn it into a normal br. - (br_on_cast_static $block $struct + (br_on_cast $block $struct (struct.new $struct) ) ) @@ -141,22 +141,22 @@ ) ) - ;; CHECK: (func $br_on_cast_static_no (type $none_=>_ref|$struct|) (result (ref $struct)) + ;; CHECK: (func $br_on_cast_no (type $none_=>_ref|$struct|) (result (ref $struct)) ;; CHECK-NEXT: (local $temp (ref null $struct)) ;; CHECK-NEXT: (block $block (result (ref $struct)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $block $struct + ;; CHECK-NEXT: (br_on_cast $block $struct ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - (func $br_on_cast_static_no (result (ref $struct)) + (func $br_on_cast_no (result (ref $struct)) (local $temp (ref null $struct)) (block $block (result (ref $struct)) (drop - (br_on_cast_static $block $struct + (br_on_cast $block $struct ;; As above, but now the type is nullable, so we cannot infer anything. (ref.null $struct) ) @@ -165,7 +165,7 @@ ) ) - ;; CHECK: (func $br_on_cast_fail_static (type $none_=>_ref|$struct|) (result (ref $struct)) + ;; CHECK: (func $br_on_cast_fail (type $none_=>_ref|$struct|) (result (ref $struct)) ;; CHECK-NEXT: (local $temp (ref null $struct)) ;; CHECK-NEXT: (block $block ;; CHECK-NEXT: (drop @@ -174,13 +174,13 @@ ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - (func $br_on_cast_fail_static (result (ref $struct)) + (func $br_on_cast_fail (result (ref $struct)) (local $temp (ref null $struct)) (block $block (result (ref $struct)) (drop - ;; As $br_on_cast_static, but this checks for a failing cast, so we know it will + ;; As $br_on_cast, but this checks for a failing cast, so we know it will ;; *not* be taken. - (br_on_cast_static_fail $block $struct + (br_on_cast_fail $block $struct (struct.new $struct) ) ) @@ -192,7 +192,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (if (result i32) ;; CHECK-NEXT: (local.get $x) - ;; CHECK-NEXT: (ref.test_static $struct + ;; CHECK-NEXT: (ref.test $struct ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (i32.const 0) @@ -202,7 +202,7 @@ ;; CHECK-NEXT: (if (result anyref) ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (ref.null none) - ;; CHECK-NEXT: (ref.cast_static $struct + ;; CHECK-NEXT: (ref.cast null $struct ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -212,7 +212,7 @@ ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (block $something (result anyref) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast_static $something $struct + ;; CHECK-NEXT: (br_on_cast $something $struct ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -245,7 +245,7 @@ (drop (if (result i32) (local.get $x) - (ref.test_static $struct + (ref.test $struct (ref.null any) ) (i32.const 0) @@ -255,7 +255,7 @@ (if (result anyref) (local.get $x) (ref.null any) - (ref.cast_static $struct + (ref.cast null $struct (ref.null any) ) ) @@ -266,7 +266,7 @@ (block (result anyref) (block $something (result anyref) (drop - (br_on_cast_static $something $struct + (br_on_cast $something $struct (ref.null $struct) ) ) diff --git a/test/lit/passes/rse-gc.wast b/test/lit/passes/rse-gc.wast index 231c4107a..935006680 100644 --- a/test/lit/passes/rse-gc.wast +++ b/test/lit/passes/rse-gc.wast @@ -52,7 +52,7 @@ ;; CHECK: (func $pick-refined (type $ref?|$A|_i32_=>_none) (param $A (ref null $A)) (param $x i32) ;; CHECK-NEXT: (local $B (ref null $B)) ;; CHECK-NEXT: (local.set $B - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -81,7 +81,7 @@ (func $pick-refined (param $A (ref null $A)) (param $x i32) (local $B (ref null $B)) (local.set $B - (ref.cast_static $B + (ref.cast null $B (local.get $A) ) ) @@ -113,7 +113,7 @@ ;; CHECK: (func $pick-refined-nn (type $ref|$A|_=>_none) (param $A (ref $A)) ;; CHECK-NEXT: (local $B (ref $B)) ;; CHECK-NEXT: (local.set $B - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -129,7 +129,7 @@ ;; As above, but now the types are both non-nullable. We should still switch ;; to $B. (local.set $B - (ref.cast_static $B + (ref.cast null $B (local.get $A) ) ) @@ -144,7 +144,7 @@ ;; CHECK: (func $avoid-unrefined (type $ref|$A|_=>_none) (param $A (ref $A)) ;; CHECK-NEXT: (local $B (ref null $B)) ;; CHECK-NEXT: (local.set $B - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -161,7 +161,7 @@ ;; nullable, that means neither is a subtype of the other, and we will make ;; no changes. (local.set $B - (ref.cast_static $B + (ref.cast null $B (local.get $A) ) ) diff --git a/test/lit/passes/signature-pruning.wast b/test/lit/passes/signature-pruning.wast index 7d1a0d197..01aebe3bb 100644 --- a/test/lit/passes/signature-pruning.wast +++ b/test/lit/passes/signature-pruning.wast @@ -793,7 +793,7 @@ (type $A (struct)) ;; CHECK: (func $0 (type $none_=>_none) ;; CHECK-NEXT: (local $0 f32) - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -804,7 +804,7 @@ ;; we do need to handle it in the optimization as well as print it (note how ;; type $A is declared in the output here - it would be a bug if it were ;; not, which this is a regression test for). - (ref.cast_static $A + (ref.cast null $A (unreachable) ) ) diff --git a/test/lit/passes/simplify-locals-gc.wast b/test/lit/passes/simplify-locals-gc.wast index b71da529c..d97d206a1 100644 --- a/test/lit/passes/simplify-locals-gc.wast +++ b/test/lit/passes/simplify-locals-gc.wast @@ -604,7 +604,7 @@ ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get $B 0 ;; CHECK-NEXT: (local.tee $B - ;; CHECK-NEXT: (ref.cast_static $B + ;; CHECK-NEXT: (ref.cast null $B ;; CHECK-NEXT: (local.get $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -632,7 +632,7 @@ ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (struct.get $B 0 ;; NOMNL-NEXT: (local.tee $B - ;; NOMNL-NEXT: (ref.cast_static $B + ;; NOMNL-NEXT: (ref.cast null $B ;; NOMNL-NEXT: (local.get $A) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) @@ -655,7 +655,7 @@ ;; nullability but not the heap type. (local $B (ref null $B)) (local.set $B - (ref.cast_static $B + (ref.cast null $B (local.get $A) ) ) diff --git a/test/lit/passes/type-merging.wast b/test/lit/passes/type-merging.wast index f28cf0e1d..56e339777 100644 --- a/test/lit/passes/type-merging.wast +++ b/test/lit/passes/type-merging.wast @@ -19,12 +19,12 @@ ;; CHECK-NEXT: (local $c (ref null $C)) ;; CHECK-NEXT: (local $d (ref null $D)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $A + ;; CHECK-NEXT: (ref.cast null $A ;; CHECK-NEXT: (local.get $a) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (ref.cast_static $D + ;; CHECK-NEXT: (ref.cast null $D ;; CHECK-NEXT: (local.get $a) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) @@ -41,13 +41,13 @@ ;; A cast of $A has no effect. (drop - (ref.cast_static $A + (ref.cast null $A (local.get $a) ) ) ;; A cast of $D prevents it from being merged. (drop - (ref.cast_static $D + (ref.cast null $D (local.get $a) ) ) diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast index 790c6488a..abc47901f 100644 --- a/test/lit/passes/type-ssa.wast +++ b/test/lit/passes/type-ssa.wast @@ -374,7 +374,7 @@ ) ) - ;; CHECK: (func $array.init (type $ref|i31|_anyref_=>_none) (param $refined (ref i31)) (param $null-any anyref) + ;; CHECK: (func $array.init_static (type $ref|i31|_anyref_=>_none) (param $refined (ref i31)) (param $null-any anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (array.init_static $array$5 ;; CHECK-NEXT: (ref.null none) @@ -397,7 +397,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; NOMNL: (func $array.init (type $ref|i31|_anyref_=>_none) (param $refined (ref i31)) (param $null-any anyref) + ;; NOMNL: (func $array.init_static (type $ref|i31|_anyref_=>_none) (param $refined (ref i31)) (param $null-any anyref) ;; NOMNL-NEXT: (drop ;; NOMNL-NEXT: (array.init_static $array$5 ;; NOMNL-NEXT: (ref.null none) @@ -420,7 +420,7 @@ ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) ;; NOMNL-NEXT: ) - (func $array.init (param $refined (ref i31)) (param $null-any (ref null any)) + (func $array.init_static (param $refined (ref i31)) (param $null-any (ref null any)) ;; Null, interesting, so we get a new type. (drop (array.init_static $array diff --git a/test/lit/ref-cast-nop.wast b/test/lit/ref-cast-nop.wast index 51df10947..060005f4d 100644 --- a/test/lit/ref-cast-nop.wast +++ b/test/lit/ref-cast-nop.wast @@ -5,13 +5,13 @@ (module ;; CHECK: (type $struct (struct (field i32))) (type $struct (struct i32)) - ;; CHECK: (func $ref.cast_nop_static (type $ref|any|_=>_ref|$struct|) (param $x (ref any)) (result (ref $struct)) - ;; CHECK-NEXT: (ref.cast_nop_static $struct + ;; CHECK: (func $ref.cast_nop (type $ref|any|_=>_ref|$struct|) (param $x (ref any)) (result (ref $struct)) + ;; CHECK-NEXT: (ref.cast_nop $struct ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - (func $ref.cast_nop_static (param $x (ref any)) (result (ref $struct)) - (ref.cast_nop_static $struct + (func $ref.cast_nop (param $x (ref any)) (result (ref $struct)) + (ref.cast_nop $struct (local.get $x) ) ) diff --git a/test/passes/Oz_fuzz-exec_all-features.txt b/test/passes/Oz_fuzz-exec_all-features.txt index 1d2fe7ed5..afeae72f0 100644 --- a/test/passes/Oz_fuzz-exec_all-features.txt +++ b/test/passes/Oz_fuzz-exec_all-features.txt @@ -42,11 +42,11 @@ [LoggingExternalInterface logging 99] [LoggingExternalInterface logging 0] [LoggingExternalInterface logging 10] -[fuzz-exec] calling array.init +[fuzz-exec] calling array.init_static [LoggingExternalInterface logging 2] [LoggingExternalInterface logging 42] [LoggingExternalInterface logging 50] -[fuzz-exec] calling array.init-packed +[fuzz-exec] calling array.init_static-packed [LoggingExternalInterface logging 8] [fuzz-exec] calling static-casts [LoggingExternalInterface logging 1] @@ -82,8 +82,8 @@ (export "init-array-packed" (func $14)) (export "cast-func-to-struct" (func $9)) (export "array-copy" (func $17)) - (export "array.init" (func $18)) - (export "array.init-packed" (func $19)) + (export "array.init_static" (func $18)) + (export "array.init_static-packed" (func $19)) (export "static-casts" (func $20)) (export "static-br_on_cast" (func $2)) (export "static-br_on_cast_fail" (func $22)) @@ -162,7 +162,7 @@ (i32.const 1) ) (drop - (br_on_cast_static_fail $any $extendedstruct + (br_on_cast_fail $any $extendedstruct (local.get $0) ) ) @@ -384,11 +384,11 @@ [LoggingExternalInterface logging 99] [LoggingExternalInterface logging 0] [LoggingExternalInterface logging 10] -[fuzz-exec] calling array.init +[fuzz-exec] calling array.init_static [LoggingExternalInterface logging 2] [LoggingExternalInterface logging 42] [LoggingExternalInterface logging 50] -[fuzz-exec] calling array.init-packed +[fuzz-exec] calling array.init_static-packed [LoggingExternalInterface logging 8] [fuzz-exec] calling static-casts [LoggingExternalInterface logging 1] diff --git a/test/passes/Oz_fuzz-exec_all-features.wast b/test/passes/Oz_fuzz-exec_all-features.wast index 3d86b9f99..203fc60fe 100644 --- a/test/passes/Oz_fuzz-exec_all-features.wast +++ b/test/passes/Oz_fuzz-exec_all-features.wast @@ -84,9 +84,9 @@ (block $extendedblock (result (ref $extendedstruct)) (drop ;; second, try to cast our simple $struct to what it is, which will work - (br_on_cast_static $block $struct + (br_on_cast $block $struct ;; first, try to cast our simple $struct to an extended, which will fail - (br_on_cast_static $extendedblock $extendedstruct + (br_on_cast $extendedblock $extendedstruct (local.get $any) ) ) @@ -113,7 +113,7 @@ (drop ;; try to cast our simple $struct to an extended, which will fail, and ;; so we will branch, skipping the next logging. - (br_on_cast_static_fail $any $extendedstruct + (br_on_cast_fail $any $extendedstruct (local.get $any) ) ) @@ -134,7 +134,7 @@ (drop ;; try to cast our simple $struct to an extended, which will succeed, and ;; so we will continue to the next logging. - (br_on_cast_static_fail $any $extendedstruct + (br_on_cast_fail $any $extendedstruct (local.get $any) ) ) @@ -148,7 +148,7 @@ ;; array or a struct, so our casting code should not assume it is. it is ok ;; to try to cast it, and the result should be 0. (call $log - (ref.test_static $struct + (ref.test $struct (ref.null any) ) ) @@ -199,12 +199,12 @@ (call $log (i32.const 0)) ;; a valid cast (call_ref $void_func - (ref.cast_static $void_func (ref.func $a-void-func)) + (ref.cast null $void_func (ref.func $a-void-func)) ) (call $log (i32.const 1)) ;; an invalid cast (drop (call_ref $int_func - (ref.cast_static $int_func (ref.func $a-void-func)) + (ref.cast null $int_func (ref.func $a-void-func)) )) ;; will never be reached (call $log (i32.const 2)) @@ -236,7 +236,7 @@ (func "cast-func-to-struct" (drop ;; An impossible cast of a function to a struct, which should fail. - (ref.cast_static $struct + (ref.cast null $struct (ref.func $call-target) ) ) @@ -287,7 +287,7 @@ (array.get_u $bytes (local.get $x) (i32.const 12)) ) ) - (func "array.init" + (func "array.init_static" (local $x (ref null $bytes)) (local.set $x (array.init_static $bytes @@ -308,7 +308,7 @@ (array.get_u $bytes (local.get $x) (i32.const 1)) ) ) - (func "array.init-packed" + (func "array.init_static-packed" (local $x (ref null $bytes)) (local.set $x (array.init_static $bytes @@ -323,15 +323,15 @@ (func "static-casts" ;; Casting null returns null. (call $log (ref.is_null - (ref.cast_static $struct (ref.null $struct)) + (ref.cast null $struct (ref.null $struct)) )) ;; Testing null returns 0. (call $log - (ref.test_static $struct (ref.null $struct)) + (ref.test $struct (ref.null $struct)) ) ;; Testing something completely wrong (struct vs array) returns 0. (call $log - (ref.test_static $struct + (ref.test $struct (array.new $bytes (i32.const 20) (i32.const 10) @@ -340,19 +340,19 @@ ) ;; Testing a thing with the same type returns 1. (call $log - (ref.test_static $struct + (ref.test $struct (struct.new_default $struct) ) ) ;; A bad downcast returns 0: we create a struct, which is not a extendedstruct. (call $log - (ref.test_static $extendedstruct + (ref.test $extendedstruct (struct.new_default $struct) ) ) ;; Casting to a supertype works. (call $log - (ref.test_static $struct + (ref.test $struct (struct.new_default $extendedstruct) ) ) @@ -369,9 +369,9 @@ (block $extendedblock (result (ref $extendedstruct)) (drop ;; second, try to cast our simple $struct to what it is, which will work - (br_on_cast_static $block $struct + (br_on_cast $block $struct ;; first, try to cast our simple $struct to an extended, which will fail - (br_on_cast_static $extendedblock $extendedstruct + (br_on_cast $extendedblock $extendedstruct (local.get $any) ) ) @@ -396,7 +396,7 @@ (block $failblock (result anyref) (drop ;; try to cast our simple $struct to an extended, which will fail - (br_on_cast_static_fail $failblock $extendedstruct + (br_on_cast_fail $failblock $extendedstruct (local.get $any) ) ) diff --git a/test/spec/array-new-elem.wast b/test/spec/array-new-elem.wast index d20d8109b..9e1ac9116 100644 --- a/test/spec/array-new-elem.wast +++ b/test/spec/array-new-elem.wast @@ -16,7 +16,7 @@ ) (func $get (param $i i32) (param $v (ref $vec)) (result i32) - (call_ref $f (ref.cast_static $f (array.get $vec (local.get $v) (local.get $i)))) + (call_ref $f (ref.cast null $f (array.get $vec (local.get $v) (local.get $i)))) ) (func (export "get") (param $i i32) (result i32) (call $get (local.get $i) (call $new)) @@ -24,7 +24,7 @@ (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y i32) (result i32) (array.set $mvec (local.get $v) (local.get $i) (array.get $mvec (local.get $v) (local.get $y))) - (call_ref $f (ref.cast_static $f (array.get $mvec (local.get $v) (local.get $i)))) + (call_ref $f (ref.cast null $f (array.get $mvec (local.get $v) (local.get $i)))) ) (func (export "set_get") (param $i i32) (param $y i32) (result i32) (call $set_get diff --git a/test/spec/ref_cast.wast b/test/spec/ref_cast.wast index 86f958b80..53ca9227c 100644 --- a/test/spec/ref_cast.wast +++ b/test/spec/ref_cast.wast @@ -29,37 +29,37 @@ (func (export "test-sub") (call $init) - (drop (ref.cast_static $t0 (ref.null data))) - (drop (ref.cast_static $t0 (global.get $tab.0))) - (drop (ref.cast_static $t0 (global.get $tab.1))) - (drop (ref.cast_static $t0 (global.get $tab.2))) - (drop (ref.cast_static $t0 (global.get $tab.3))) - (drop (ref.cast_static $t0 (global.get $tab.4))) + (drop (ref.cast null $t0 (ref.null data))) + (drop (ref.cast null $t0 (global.get $tab.0))) + (drop (ref.cast null $t0 (global.get $tab.1))) + (drop (ref.cast null $t0 (global.get $tab.2))) + (drop (ref.cast null $t0 (global.get $tab.3))) + (drop (ref.cast null $t0 (global.get $tab.4))) - (drop (ref.cast_static $t0 (ref.null data))) - (drop (ref.cast_static $t1 (global.get $tab.1))) - (drop (ref.cast_static $t1 (global.get $tab.2))) + (drop (ref.cast null $t0 (ref.null data))) + (drop (ref.cast null $t1 (global.get $tab.1))) + (drop (ref.cast null $t1 (global.get $tab.2))) - (drop (ref.cast_static $t0 (ref.null data))) - (drop (ref.cast_static $t2 (global.get $tab.2))) + (drop (ref.cast null $t0 (ref.null data))) + (drop (ref.cast null $t2 (global.get $tab.2))) - (drop (ref.cast_static $t0 (ref.null data))) - (drop (ref.cast_static $t3 (global.get $tab.3))) + (drop (ref.cast null $t0 (ref.null data))) + (drop (ref.cast null $t3 (global.get $tab.3))) - (drop (ref.cast_static $t0 (ref.null data))) + (drop (ref.cast null $t0 (ref.null data))) ) (func (export "test-canon") (call $init) - (drop (ref.cast_static $t0 (global.get $tab.10))) - (drop (ref.cast_static $t0 (global.get $tab.11))) - (drop (ref.cast_static $t0 (global.get $tab.12))) + (drop (ref.cast null $t0 (global.get $tab.10))) + (drop (ref.cast null $t0 (global.get $tab.11))) + (drop (ref.cast null $t0 (global.get $tab.12))) - (drop (ref.cast_static $t1 (global.get $tab.11))) - (drop (ref.cast_static $t1 (global.get $tab.12))) + (drop (ref.cast null $t1 (global.get $tab.11))) + (drop (ref.cast null $t1 (global.get $tab.12))) - (drop (ref.cast_static $t2 (global.get $tab.12))) + (drop (ref.cast null $t2 (global.get $tab.12))) ) ) |