...

Text file src/github.com/tetratelabs/wazero/internal/integration_test/spectest/v1/testdata/int_exprs.wast

Documentation: github.com/tetratelabs/wazero/internal/integration_test/spectest/v1/testdata

     1;; Test interesting integer "expressions". These tests contain code
     2;; patterns which tempt common value-changing optimizations.
     3
     4;; Test that x+1<y+1 is not folded to x<y.
     5
     6(module
     7  (func (export "i32.no_fold_cmp_s_offset") (param $x i32) (param $y i32) (result i32)
     8    (i32.lt_s (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
     9  (func (export "i32.no_fold_cmp_u_offset") (param $x i32) (param $y i32) (result i32)
    10    (i32.lt_u (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
    11
    12  (func (export "i64.no_fold_cmp_s_offset") (param $x i64) (param $y i64) (result i32)
    13    (i64.lt_s (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
    14  (func (export "i64.no_fold_cmp_u_offset") (param $x i64) (param $y i64) (result i32)
    15    (i64.lt_u (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
    16)
    17
    18(assert_return (invoke "i32.no_fold_cmp_s_offset" (i32.const 0x7fffffff) (i32.const 0)) (i32.const 1))
    19(assert_return (invoke "i32.no_fold_cmp_u_offset" (i32.const 0xffffffff) (i32.const 0)) (i32.const 1))
    20(assert_return (invoke "i64.no_fold_cmp_s_offset" (i64.const 0x7fffffffffffffff) (i64.const 0)) (i32.const 1))
    21(assert_return (invoke "i64.no_fold_cmp_u_offset" (i64.const 0xffffffffffffffff) (i64.const 0)) (i32.const 1))
    22
    23;; Test that wrap(extend_s(x)) is not folded to x.
    24
    25(module
    26  (func (export "i64.no_fold_wrap_extend_s") (param $x i64) (result i64)
    27    (i64.extend_i32_s (i32.wrap_i64 (local.get $x))))
    28)
    29
    30(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
    31(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x00a0b0c0d0e0f0a0)) (i64.const 0xffffffffd0e0f0a0))
    32
    33;; Test that wrap(extend_u(x)) is not folded to x.
    34
    35(module
    36  (func (export "i64.no_fold_wrap_extend_u") (param $x i64) (result i64)
    37    (i64.extend_i32_u (i32.wrap_i64 (local.get $x))))
    38)
    39
    40(assert_return (invoke "i64.no_fold_wrap_extend_u" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
    41
    42;; Test that x<<n>>n is not folded to x.
    43
    44(module
    45  (func (export "i32.no_fold_shl_shr_s") (param $x i32) (result i32)
    46    (i32.shr_s (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
    47  (func (export "i32.no_fold_shl_shr_u") (param $x i32) (result i32)
    48    (i32.shr_u (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
    49
    50  (func (export "i64.no_fold_shl_shr_s") (param $x i64) (result i64)
    51    (i64.shr_s (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
    52  (func (export "i64.no_fold_shl_shr_u") (param $x i64) (result i64)
    53    (i64.shr_u (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
    54)
    55
    56(assert_return (invoke "i32.no_fold_shl_shr_s" (i32.const 0x80000000)) (i32.const 0))
    57(assert_return (invoke "i32.no_fold_shl_shr_u" (i32.const 0x80000000)) (i32.const 0))
    58(assert_return (invoke "i64.no_fold_shl_shr_s" (i64.const 0x8000000000000000)) (i64.const 0))
    59(assert_return (invoke "i64.no_fold_shl_shr_u" (i64.const 0x8000000000000000)) (i64.const 0))
    60
    61;; Test that x>>n<<n is not folded to x.
    62
    63(module
    64  (func (export "i32.no_fold_shr_s_shl") (param $x i32) (result i32)
    65    (i32.shl (i32.shr_s (local.get $x) (i32.const 1)) (i32.const 1)))
    66  (func (export "i32.no_fold_shr_u_shl") (param $x i32) (result i32)
    67    (i32.shl (i32.shr_u (local.get $x) (i32.const 1)) (i32.const 1)))
    68
    69  (func (export "i64.no_fold_shr_s_shl") (param $x i64) (result i64)
    70    (i64.shl (i64.shr_s (local.get $x) (i64.const 1)) (i64.const 1)))
    71  (func (export "i64.no_fold_shr_u_shl") (param $x i64) (result i64)
    72    (i64.shl (i64.shr_u (local.get $x) (i64.const 1)) (i64.const 1)))
    73)
    74
    75(assert_return (invoke "i32.no_fold_shr_s_shl" (i32.const 1)) (i32.const 0))
    76(assert_return (invoke "i32.no_fold_shr_u_shl" (i32.const 1)) (i32.const 0))
    77(assert_return (invoke "i64.no_fold_shr_s_shl" (i64.const 1)) (i64.const 0))
    78(assert_return (invoke "i64.no_fold_shr_u_shl" (i64.const 1)) (i64.const 0))
    79
    80;; Test that x/n*n is not folded to x.
    81
    82(module
    83  (func (export "i32.no_fold_div_s_mul") (param $x i32) (result i32)
    84    (i32.mul (i32.div_s (local.get $x) (i32.const 6)) (i32.const 6)))
    85  (func (export "i32.no_fold_div_u_mul") (param $x i32) (result i32)
    86    (i32.mul (i32.div_u (local.get $x) (i32.const 6)) (i32.const 6)))
    87
    88  (func (export "i64.no_fold_div_s_mul") (param $x i64) (result i64)
    89    (i64.mul (i64.div_s (local.get $x) (i64.const 6)) (i64.const 6)))
    90  (func (export "i64.no_fold_div_u_mul") (param $x i64) (result i64)
    91    (i64.mul (i64.div_u (local.get $x) (i64.const 6)) (i64.const 6)))
    92)
    93
    94(assert_return (invoke "i32.no_fold_div_s_mul" (i32.const 1)) (i32.const 0))
    95(assert_return (invoke "i32.no_fold_div_u_mul" (i32.const 1)) (i32.const 0))
    96(assert_return (invoke "i64.no_fold_div_s_mul" (i64.const 1)) (i64.const 0))
    97(assert_return (invoke "i64.no_fold_div_u_mul" (i64.const 1)) (i64.const 0))
    98
    99;; Test that x/x is not folded to 1.
   100
   101(module
   102  (func (export "i32.no_fold_div_s_self") (param $x i32) (result i32)
   103    (i32.div_s (local.get $x) (local.get $x)))
   104  (func (export "i32.no_fold_div_u_self") (param $x i32) (result i32)
   105    (i32.div_u (local.get $x) (local.get $x)))
   106
   107  (func (export "i64.no_fold_div_s_self") (param $x i64) (result i64)
   108    (i64.div_s (local.get $x) (local.get $x)))
   109  (func (export "i64.no_fold_div_u_self") (param $x i64) (result i64)
   110    (i64.div_u (local.get $x) (local.get $x)))
   111)
   112
   113(assert_trap (invoke "i32.no_fold_div_s_self" (i32.const 0)) "integer divide by zero")
   114(assert_trap (invoke "i32.no_fold_div_u_self" (i32.const 0)) "integer divide by zero")
   115(assert_trap (invoke "i64.no_fold_div_s_self" (i64.const 0)) "integer divide by zero")
   116(assert_trap (invoke "i64.no_fold_div_u_self" (i64.const 0)) "integer divide by zero")
   117
   118;; Test that x%x is not folded to 0.
   119
   120(module
   121  (func (export "i32.no_fold_rem_s_self") (param $x i32) (result i32)
   122    (i32.rem_s (local.get $x) (local.get $x)))
   123  (func (export "i32.no_fold_rem_u_self") (param $x i32) (result i32)
   124    (i32.rem_u (local.get $x) (local.get $x)))
   125
   126  (func (export "i64.no_fold_rem_s_self") (param $x i64) (result i64)
   127    (i64.rem_s (local.get $x) (local.get $x)))
   128  (func (export "i64.no_fold_rem_u_self") (param $x i64) (result i64)
   129    (i64.rem_u (local.get $x) (local.get $x)))
   130)
   131
   132(assert_trap (invoke "i32.no_fold_rem_s_self" (i32.const 0)) "integer divide by zero")
   133(assert_trap (invoke "i32.no_fold_rem_u_self" (i32.const 0)) "integer divide by zero")
   134(assert_trap (invoke "i64.no_fold_rem_s_self" (i64.const 0)) "integer divide by zero")
   135(assert_trap (invoke "i64.no_fold_rem_u_self" (i64.const 0)) "integer divide by zero")
   136
   137;; Test that x*n/n is not folded to x.
   138
   139(module
   140  (func (export "i32.no_fold_mul_div_s") (param $x i32) (result i32)
   141    (i32.div_s (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
   142  (func (export "i32.no_fold_mul_div_u") (param $x i32) (result i32)
   143    (i32.div_u (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
   144
   145  (func (export "i64.no_fold_mul_div_s") (param $x i64) (result i64)
   146    (i64.div_s (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
   147  (func (export "i64.no_fold_mul_div_u") (param $x i64) (result i64)
   148    (i64.div_u (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
   149)
   150
   151(assert_return (invoke "i32.no_fold_mul_div_s" (i32.const 0x80000000)) (i32.const 0))
   152(assert_return (invoke "i32.no_fold_mul_div_u" (i32.const 0x80000000)) (i32.const 0))
   153(assert_return (invoke "i64.no_fold_mul_div_s" (i64.const 0x8000000000000000)) (i64.const 0))
   154(assert_return (invoke "i64.no_fold_mul_div_u" (i64.const 0x8000000000000000)) (i64.const 0))
   155
   156;; Test that x/n where n is a known power of 2 is not folded to shr_s.
   157
   158(module
   159  (func (export "i32.no_fold_div_s_2") (param $x i32) (result i32)
   160    (i32.div_s (local.get $x) (i32.const 2)))
   161
   162  (func (export "i64.no_fold_div_s_2") (param $x i64) (result i64)
   163    (i64.div_s (local.get $x) (i64.const 2)))
   164)
   165
   166(assert_return (invoke "i32.no_fold_div_s_2" (i32.const -11)) (i32.const -5))
   167(assert_return (invoke "i64.no_fold_div_s_2" (i64.const -11)) (i64.const -5))
   168
   169;; Test that x%n where n is a known power of 2 is not folded to and.
   170
   171(module
   172  (func (export "i32.no_fold_rem_s_2") (param $x i32) (result i32)
   173    (i32.rem_s (local.get $x) (i32.const 2)))
   174
   175  (func (export "i64.no_fold_rem_s_2") (param $x i64) (result i64)
   176    (i64.rem_s (local.get $x) (i64.const 2)))
   177)
   178
   179(assert_return (invoke "i32.no_fold_rem_s_2" (i32.const -11)) (i32.const -1))
   180(assert_return (invoke "i64.no_fold_rem_s_2" (i64.const -11)) (i64.const -1))
   181
   182;; Test that x/0 works.
   183
   184(module
   185  (func (export "i32.div_s_0") (param $x i32) (result i32)
   186    (i32.div_s (local.get $x) (i32.const 0)))
   187  (func (export "i32.div_u_0") (param $x i32) (result i32)
   188    (i32.div_u (local.get $x) (i32.const 0)))
   189
   190  (func (export "i64.div_s_0") (param $x i64) (result i64)
   191    (i64.div_s (local.get $x) (i64.const 0)))
   192  (func (export "i64.div_u_0") (param $x i64) (result i64)
   193    (i64.div_u (local.get $x) (i64.const 0)))
   194)
   195
   196(assert_trap (invoke "i32.div_s_0" (i32.const 71)) "integer divide by zero")
   197(assert_trap (invoke "i32.div_u_0" (i32.const 71)) "integer divide by zero")
   198(assert_trap (invoke "i64.div_s_0" (i64.const 71)) "integer divide by zero")
   199(assert_trap (invoke "i64.div_u_0" (i64.const 71)) "integer divide by zero")
   200
   201;; Test that x/3 works.
   202
   203(module
   204  (func (export "i32.div_s_3") (param $x i32) (result i32)
   205    (i32.div_s (local.get $x) (i32.const 3)))
   206  (func (export "i32.div_u_3") (param $x i32) (result i32)
   207    (i32.div_u (local.get $x) (i32.const 3)))
   208
   209  (func (export "i64.div_s_3") (param $x i64) (result i64)
   210    (i64.div_s (local.get $x) (i64.const 3)))
   211  (func (export "i64.div_u_3") (param $x i64) (result i64)
   212    (i64.div_u (local.get $x) (i64.const 3)))
   213)
   214
   215(assert_return (invoke "i32.div_s_3" (i32.const 71)) (i32.const 23))
   216(assert_return (invoke "i32.div_s_3" (i32.const 0x60000000)) (i32.const 0x20000000))
   217(assert_return (invoke "i32.div_u_3" (i32.const 71)) (i32.const 23))
   218(assert_return (invoke "i32.div_u_3" (i32.const 0xc0000000)) (i32.const 0x40000000))
   219(assert_return (invoke "i64.div_s_3" (i64.const 71)) (i64.const 23))
   220(assert_return (invoke "i64.div_s_3" (i64.const 0x3000000000000000)) (i64.const 0x1000000000000000))
   221(assert_return (invoke "i64.div_u_3" (i64.const 71)) (i64.const 23))
   222(assert_return (invoke "i64.div_u_3" (i64.const 0xc000000000000000)) (i64.const 0x4000000000000000))
   223
   224;; Test that x/5 works.
   225
   226(module
   227  (func (export "i32.div_s_5") (param $x i32) (result i32)
   228    (i32.div_s (local.get $x) (i32.const 5)))
   229  (func (export "i32.div_u_5") (param $x i32) (result i32)
   230    (i32.div_u (local.get $x) (i32.const 5)))
   231
   232  (func (export "i64.div_s_5") (param $x i64) (result i64)
   233    (i64.div_s (local.get $x) (i64.const 5)))
   234  (func (export "i64.div_u_5") (param $x i64) (result i64)
   235    (i64.div_u (local.get $x) (i64.const 5)))
   236)
   237
   238(assert_return (invoke "i32.div_s_5" (i32.const 71)) (i32.const 14))
   239(assert_return (invoke "i32.div_s_5" (i32.const 0x50000000)) (i32.const 0x10000000))
   240(assert_return (invoke "i32.div_u_5" (i32.const 71)) (i32.const 14))
   241(assert_return (invoke "i32.div_u_5" (i32.const 0xa0000000)) (i32.const 0x20000000))
   242(assert_return (invoke "i64.div_s_5" (i64.const 71)) (i64.const 14))
   243(assert_return (invoke "i64.div_s_5" (i64.const 0x5000000000000000)) (i64.const 0x1000000000000000))
   244(assert_return (invoke "i64.div_u_5" (i64.const 71)) (i64.const 14))
   245(assert_return (invoke "i64.div_u_5" (i64.const 0xa000000000000000)) (i64.const 0x2000000000000000))
   246
   247;; Test that x/7 works.
   248
   249(module
   250  (func (export "i32.div_s_7") (param $x i32) (result i32)
   251    (i32.div_s (local.get $x) (i32.const 7)))
   252  (func (export "i32.div_u_7") (param $x i32) (result i32)
   253    (i32.div_u (local.get $x) (i32.const 7)))
   254
   255  (func (export "i64.div_s_7") (param $x i64) (result i64)
   256    (i64.div_s (local.get $x) (i64.const 7)))
   257  (func (export "i64.div_u_7") (param $x i64) (result i64)
   258    (i64.div_u (local.get $x) (i64.const 7)))
   259)
   260
   261(assert_return (invoke "i32.div_s_7" (i32.const 71)) (i32.const 10))
   262(assert_return (invoke "i32.div_s_7" (i32.const 0x70000000)) (i32.const 0x10000000))
   263(assert_return (invoke "i32.div_u_7" (i32.const 71)) (i32.const 10))
   264(assert_return (invoke "i32.div_u_7" (i32.const 0xe0000000)) (i32.const 0x20000000))
   265(assert_return (invoke "i64.div_s_7" (i64.const 71)) (i64.const 10))
   266(assert_return (invoke "i64.div_s_7" (i64.const 0x7000000000000000)) (i64.const 0x1000000000000000))
   267(assert_return (invoke "i64.div_u_7" (i64.const 71)) (i64.const 10))
   268(assert_return (invoke "i64.div_u_7" (i64.const 0xe000000000000000)) (i64.const 0x2000000000000000))
   269
   270;; Test that x%3 works.
   271
   272(module
   273  (func (export "i32.rem_s_3") (param $x i32) (result i32)
   274    (i32.rem_s (local.get $x) (i32.const 3)))
   275  (func (export "i32.rem_u_3") (param $x i32) (result i32)
   276    (i32.rem_u (local.get $x) (i32.const 3)))
   277
   278  (func (export "i64.rem_s_3") (param $x i64) (result i64)
   279    (i64.rem_s (local.get $x) (i64.const 3)))
   280  (func (export "i64.rem_u_3") (param $x i64) (result i64)
   281    (i64.rem_u (local.get $x) (i64.const 3)))
   282)
   283
   284(assert_return (invoke "i32.rem_s_3" (i32.const 71)) (i32.const 2))
   285(assert_return (invoke "i32.rem_s_3" (i32.const 0x60000000)) (i32.const 0))
   286(assert_return (invoke "i32.rem_u_3" (i32.const 71)) (i32.const 2))
   287(assert_return (invoke "i32.rem_u_3" (i32.const 0xc0000000)) (i32.const 0))
   288(assert_return (invoke "i64.rem_s_3" (i64.const 71)) (i64.const 2))
   289(assert_return (invoke "i64.rem_s_3" (i64.const 0x3000000000000000)) (i64.const 0))
   290(assert_return (invoke "i64.rem_u_3" (i64.const 71)) (i64.const 2))
   291(assert_return (invoke "i64.rem_u_3" (i64.const 0xc000000000000000)) (i64.const 0))
   292
   293;; Test that x%5 works.
   294
   295(module
   296  (func (export "i32.rem_s_5") (param $x i32) (result i32)
   297    (i32.rem_s (local.get $x) (i32.const 5)))
   298  (func (export "i32.rem_u_5") (param $x i32) (result i32)
   299    (i32.rem_u (local.get $x) (i32.const 5)))
   300
   301  (func (export "i64.rem_s_5") (param $x i64) (result i64)
   302    (i64.rem_s (local.get $x) (i64.const 5)))
   303  (func (export "i64.rem_u_5") (param $x i64) (result i64)
   304    (i64.rem_u (local.get $x) (i64.const 5)))
   305)
   306
   307(assert_return (invoke "i32.rem_s_5" (i32.const 71)) (i32.const 1))
   308(assert_return (invoke "i32.rem_s_5" (i32.const 0x50000000)) (i32.const 0))
   309(assert_return (invoke "i32.rem_u_5" (i32.const 71)) (i32.const 1))
   310(assert_return (invoke "i32.rem_u_5" (i32.const 0xa0000000)) (i32.const 0))
   311(assert_return (invoke "i64.rem_s_5" (i64.const 71)) (i64.const 1))
   312(assert_return (invoke "i64.rem_s_5" (i64.const 0x5000000000000000)) (i64.const 0))
   313(assert_return (invoke "i64.rem_u_5" (i64.const 71)) (i64.const 1))
   314(assert_return (invoke "i64.rem_u_5" (i64.const 0xa000000000000000)) (i64.const 0))
   315
   316;; Test that x%7 works.
   317
   318(module
   319  (func (export "i32.rem_s_7") (param $x i32) (result i32)
   320    (i32.rem_s (local.get $x) (i32.const 7)))
   321  (func (export "i32.rem_u_7") (param $x i32) (result i32)
   322    (i32.rem_u (local.get $x) (i32.const 7)))
   323
   324  (func (export "i64.rem_s_7") (param $x i64) (result i64)
   325    (i64.rem_s (local.get $x) (i64.const 7)))
   326  (func (export "i64.rem_u_7") (param $x i64) (result i64)
   327    (i64.rem_u (local.get $x) (i64.const 7)))
   328)
   329
   330(assert_return (invoke "i32.rem_s_7" (i32.const 71)) (i32.const 1))
   331(assert_return (invoke "i32.rem_s_7" (i32.const 0x70000000)) (i32.const 0))
   332(assert_return (invoke "i32.rem_u_7" (i32.const 71)) (i32.const 1))
   333(assert_return (invoke "i32.rem_u_7" (i32.const 0xe0000000)) (i32.const 0))
   334(assert_return (invoke "i64.rem_s_7" (i64.const 71)) (i64.const 1))
   335(assert_return (invoke "i64.rem_s_7" (i64.const 0x7000000000000000)) (i64.const 0))
   336(assert_return (invoke "i64.rem_u_7" (i64.const 71)) (i64.const 1))
   337(assert_return (invoke "i64.rem_u_7" (i64.const 0xe000000000000000)) (i64.const 0))
   338
   339;; Test that x/-1 is not folded to -x.
   340
   341(module
   342  (func (export "i32.no_fold_div_neg1") (param $x i32) (result i32)
   343    (i32.div_s (local.get $x) (i32.const -1)))
   344
   345  (func (export "i64.no_fold_div_neg1") (param $x i64) (result i64)
   346    (i64.div_s (local.get $x) (i64.const -1)))
   347)
   348
   349(assert_trap (invoke "i32.no_fold_div_neg1" (i32.const 0x80000000)) "integer overflow")
   350(assert_trap (invoke "i64.no_fold_div_neg1" (i64.const 0x8000000000000000)) "integer overflow")

View as plain text