ryan/libdpf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update googletest to 1.18.0 and SIMDe to 0.8.2.

Browse source 
Googletest 1.18 asks for CMake 3.13 or newer, so configuring the tests no longer warns that CMake compatibility below 3.10 is deprecated.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Ryan Henry 2026-09-24 14:30:19 -06:00
parent e4e666f459
commit 3f10e05176
912 changed files with 224964 additions and 11502 deletions
Download patch file Download diff file Expand all files Collapse all files

183
thirdparty/simde/test/wasm/relaxed-simd/fma.c vendored
View file

@ -1,183 +0,0 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN fma
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_fma(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 c[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 35.68), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -774.53) },
{ SIMDE_FLOAT32_C( 759.66), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -774.53) },
{ SIMDE_FLOAT32_C( 759.66), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -774.53) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C(599122.25) } },
#endif
{ { SIMDE_FLOAT32_C( 718.59), SIMDE_FLOAT32_C( -622.20), SIMDE_FLOAT32_C( -12.71), SIMDE_FLOAT32_C( 145.90) },
{ SIMDE_FLOAT32_C( 493.69), SIMDE_FLOAT32_C( -413.24), SIMDE_FLOAT32_C( -414.24), SIMDE_FLOAT32_C( 394.66) },
{ SIMDE_FLOAT32_C( 493.69), SIMDE_FLOAT32_C( -413.24), SIMDE_FLOAT32_C( -414.24), SIMDE_FLOAT32_C( 394.66) },
{ SIMDE_FLOAT32_C(244448.41), SIMDE_FLOAT32_C(170145.09), SIMDE_FLOAT32_C(171582.06), SIMDE_FLOAT32_C(155902.42) } },
{ { SIMDE_FLOAT32_C( 308.42), SIMDE_FLOAT32_C( 86.05), SIMDE_FLOAT32_C( 150.72), SIMDE_FLOAT32_C( -861.13) },
{ SIMDE_FLOAT32_C( -705.94), SIMDE_FLOAT32_C( 541.94), SIMDE_FLOAT32_C( -888.14), SIMDE_FLOAT32_C( 233.26) },
{ SIMDE_FLOAT32_C( -705.94), SIMDE_FLOAT32_C( 541.94), SIMDE_FLOAT32_C( -888.14), SIMDE_FLOAT32_C( 233.26) },
{ SIMDE_FLOAT32_C(498659.69), SIMDE_FLOAT32_C(293785.03), SIMDE_FLOAT32_C(788943.44), SIMDE_FLOAT32_C( 53549.10) } },
{ { SIMDE_FLOAT32_C( -756.83), SIMDE_FLOAT32_C( 995.47), SIMDE_FLOAT32_C( 603.58), SIMDE_FLOAT32_C( -894.80) },
{ SIMDE_FLOAT32_C( -794.79), SIMDE_FLOAT32_C( 27.52), SIMDE_FLOAT32_C( -472.09), SIMDE_FLOAT32_C( -978.18) },
{ SIMDE_FLOAT32_C( -794.79), SIMDE_FLOAT32_C( 27.52), SIMDE_FLOAT32_C( -472.09), SIMDE_FLOAT32_C( -978.18) },
{ SIMDE_FLOAT32_C(630934.31), SIMDE_FLOAT32_C( 1752.82), SIMDE_FLOAT32_C(223472.55), SIMDE_FLOAT32_C(955941.31) } },
{ { SIMDE_FLOAT32_C( -936.80), SIMDE_FLOAT32_C( -668.74), SIMDE_FLOAT32_C( 863.15), SIMDE_FLOAT32_C( 822.85) },
{ SIMDE_FLOAT32_C( 593.95), SIMDE_FLOAT32_C( 59.13), SIMDE_FLOAT32_C( 718.77), SIMDE_FLOAT32_C( 312.54) },
{ SIMDE_FLOAT32_C( 593.95), SIMDE_FLOAT32_C( 59.13), SIMDE_FLOAT32_C( 718.77), SIMDE_FLOAT32_C( 312.54) },
{ SIMDE_FLOAT32_C(351839.81), SIMDE_FLOAT32_C( 2827.62), SIMDE_FLOAT32_C(517493.50), SIMDE_FLOAT32_C( 98504.11) } },
{ { SIMDE_FLOAT32_C( 436.93), SIMDE_FLOAT32_C( -293.94), SIMDE_FLOAT32_C( -541.56), SIMDE_FLOAT32_C( -69.39) },
{ SIMDE_FLOAT32_C( 292.82), SIMDE_FLOAT32_C( 44.21), SIMDE_FLOAT32_C( -674.72), SIMDE_FLOAT32_C( -398.76) },
{ SIMDE_FLOAT32_C( 292.82), SIMDE_FLOAT32_C( 44.21), SIMDE_FLOAT32_C( -674.72), SIMDE_FLOAT32_C( -398.76) },
{ SIMDE_FLOAT32_C( 86180.48), SIMDE_FLOAT32_C( 1660.58), SIMDE_FLOAT32_C(454705.47), SIMDE_FLOAT32_C(158940.16) } },
{ { SIMDE_FLOAT32_C( -869.74), SIMDE_FLOAT32_C( 475.99), SIMDE_FLOAT32_C( -259.88), SIMDE_FLOAT32_C( -575.68) },
{ SIMDE_FLOAT32_C( 17.93), SIMDE_FLOAT32_C( -148.02), SIMDE_FLOAT32_C( 657.58), SIMDE_FLOAT32_C( 261.10) },
{ SIMDE_FLOAT32_C( 17.93), SIMDE_FLOAT32_C( -148.02), SIMDE_FLOAT32_C( 657.58), SIMDE_FLOAT32_C( 261.10) },
{ SIMDE_FLOAT32_C( -548.26), SIMDE_FLOAT32_C( 22385.91), SIMDE_FLOAT32_C(432151.59), SIMDE_FLOAT32_C( 67597.53) } },
{ { SIMDE_FLOAT32_C( -152.55), SIMDE_FLOAT32_C( 261.17), SIMDE_FLOAT32_C( 366.30), SIMDE_FLOAT32_C( 52.65) },
{ SIMDE_FLOAT32_C( -711.32), SIMDE_FLOAT32_C( 894.21), SIMDE_FLOAT32_C( 74.47), SIMDE_FLOAT32_C( -648.12) },
{ SIMDE_FLOAT32_C( -711.32), SIMDE_FLOAT32_C( 894.21), SIMDE_FLOAT32_C( 74.47), SIMDE_FLOAT32_C( -648.12) },
{ SIMDE_FLOAT32_C(505823.59), SIMDE_FLOAT32_C(799872.75), SIMDE_FLOAT32_C( 5912.08), SIMDE_FLOAT32_C(420112.19) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_fma(a, b, c);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
fputc('\n', stdout);
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_fma(a, b, c);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_fma(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 c[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( -621.40) },
{ SIMDE_FLOAT64_C( 52.22), SIMDE_MATH_NAN },
{ SIMDE_FLOAT64_C( 52.22), SIMDE_MATH_NAN },
{ SIMDE_MATH_NAN, SIMDE_MATH_NAN } },
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( -435.92) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 407.34) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 407.34) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C(165489.96) } },
#endif
{ { SIMDE_FLOAT64_C( -930.00), SIMDE_FLOAT64_C( -720.45) },
{ SIMDE_FLOAT64_C( 96.66), SIMDE_FLOAT64_C( 326.47) },
{ SIMDE_FLOAT64_C( 96.66), SIMDE_FLOAT64_C( 326.47) },
{ SIMDE_FLOAT64_C( 8413.16), SIMDE_FLOAT64_C(105862.21) } },
{ { SIMDE_FLOAT64_C( -52.84), SIMDE_FLOAT64_C( 875.57) },
{ SIMDE_FLOAT64_C( -832.42), SIMDE_FLOAT64_C( -266.54) },
{ SIMDE_FLOAT64_C( -832.42), SIMDE_FLOAT64_C( -266.54) },
{ SIMDE_FLOAT64_C(692870.22), SIMDE_FLOAT64_C( 71919.14) } },
{ { SIMDE_FLOAT64_C( 582.06), SIMDE_FLOAT64_C( 390.67) },
{ SIMDE_FLOAT64_C( 713.92), SIMDE_FLOAT64_C( -481.53) },
{ SIMDE_FLOAT64_C( 713.92), SIMDE_FLOAT64_C( -481.53) },
{ SIMDE_FLOAT64_C(510263.83), SIMDE_FLOAT64_C(232261.81) } },
{ { SIMDE_FLOAT64_C( 246.83), SIMDE_FLOAT64_C( -742.77) },
{ SIMDE_FLOAT64_C( 332.12), SIMDE_FLOAT64_C( -798.45) },
{ SIMDE_FLOAT64_C( 332.12), SIMDE_FLOAT64_C( -798.45) },
{ SIMDE_FLOAT64_C(110550.52), SIMDE_FLOAT64_C(636779.63) } },
{ { SIMDE_FLOAT64_C( 180.40), SIMDE_FLOAT64_C( -132.97) },
{ SIMDE_FLOAT64_C( 916.06), SIMDE_FLOAT64_C( 698.44) },
{ SIMDE_FLOAT64_C( 916.06), SIMDE_FLOAT64_C( 698.44) },
{ SIMDE_FLOAT64_C(839346.32), SIMDE_FLOAT64_C(487685.46) } },
{ { SIMDE_FLOAT64_C( -79.04), SIMDE_FLOAT64_C( 600.83) },
{ SIMDE_FLOAT64_C( -871.27), SIMDE_FLOAT64_C( 389.47) },
{ SIMDE_FLOAT64_C( -871.27), SIMDE_FLOAT64_C( 389.47) },
{ SIMDE_FLOAT64_C(759032.37), SIMDE_FLOAT64_C(152287.71) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].c);
simde_v128_t r = simde_wasm_f64x2_fma(a, b, c);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
fputc('\n', stdout);
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_fma(a, b, c);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_fma)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_fma)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

183
thirdparty/simde/test/wasm/relaxed-simd/fms.c vendored
View file

@ -1,183 +0,0 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN fms
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_fms(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 c[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -993.27), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 417.41) },
{ SIMDE_FLOAT32_C( -485.37), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 417.41) },
{ SIMDE_FLOAT32_C( -485.37), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 417.41) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C(-173813.70) } },
#endif
{ { SIMDE_FLOAT32_C( -135.40), SIMDE_FLOAT32_C( -44.03), SIMDE_FLOAT32_C( 309.21), SIMDE_FLOAT32_C( 776.94) },
{ SIMDE_FLOAT32_C( 285.44), SIMDE_FLOAT32_C( 449.56), SIMDE_FLOAT32_C( -32.12), SIMDE_FLOAT32_C( 455.56) },
{ SIMDE_FLOAT32_C( 285.44), SIMDE_FLOAT32_C( 449.56), SIMDE_FLOAT32_C( -32.12), SIMDE_FLOAT32_C( 455.56) },
{ SIMDE_FLOAT32_C(-81611.39), SIMDE_FLOAT32_C(-202148.22), SIMDE_FLOAT32_C( -722.48), SIMDE_FLOAT32_C(-206757.97) } },
{ { SIMDE_FLOAT32_C( -255.61), SIMDE_FLOAT32_C( -375.49), SIMDE_FLOAT32_C( -500.83), SIMDE_FLOAT32_C( -933.43) },
{ SIMDE_FLOAT32_C( 338.55), SIMDE_FLOAT32_C( -93.11), SIMDE_FLOAT32_C( 370.59), SIMDE_FLOAT32_C( -687.41) },
{ SIMDE_FLOAT32_C( 338.55), SIMDE_FLOAT32_C( -93.11), SIMDE_FLOAT32_C( 370.59), SIMDE_FLOAT32_C( -687.41) },
{ SIMDE_FLOAT32_C(-114871.70), SIMDE_FLOAT32_C( -9044.96), SIMDE_FLOAT32_C(-137837.78), SIMDE_FLOAT32_C(-473465.91) } },
{ { SIMDE_FLOAT32_C( 898.51), SIMDE_FLOAT32_C( 628.53), SIMDE_FLOAT32_C( 902.40), SIMDE_FLOAT32_C( 62.33) },
{ SIMDE_FLOAT32_C( -446.25), SIMDE_FLOAT32_C( 645.33), SIMDE_FLOAT32_C( -460.63), SIMDE_FLOAT32_C( 754.66) },
{ SIMDE_FLOAT32_C( -446.25), SIMDE_FLOAT32_C( 645.33), SIMDE_FLOAT32_C( -460.63), SIMDE_FLOAT32_C( 754.66) },
{ SIMDE_FLOAT32_C(-198240.55), SIMDE_FLOAT32_C(-415822.31), SIMDE_FLOAT32_C(-211277.59), SIMDE_FLOAT32_C(-569449.38) } },
{ { SIMDE_FLOAT32_C( 652.06), SIMDE_FLOAT32_C( 329.68), SIMDE_FLOAT32_C( -821.45), SIMDE_FLOAT32_C( -833.31) },
{ SIMDE_FLOAT32_C( -319.39), SIMDE_FLOAT32_C( 484.50), SIMDE_FLOAT32_C( 1.43), SIMDE_FLOAT32_C( 545.21) },
{ SIMDE_FLOAT32_C( -319.39), SIMDE_FLOAT32_C( 484.50), SIMDE_FLOAT32_C( 1.43), SIMDE_FLOAT32_C( 545.21) },
{ SIMDE_FLOAT32_C(-101357.92), SIMDE_FLOAT32_C(-234410.56), SIMDE_FLOAT32_C( -823.49), SIMDE_FLOAT32_C(-298087.28) } },
{ { SIMDE_FLOAT32_C( -559.53), SIMDE_FLOAT32_C( -689.36), SIMDE_FLOAT32_C( 322.15), SIMDE_FLOAT32_C( 725.90) },
{ SIMDE_FLOAT32_C( 760.20), SIMDE_FLOAT32_C( -709.97), SIMDE_FLOAT32_C( 181.46), SIMDE_FLOAT32_C( -495.41) },
{ SIMDE_FLOAT32_C( 760.20), SIMDE_FLOAT32_C( -709.97), SIMDE_FLOAT32_C( 181.46), SIMDE_FLOAT32_C( -495.41) },
{ SIMDE_FLOAT32_C(-578463.56), SIMDE_FLOAT32_C(-504746.72), SIMDE_FLOAT32_C(-32605.58), SIMDE_FLOAT32_C(-244705.17) } },
{ { SIMDE_FLOAT32_C( -85.45), SIMDE_FLOAT32_C( 680.63), SIMDE_FLOAT32_C( -428.83), SIMDE_FLOAT32_C( -746.90) },
{ SIMDE_FLOAT32_C( -412.48), SIMDE_FLOAT32_C( 941.76), SIMDE_FLOAT32_C( -434.31), SIMDE_FLOAT32_C( -513.97) },
{ SIMDE_FLOAT32_C( -412.48), SIMDE_FLOAT32_C( 941.76), SIMDE_FLOAT32_C( -434.31), SIMDE_FLOAT32_C( -513.97) },
{ SIMDE_FLOAT32_C(-170225.22), SIMDE_FLOAT32_C(-886231.31), SIMDE_FLOAT32_C(-189054.00), SIMDE_FLOAT32_C(-264912.03) } },
{ { SIMDE_FLOAT32_C( 570.28), SIMDE_FLOAT32_C( -531.92), SIMDE_FLOAT32_C( 548.36), SIMDE_FLOAT32_C( -875.96) },
{ SIMDE_FLOAT32_C( -886.59), SIMDE_FLOAT32_C( -912.27), SIMDE_FLOAT32_C( 878.70), SIMDE_FLOAT32_C( 765.47) },
{ SIMDE_FLOAT32_C( -886.59), SIMDE_FLOAT32_C( -912.27), SIMDE_FLOAT32_C( 878.70), SIMDE_FLOAT32_C( 765.47) },
{ SIMDE_FLOAT32_C(-785471.62), SIMDE_FLOAT32_C(-832768.50), SIMDE_FLOAT32_C(-771565.31), SIMDE_FLOAT32_C(-586820.19) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_fms(a, b, c);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
fputc('\n', stdout);
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_fms(a, b, c);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_fms(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 c[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 932.16) },
{ SIMDE_FLOAT64_C( -901.98), SIMDE_MATH_NAN },
{ SIMDE_FLOAT64_C( -901.98), SIMDE_MATH_NAN },
{ SIMDE_MATH_NAN, SIMDE_MATH_NAN } },
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 643.23) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 244.23) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 244.23) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C(-59005.06) } },
#endif
{ { SIMDE_FLOAT64_C( -34.62), SIMDE_FLOAT64_C( 708.12) },
{ SIMDE_FLOAT64_C( 4.43), SIMDE_FLOAT64_C( 255.42) },
{ SIMDE_FLOAT64_C( 4.43), SIMDE_FLOAT64_C( 255.42) },
{ SIMDE_FLOAT64_C( -54.24), SIMDE_FLOAT64_C(-64531.26) } },
{ { SIMDE_FLOAT64_C( -110.42), SIMDE_FLOAT64_C( 509.02) },
{ SIMDE_FLOAT64_C( -830.04), SIMDE_FLOAT64_C( -429.79) },
{ SIMDE_FLOAT64_C( -830.04), SIMDE_FLOAT64_C( -429.79) },
{ SIMDE_FLOAT64_C(-689076.82), SIMDE_FLOAT64_C(-184210.42) } },
{ { SIMDE_FLOAT64_C( -919.81), SIMDE_FLOAT64_C( -576.94) },
{ SIMDE_FLOAT64_C( 157.73), SIMDE_FLOAT64_C( -978.05) },
{ SIMDE_FLOAT64_C( 157.73), SIMDE_FLOAT64_C( -978.05) },
{ SIMDE_FLOAT64_C(-25798.56), SIMDE_FLOAT64_C(-957158.74) } },
{ { SIMDE_FLOAT64_C( -11.25), SIMDE_FLOAT64_C( 643.76) },
{ SIMDE_FLOAT64_C( 592.23), SIMDE_FLOAT64_C( 456.83) },
{ SIMDE_FLOAT64_C( 592.23), SIMDE_FLOAT64_C( 456.83) },
{ SIMDE_FLOAT64_C(-350747.62), SIMDE_FLOAT64_C(-208049.89) } },
{ { SIMDE_FLOAT64_C( 192.13), SIMDE_FLOAT64_C( 716.26) },
{ SIMDE_FLOAT64_C( 570.24), SIMDE_FLOAT64_C( 279.86) },
{ SIMDE_FLOAT64_C( 570.24), SIMDE_FLOAT64_C( 279.86) },
{ SIMDE_FLOAT64_C(-324981.53), SIMDE_FLOAT64_C(-77605.36) } },
{ { SIMDE_FLOAT64_C( 594.96), SIMDE_FLOAT64_C( 335.72) },
{ SIMDE_FLOAT64_C( -302.73), SIMDE_FLOAT64_C( 652.21) },
{ SIMDE_FLOAT64_C( -302.73), SIMDE_FLOAT64_C( 652.21) },
{ SIMDE_FLOAT64_C(-91050.49), SIMDE_FLOAT64_C(-425042.16) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].c);
simde_v128_t r = simde_wasm_f64x2_fms(a, b, c);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
fputc('\n', stdout);
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_fms(a, b, c);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_fms)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_fms)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

34
thirdparty/simde/test/wasm/relaxed-simd/blend.c → thirdparty/simde/test/wasm/relaxed-simd/laneselect.c vendored
View file

@ -21,12 +21,12 @@
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN blend
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN laneselect
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_i8x16_blend(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i8x16_relaxed_laneselect(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
int8_t a[sizeof(simde_v128_t) / sizeof(int8_t)];
@ -104,7 +104,7 @@ test_simde_wasm_i8x16_blend(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t mask = simde_wasm_v128_load(test_vec[i].mask);
simde_v128_t r = simde_wasm_i8x16_blend(a, b, mask);
simde_v128_t r = simde_wasm_i8x16_relaxed_laneselect(a, b, mask);
simde_test_wasm_i8x16_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -117,7 +117,7 @@ test_simde_wasm_i8x16_blend(SIMDE_MUNIT_TEST_ARGS) {
mask = simde_wasm_i8x16_shr(simde_test_wasm_i8x16_random(), 7),
r;
r = simde_wasm_i8x16_blend(a, b, mask);
r = simde_wasm_i8x16_relaxed_laneselect(a, b, mask);
simde_test_wasm_i8x16_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i8x16_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
@ -129,7 +129,7 @@ test_simde_wasm_i8x16_blend(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_i16x8_blend(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i16x8_relaxed_laneselect(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
int16_t a[sizeof(simde_v128_t) / sizeof(int16_t)];
@ -175,7 +175,7 @@ test_simde_wasm_i16x8_blend(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t mask = simde_wasm_v128_load(test_vec[i].mask);
simde_v128_t r = simde_wasm_i16x8_blend(a, b, mask);
simde_v128_t r = simde_wasm_i16x8_relaxed_laneselect(a, b, mask);
simde_test_wasm_i16x8_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -188,7 +188,7 @@ test_simde_wasm_i16x8_blend(SIMDE_MUNIT_TEST_ARGS) {
mask = simde_wasm_i16x8_shr(simde_test_wasm_i16x8_random(), 15),
r;
r = simde_wasm_i16x8_blend(a, b, mask);
r = simde_wasm_i16x8_relaxed_laneselect(a, b, mask);
simde_test_wasm_i16x8_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i16x8_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
@ -200,7 +200,7 @@ test_simde_wasm_i16x8_blend(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_i32x4_blend(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i32x4_relaxed_laneselect(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
int32_t a[sizeof(simde_v128_t) / sizeof(int32_t)];
@ -246,7 +246,7 @@ test_simde_wasm_i32x4_blend(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t mask = simde_wasm_v128_load(test_vec[i].mask);
simde_v128_t r = simde_wasm_i32x4_blend(a, b, mask);
simde_v128_t r = simde_wasm_i32x4_relaxed_laneselect(a, b, mask);
simde_test_wasm_i32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -259,7 +259,7 @@ test_simde_wasm_i32x4_blend(SIMDE_MUNIT_TEST_ARGS) {
mask = simde_wasm_i32x4_shr(simde_test_wasm_i32x4_random(), 31),
r;
r = simde_wasm_i32x4_blend(a, b, mask);
r = simde_wasm_i32x4_relaxed_laneselect(a, b, mask);
simde_test_wasm_i32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
@ -271,7 +271,7 @@ test_simde_wasm_i32x4_blend(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_i64x2_blend(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i64x2_relaxed_laneselect(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
int64_t a[sizeof(simde_v128_t) / sizeof(int64_t)];
@ -317,7 +317,7 @@ test_simde_wasm_i64x2_blend(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t mask = simde_wasm_v128_load(test_vec[i].mask);
simde_v128_t r = simde_wasm_i64x2_blend(a, b, mask);
simde_v128_t r = simde_wasm_i64x2_relaxed_laneselect(a, b, mask);
simde_test_wasm_i64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -330,7 +330,7 @@ test_simde_wasm_i64x2_blend(SIMDE_MUNIT_TEST_ARGS) {
mask = simde_wasm_i64x2_shr(simde_test_wasm_i64x2_random(), 63),
r;
r = simde_wasm_i64x2_blend(a, b, mask);
r = simde_wasm_i64x2_relaxed_laneselect(a, b, mask);
simde_test_wasm_i64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
@ -342,10 +342,10 @@ test_simde_wasm_i64x2_blend(SIMDE_MUNIT_TEST_ARGS) {
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_blend)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i16x8_blend)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_blend)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_blend)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_relaxed_laneselect)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i16x8_relaxed_laneselect)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_relaxed_laneselect)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_relaxed_laneselect)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

183
thirdparty/simde/test/wasm/relaxed-simd/madd.c vendored Normal file
View file

@ -0,0 +1,183 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN madd
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_relaxed_madd(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 c[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -939.85), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -336.73) },
{ SIMDE_FLOAT32_C( 40.12), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -336.73) },
{ SIMDE_FLOAT32_C( 40.12), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -336.73) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C(113050.37) } },
#endif
{ { SIMDE_FLOAT32_C( 279.46), SIMDE_FLOAT32_C( -892.17), SIMDE_FLOAT32_C( 472.79), SIMDE_FLOAT32_C( 28.20) },
{ SIMDE_FLOAT32_C( 553.33), SIMDE_FLOAT32_C( -43.23), SIMDE_FLOAT32_C( 213.29), SIMDE_FLOAT32_C( 976.59) },
{ SIMDE_FLOAT32_C( 553.33), SIMDE_FLOAT32_C( -43.23), SIMDE_FLOAT32_C( 213.29), SIMDE_FLOAT32_C( 976.59) },
{ SIMDE_FLOAT32_C(155186.94), SIMDE_FLOAT32_C( 38525.28), SIMDE_FLOAT32_C(101054.66), SIMDE_FLOAT32_C( 28516.43) } },
{ { SIMDE_FLOAT32_C( -199.25), SIMDE_FLOAT32_C( 569.13), SIMDE_FLOAT32_C( -283.83), SIMDE_FLOAT32_C( 765.16) },
{ SIMDE_FLOAT32_C( 566.57), SIMDE_FLOAT32_C( -354.03), SIMDE_FLOAT32_C( 136.16), SIMDE_FLOAT32_C( -900.31) },
{ SIMDE_FLOAT32_C( 566.57), SIMDE_FLOAT32_C( -354.03), SIMDE_FLOAT32_C( 136.16), SIMDE_FLOAT32_C( -900.31) },
{ SIMDE_FLOAT32_C(-112322.51), SIMDE_FLOAT32_C(-201843.12), SIMDE_FLOAT32_C(-38510.13), SIMDE_FLOAT32_C(-689781.50) } },
{ { SIMDE_FLOAT32_C( -487.28), SIMDE_FLOAT32_C( 960.14), SIMDE_FLOAT32_C( 549.78), SIMDE_FLOAT32_C( -162.66) },
{ SIMDE_FLOAT32_C( 999.49), SIMDE_FLOAT32_C( 808.42), SIMDE_FLOAT32_C( -550.69), SIMDE_FLOAT32_C( 755.10) },
{ SIMDE_FLOAT32_C( 999.49), SIMDE_FLOAT32_C( 808.42), SIMDE_FLOAT32_C( -550.69), SIMDE_FLOAT32_C( 755.10) },
{ SIMDE_FLOAT32_C(-486032.00), SIMDE_FLOAT32_C(777004.81), SIMDE_FLOAT32_C(-303309.06), SIMDE_FLOAT32_C(-122069.46) } },
{ { SIMDE_FLOAT32_C( 316.95), SIMDE_FLOAT32_C( 30.33), SIMDE_FLOAT32_C( 448.55), SIMDE_FLOAT32_C( -478.68) },
{ SIMDE_FLOAT32_C( -465.32), SIMDE_FLOAT32_C( -429.53), SIMDE_FLOAT32_C( 856.79), SIMDE_FLOAT32_C( -324.39) },
{ SIMDE_FLOAT32_C( -465.32), SIMDE_FLOAT32_C( -429.53), SIMDE_FLOAT32_C( 856.79), SIMDE_FLOAT32_C( -324.39) },
{ SIMDE_FLOAT32_C(-147948.50), SIMDE_FLOAT32_C(-13457.17), SIMDE_FLOAT32_C(385169.94), SIMDE_FLOAT32_C(154954.62) } },
{ { SIMDE_FLOAT32_C( -404.93), SIMDE_FLOAT32_C( -322.42), SIMDE_FLOAT32_C( 198.39), SIMDE_FLOAT32_C( -16.18) },
{ SIMDE_FLOAT32_C( -300.14), SIMDE_FLOAT32_C( 744.61), SIMDE_FLOAT32_C( 342.27), SIMDE_FLOAT32_C( -505.90) },
{ SIMDE_FLOAT32_C( -300.14), SIMDE_FLOAT32_C( 744.61), SIMDE_FLOAT32_C( 342.27), SIMDE_FLOAT32_C( -505.90) },
{ SIMDE_FLOAT32_C(121235.55), SIMDE_FLOAT32_C(-239332.55), SIMDE_FLOAT32_C( 68245.21), SIMDE_FLOAT32_C( 7679.56) } },
{ { SIMDE_FLOAT32_C( -560.16), SIMDE_FLOAT32_C( -586.90), SIMDE_FLOAT32_C( -54.15), SIMDE_FLOAT32_C( -277.30) },
{ SIMDE_FLOAT32_C( -912.30), SIMDE_FLOAT32_C( -170.24), SIMDE_FLOAT32_C( -166.55), SIMDE_FLOAT32_C( -308.02) },
{ SIMDE_FLOAT32_C( -912.30), SIMDE_FLOAT32_C( -170.24), SIMDE_FLOAT32_C( -166.55), SIMDE_FLOAT32_C( -308.02) },
{ SIMDE_FLOAT32_C(510121.62), SIMDE_FLOAT32_C( 99743.62), SIMDE_FLOAT32_C( 8852.13), SIMDE_FLOAT32_C( 85105.92) } },
{ { SIMDE_FLOAT32_C( 547.49), SIMDE_FLOAT32_C( -51.58), SIMDE_FLOAT32_C( -417.07), SIMDE_FLOAT32_C( -866.44) },
{ SIMDE_FLOAT32_C( 143.24), SIMDE_FLOAT32_C( 483.80), SIMDE_FLOAT32_C( -548.74), SIMDE_FLOAT32_C( -665.65) },
{ SIMDE_FLOAT32_C( 143.24), SIMDE_FLOAT32_C( 483.80), SIMDE_FLOAT32_C( -548.74), SIMDE_FLOAT32_C( -665.65) },
{ SIMDE_FLOAT32_C( 78565.71), SIMDE_FLOAT32_C(-24470.60), SIMDE_FLOAT32_C(228314.25), SIMDE_FLOAT32_C(576080.19) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_relaxed_madd(a, b, c);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
fputc('\n', stdout);
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_relaxed_madd(a, b, c);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_relaxed_madd(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 c[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 695.24) },
{ SIMDE_FLOAT64_C( -758.15), SIMDE_MATH_NAN },
{ SIMDE_FLOAT64_C( -758.15), SIMDE_MATH_NAN },
{ SIMDE_MATH_NAN, SIMDE_MATH_NAN } },
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( -844.22) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 363.37) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 363.37) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C(-306400.85) } },
#endif
{ { SIMDE_FLOAT64_C( 509.66), SIMDE_FLOAT64_C( -400.49) },
{ SIMDE_FLOAT64_C( 163.04), SIMDE_FLOAT64_C( -942.79) },
{ SIMDE_FLOAT64_C( 163.04), SIMDE_FLOAT64_C( -942.79) },
{ SIMDE_FLOAT64_C( 83258.01), SIMDE_FLOAT64_C(376635.18) } },
{ { SIMDE_FLOAT64_C( 604.83), SIMDE_FLOAT64_C( -31.05) },
{ SIMDE_FLOAT64_C( -523.11), SIMDE_FLOAT64_C( 762.22) },
{ SIMDE_FLOAT64_C( -523.11), SIMDE_FLOAT64_C( 762.22) },
{ SIMDE_FLOAT64_C(-316915.73), SIMDE_FLOAT64_C(-22904.71) } },
{ { SIMDE_FLOAT64_C( 387.14), SIMDE_FLOAT64_C( 293.35) },
{ SIMDE_FLOAT64_C( -114.01), SIMDE_FLOAT64_C( 60.86) },
{ SIMDE_FLOAT64_C( -114.01), SIMDE_FLOAT64_C( 60.86) },
{ SIMDE_FLOAT64_C(-44251.84), SIMDE_FLOAT64_C( 17914.14) } },
{ { SIMDE_FLOAT64_C( 711.99), SIMDE_FLOAT64_C( 494.07) },
{ SIMDE_FLOAT64_C( -456.08), SIMDE_FLOAT64_C( -781.46) },
{ SIMDE_FLOAT64_C( -456.08), SIMDE_FLOAT64_C( -781.46) },
{ SIMDE_FLOAT64_C(-325180.48), SIMDE_FLOAT64_C(-386877.40) } },
{ { SIMDE_FLOAT64_C( -231.37), SIMDE_FLOAT64_C( -589.48) },
{ SIMDE_FLOAT64_C( -349.94), SIMDE_FLOAT64_C( -420.17) },
{ SIMDE_FLOAT64_C( -349.94), SIMDE_FLOAT64_C( -420.17) },
{ SIMDE_FLOAT64_C( 80615.68), SIMDE_FLOAT64_C(247261.64) } },
{ { SIMDE_FLOAT64_C( -293.55), SIMDE_FLOAT64_C( 337.68) },
{ SIMDE_FLOAT64_C( -803.44), SIMDE_FLOAT64_C( -266.96) },
{ SIMDE_FLOAT64_C( -803.44), SIMDE_FLOAT64_C( -266.96) },
{ SIMDE_FLOAT64_C(235046.37), SIMDE_FLOAT64_C(-90414.01) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].c);
simde_v128_t r = simde_wasm_f64x2_relaxed_madd(a, b, c);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
fputc('\n', stdout);
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_relaxed_madd(a, b, c);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_relaxed_madd)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_relaxed_madd)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

146
thirdparty/simde/test/wasm/relaxed-simd/max.c vendored Normal file
View file

@ -0,0 +1,146 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN max
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_relaxed_max(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
{ { SIMDE_FLOAT32_C( -920.07), SIMDE_FLOAT32_C( 830.32), SIMDE_FLOAT32_C( -196.85), SIMDE_FLOAT32_C( 291.81) },
{ SIMDE_FLOAT32_C( -289.04), SIMDE_FLOAT32_C( 49.93), SIMDE_FLOAT32_C( -928.55), SIMDE_FLOAT32_C( 69.77) },
{ SIMDE_FLOAT32_C( -289.04), SIMDE_FLOAT32_C( 830.32), SIMDE_FLOAT32_C( -196.85), SIMDE_FLOAT32_C( 291.81) } },
{ { SIMDE_FLOAT32_C( -679.01), SIMDE_FLOAT32_C( 273.37), SIMDE_FLOAT32_C( -532.77), SIMDE_FLOAT32_C( 127.55) },
{ SIMDE_FLOAT32_C( 100.92), SIMDE_FLOAT32_C( -536.72), SIMDE_FLOAT32_C( -535.51), SIMDE_FLOAT32_C( -444.83) },
{ SIMDE_FLOAT32_C( 100.92), SIMDE_FLOAT32_C( 273.37), SIMDE_FLOAT32_C( -532.77), SIMDE_FLOAT32_C( 127.55) } },
{ { SIMDE_FLOAT32_C( -370.35), SIMDE_FLOAT32_C( 910.66), SIMDE_FLOAT32_C( -449.76), SIMDE_FLOAT32_C( 756.97) },
{ SIMDE_FLOAT32_C( -168.50), SIMDE_FLOAT32_C( 242.88), SIMDE_FLOAT32_C( -696.72), SIMDE_FLOAT32_C( 663.79) },
{ SIMDE_FLOAT32_C( -168.50), SIMDE_FLOAT32_C( 910.66), SIMDE_FLOAT32_C( -449.76), SIMDE_FLOAT32_C( 756.97) } },
{ { SIMDE_FLOAT32_C( -777.21), SIMDE_FLOAT32_C( -561.66), SIMDE_FLOAT32_C( 225.28), SIMDE_FLOAT32_C( 30.10) },
{ SIMDE_FLOAT32_C( -535.78), SIMDE_FLOAT32_C( -546.75), SIMDE_FLOAT32_C( 345.48), SIMDE_FLOAT32_C( 708.52) },
{ SIMDE_FLOAT32_C( -535.78), SIMDE_FLOAT32_C( -546.75), SIMDE_FLOAT32_C( 345.48), SIMDE_FLOAT32_C( 708.52) } },
{ { SIMDE_FLOAT32_C( 940.56), SIMDE_FLOAT32_C( 303.87), SIMDE_FLOAT32_C( 810.53), SIMDE_FLOAT32_C( -526.94) },
{ SIMDE_FLOAT32_C( 611.43), SIMDE_FLOAT32_C( 797.37), SIMDE_FLOAT32_C( 432.36), SIMDE_FLOAT32_C( 709.89) },
{ SIMDE_FLOAT32_C( 940.56), SIMDE_FLOAT32_C( 797.37), SIMDE_FLOAT32_C( 810.53), SIMDE_FLOAT32_C( 709.89) } },
{ { SIMDE_FLOAT32_C( -157.18), SIMDE_FLOAT32_C( -402.78), SIMDE_FLOAT32_C( -362.67), SIMDE_FLOAT32_C( -944.01) },
{ SIMDE_FLOAT32_C( 106.70), SIMDE_FLOAT32_C( -208.07), SIMDE_FLOAT32_C( 277.04), SIMDE_FLOAT32_C( 374.11) },
{ SIMDE_FLOAT32_C( 106.70), SIMDE_FLOAT32_C( -208.07), SIMDE_FLOAT32_C( 277.04), SIMDE_FLOAT32_C( 374.11) } },
{ { SIMDE_FLOAT32_C( -402.16), SIMDE_FLOAT32_C( 227.84), SIMDE_FLOAT32_C( -493.53), SIMDE_FLOAT32_C( 869.48) },
{ SIMDE_FLOAT32_C( 903.71), SIMDE_FLOAT32_C( -712.51), SIMDE_FLOAT32_C( -864.99), SIMDE_FLOAT32_C( -151.96) },
{ SIMDE_FLOAT32_C( 903.71), SIMDE_FLOAT32_C( 227.84), SIMDE_FLOAT32_C( -493.53), SIMDE_FLOAT32_C( 869.48) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_relaxed_max(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
fputc('\n', stdout);
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_relaxed_max(a, b);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_relaxed_max(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
{ { SIMDE_FLOAT64_C( 523.06), SIMDE_FLOAT64_C( -600.30) },
{ SIMDE_FLOAT64_C( 212.57), SIMDE_FLOAT64_C( -725.13) },
{ SIMDE_FLOAT64_C( 523.06), SIMDE_FLOAT64_C( -600.30) } },
{ { SIMDE_FLOAT64_C( 630.42), SIMDE_FLOAT64_C( -507.35) },
{ SIMDE_FLOAT64_C( 28.88), SIMDE_FLOAT64_C( -240.00) },
{ SIMDE_FLOAT64_C( 630.42), SIMDE_FLOAT64_C( -240.00) } },
{ { SIMDE_FLOAT64_C( 373.65), SIMDE_FLOAT64_C( 213.86) },
{ SIMDE_FLOAT64_C( -611.53), SIMDE_FLOAT64_C( 707.90) },
{ SIMDE_FLOAT64_C( 373.65), SIMDE_FLOAT64_C( 707.90) } },
{ { SIMDE_FLOAT64_C( 339.86), SIMDE_FLOAT64_C( -860.05) },
{ SIMDE_FLOAT64_C( 213.55), SIMDE_FLOAT64_C( -405.72) },
{ SIMDE_FLOAT64_C( 339.86), SIMDE_FLOAT64_C( -405.72) } },
{ { SIMDE_FLOAT64_C( -478.66), SIMDE_FLOAT64_C( -629.72) },
{ SIMDE_FLOAT64_C( 841.82), SIMDE_FLOAT64_C( 793.27) },
{ SIMDE_FLOAT64_C( 841.82), SIMDE_FLOAT64_C( 793.27) } },
{ { SIMDE_FLOAT64_C( -262.99), SIMDE_FLOAT64_C( 802.55) },
{ SIMDE_FLOAT64_C( -938.61), SIMDE_FLOAT64_C( 323.51) },
{ SIMDE_FLOAT64_C( -262.99), SIMDE_FLOAT64_C( 802.55) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_relaxed_max(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 3);
}
return 0;
#else
fputc('\n', stdout);
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_relaxed_max(a, b);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_relaxed_max)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_relaxed_max)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

10
thirdparty/simde/test/wasm/relaxed-simd/meson.build vendored
View file

@ -1,7 +1,9 @@
simde_test_wasm_relaxed_simd_tests = [
'blend',
'fma',
'fms',
'laneselect',
'madd',
'max',
'min',
'nmadd',
'swizzle',
'trunc',
]
@ -28,7 +30,7 @@ foreach name : simde_test_wasm_relaxed_simd_tests
include_directories: simde_include_dir,
dependencies: simde_deps)
test('wasm_relexad_simd/' + name + '/' + emul + '/' + lang, x,
test('wasm_relaxed_simd/' + name + '/' + emul + '/' + lang, x,
protocol: 'tap',
# Emscripten tests must be run from builddir
workdir: meson.current_build_dir())

146
thirdparty/simde/test/wasm/relaxed-simd/min.c vendored Normal file
View file

@ -0,0 +1,146 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN min
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_relaxed_min(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
{ { SIMDE_FLOAT32_C( -384.73), SIMDE_FLOAT32_C( -820.97), SIMDE_FLOAT32_C( 258.75), SIMDE_FLOAT32_C( -90.51) },
{ SIMDE_FLOAT32_C( 635.11), SIMDE_FLOAT32_C( -21.53), SIMDE_FLOAT32_C( -197.11), SIMDE_FLOAT32_C( 959.39) },
{ SIMDE_FLOAT32_C( -384.73), SIMDE_FLOAT32_C( -820.97), SIMDE_FLOAT32_C( -197.11), SIMDE_FLOAT32_C( -90.51) } },
{ { SIMDE_FLOAT32_C( 756.93), SIMDE_FLOAT32_C( -403.83), SIMDE_FLOAT32_C( -535.40), SIMDE_FLOAT32_C( 581.16) },
{ SIMDE_FLOAT32_C( 575.10), SIMDE_FLOAT32_C( -784.62), SIMDE_FLOAT32_C( 826.27), SIMDE_FLOAT32_C( -290.44) },
{ SIMDE_FLOAT32_C( 575.10), SIMDE_FLOAT32_C( -784.62), SIMDE_FLOAT32_C( -535.40), SIMDE_FLOAT32_C( -290.44) } },
{ { SIMDE_FLOAT32_C( -580.63), SIMDE_FLOAT32_C( 400.60), SIMDE_FLOAT32_C( -825.33), SIMDE_FLOAT32_C( 395.98) },
{ SIMDE_FLOAT32_C( 903.08), SIMDE_FLOAT32_C( 523.68), SIMDE_FLOAT32_C( -270.81), SIMDE_FLOAT32_C( -996.64) },
{ SIMDE_FLOAT32_C( -580.63), SIMDE_FLOAT32_C( 400.60), SIMDE_FLOAT32_C( -825.33), SIMDE_FLOAT32_C( -996.64) } },
{ { SIMDE_FLOAT32_C( -450.06), SIMDE_FLOAT32_C( -799.96), SIMDE_FLOAT32_C( 54.34), SIMDE_FLOAT32_C( 646.36) },
{ SIMDE_FLOAT32_C( -396.89), SIMDE_FLOAT32_C( -93.21), SIMDE_FLOAT32_C( -282.13), SIMDE_FLOAT32_C( -348.89) },
{ SIMDE_FLOAT32_C( -450.06), SIMDE_FLOAT32_C( -799.96), SIMDE_FLOAT32_C( -282.13), SIMDE_FLOAT32_C( -348.89) } },
{ { SIMDE_FLOAT32_C( 449.36), SIMDE_FLOAT32_C( -932.70), SIMDE_FLOAT32_C( 504.25), SIMDE_FLOAT32_C( 630.70) },
{ SIMDE_FLOAT32_C( 6.05), SIMDE_FLOAT32_C( 284.22), SIMDE_FLOAT32_C( -492.84), SIMDE_FLOAT32_C( -857.28) },
{ SIMDE_FLOAT32_C( 6.05), SIMDE_FLOAT32_C( -932.70), SIMDE_FLOAT32_C( -492.84), SIMDE_FLOAT32_C( -857.28) } },
{ { SIMDE_FLOAT32_C( -734.85), SIMDE_FLOAT32_C( 291.38), SIMDE_FLOAT32_C( 910.86), SIMDE_FLOAT32_C( -655.45) },
{ SIMDE_FLOAT32_C( 848.95), SIMDE_FLOAT32_C( -550.13), SIMDE_FLOAT32_C( 91.62), SIMDE_FLOAT32_C( 71.10) },
{ SIMDE_FLOAT32_C( -734.85), SIMDE_FLOAT32_C( -550.13), SIMDE_FLOAT32_C( 91.62), SIMDE_FLOAT32_C( -655.45) } },
{ { SIMDE_FLOAT32_C( 983.19), SIMDE_FLOAT32_C( 944.04), SIMDE_FLOAT32_C( -663.05), SIMDE_FLOAT32_C( 678.96) },
{ SIMDE_FLOAT32_C( -656.24), SIMDE_FLOAT32_C( -618.32), SIMDE_FLOAT32_C( 677.11), SIMDE_FLOAT32_C( -741.86) },
{ SIMDE_FLOAT32_C( -656.24), SIMDE_FLOAT32_C( -618.32), SIMDE_FLOAT32_C( -663.05), SIMDE_FLOAT32_C( -741.86) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_relaxed_min(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
fputc('\n', stdout);
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_relaxed_min(a, b);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_relaxed_min(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
{ { SIMDE_FLOAT64_C( -79.92), SIMDE_FLOAT64_C( 907.35) },
{ SIMDE_FLOAT64_C( -343.94), SIMDE_FLOAT64_C( 358.40) },
{ SIMDE_FLOAT64_C( -343.94), SIMDE_FLOAT64_C( 358.40) } },
{ { SIMDE_FLOAT64_C( 906.87), SIMDE_FLOAT64_C( 964.34) },
{ SIMDE_FLOAT64_C( 672.12), SIMDE_FLOAT64_C( 69.90) },
{ SIMDE_FLOAT64_C( 672.12), SIMDE_FLOAT64_C( 69.90) } },
{ { SIMDE_FLOAT64_C( 891.24), SIMDE_FLOAT64_C( 43.61) },
{ SIMDE_FLOAT64_C( 586.69), SIMDE_FLOAT64_C( 866.82) },
{ SIMDE_FLOAT64_C( 586.69), SIMDE_FLOAT64_C( 43.61) } },
{ { SIMDE_FLOAT64_C( 147.11), SIMDE_FLOAT64_C( -721.67) },
{ SIMDE_FLOAT64_C( 40.13), SIMDE_FLOAT64_C( 931.62) },
{ SIMDE_FLOAT64_C( 40.13), SIMDE_FLOAT64_C( -721.67) } },
{ { SIMDE_FLOAT64_C( 114.93), SIMDE_FLOAT64_C( -695.95) },
{ SIMDE_FLOAT64_C( -532.17), SIMDE_FLOAT64_C( -145.28) },
{ SIMDE_FLOAT64_C( -532.17), SIMDE_FLOAT64_C( -695.95) } },
{ { SIMDE_FLOAT64_C( 230.71), SIMDE_FLOAT64_C( -792.59) },
{ SIMDE_FLOAT64_C( 541.02), SIMDE_FLOAT64_C( 155.01) },
{ SIMDE_FLOAT64_C( 230.71), SIMDE_FLOAT64_C( -792.59) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_relaxed_min(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
fputc('\n', stdout);
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_relaxed_min(a, b);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_relaxed_min)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_relaxed_min)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

183
thirdparty/simde/test/wasm/relaxed-simd/nmadd.c vendored Normal file
View file

@ -0,0 +1,183 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_RELAXED_SIMD_INSN nmadd
#include "../../../simde/wasm/relaxed-simd.h"
#include "test-relaxed-simd.h"
static int
test_simde_wasm_f32x4_relaxed_nmadd(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 b[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 c[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 545.32), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 291.74) },
{ SIMDE_FLOAT32_C( -401.62), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 291.74) },
{ SIMDE_FLOAT32_C( -401.62), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 291.74) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C(-84820.48) } },
#endif
{ { SIMDE_FLOAT32_C( 173.47), SIMDE_FLOAT32_C( 46.49), SIMDE_FLOAT32_C( -845.82), SIMDE_FLOAT32_C( -7.33) },
{ SIMDE_FLOAT32_C( -984.71), SIMDE_FLOAT32_C( 707.30), SIMDE_FLOAT32_C( 807.44), SIMDE_FLOAT32_C( -705.38) },
{ SIMDE_FLOAT32_C( -984.71), SIMDE_FLOAT32_C( 707.30), SIMDE_FLOAT32_C( 807.44), SIMDE_FLOAT32_C( -705.38) },
{ SIMDE_FLOAT32_C(169832.94), SIMDE_FLOAT32_C(-32175.08), SIMDE_FLOAT32_C(683756.38), SIMDE_FLOAT32_C( -5875.82) } },
{ { SIMDE_FLOAT32_C( -897.96), SIMDE_FLOAT32_C( -320.99), SIMDE_FLOAT32_C( 222.19), SIMDE_FLOAT32_C( 329.67) },
{ SIMDE_FLOAT32_C( 480.55), SIMDE_FLOAT32_C( -189.47), SIMDE_FLOAT32_C( 641.89), SIMDE_FLOAT32_C( 962.95) },
{ SIMDE_FLOAT32_C( 480.55), SIMDE_FLOAT32_C( -189.47), SIMDE_FLOAT32_C( 641.89), SIMDE_FLOAT32_C( 962.95) },
{ SIMDE_FLOAT32_C(431995.22), SIMDE_FLOAT32_C(-61007.45), SIMDE_FLOAT32_C(-141979.66), SIMDE_FLOAT32_C(-316492.78) } },
{ { SIMDE_FLOAT32_C( 364.91), SIMDE_FLOAT32_C( -180.05), SIMDE_FLOAT32_C( 832.13), SIMDE_FLOAT32_C( 436.64) },
{ SIMDE_FLOAT32_C( -923.59), SIMDE_FLOAT32_C( -999.35), SIMDE_FLOAT32_C( -851.40), SIMDE_FLOAT32_C( 622.08) },
{ SIMDE_FLOAT32_C( -923.59), SIMDE_FLOAT32_C( -999.35), SIMDE_FLOAT32_C( -851.40), SIMDE_FLOAT32_C( 622.08) },
{ SIMDE_FLOAT32_C(336103.66), SIMDE_FLOAT32_C(-180932.31), SIMDE_FLOAT32_C(707624.12), SIMDE_FLOAT32_C(-271002.94) } },
{ { SIMDE_FLOAT32_C( -647.47), SIMDE_FLOAT32_C( -384.76), SIMDE_FLOAT32_C( 680.63), SIMDE_FLOAT32_C( 383.43) },
{ SIMDE_FLOAT32_C( -623.98), SIMDE_FLOAT32_C( -691.43), SIMDE_FLOAT32_C( -32.70), SIMDE_FLOAT32_C( -59.91) },
{ SIMDE_FLOAT32_C( -623.98), SIMDE_FLOAT32_C( -691.43), SIMDE_FLOAT32_C( -32.70), SIMDE_FLOAT32_C( -59.91) },
{ SIMDE_FLOAT32_C(-404632.28), SIMDE_FLOAT32_C(-266726.03), SIMDE_FLOAT32_C( 22223.90), SIMDE_FLOAT32_C( 22911.38) } },
{ { SIMDE_FLOAT32_C( 460.16), SIMDE_FLOAT32_C( 699.08), SIMDE_FLOAT32_C( 46.84), SIMDE_FLOAT32_C( -276.12) },
{ SIMDE_FLOAT32_C( 209.70), SIMDE_FLOAT32_C( 62.34), SIMDE_FLOAT32_C( -423.14), SIMDE_FLOAT32_C( -232.76) },
{ SIMDE_FLOAT32_C( 209.70), SIMDE_FLOAT32_C( 62.34), SIMDE_FLOAT32_C( -423.14), SIMDE_FLOAT32_C( -232.76) },
{ SIMDE_FLOAT32_C(-96285.85), SIMDE_FLOAT32_C(-43518.31), SIMDE_FLOAT32_C( 19396.74), SIMDE_FLOAT32_C(-64502.45) } },
{ { SIMDE_FLOAT32_C( -628.34), SIMDE_FLOAT32_C( 631.71), SIMDE_FLOAT32_C( 358.07), SIMDE_FLOAT32_C( -740.27) },
{ SIMDE_FLOAT32_C( -615.72), SIMDE_FLOAT32_C( 348.27), SIMDE_FLOAT32_C( 757.89), SIMDE_FLOAT32_C( -603.25) },
{ SIMDE_FLOAT32_C( -615.72), SIMDE_FLOAT32_C( 348.27), SIMDE_FLOAT32_C( 757.89), SIMDE_FLOAT32_C( -603.25) },
{ SIMDE_FLOAT32_C(-387497.22), SIMDE_FLOAT32_C(-219657.38), SIMDE_FLOAT32_C(-270619.78), SIMDE_FLOAT32_C(-447171.12) } },
{ { SIMDE_FLOAT32_C( -516.74), SIMDE_FLOAT32_C( -975.11), SIMDE_FLOAT32_C( -307.68), SIMDE_FLOAT32_C( 814.78) },
{ SIMDE_FLOAT32_C( -592.82), SIMDE_FLOAT32_C( 636.65), SIMDE_FLOAT32_C( -416.13), SIMDE_FLOAT32_C( -499.03) },
{ SIMDE_FLOAT32_C( -592.82), SIMDE_FLOAT32_C( 636.65), SIMDE_FLOAT32_C( -416.13), SIMDE_FLOAT32_C( -499.03) },
{ SIMDE_FLOAT32_C(-306926.62), SIMDE_FLOAT32_C(621440.44), SIMDE_FLOAT32_C(-128451.01), SIMDE_FLOAT32_C(406100.66) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_relaxed_nmadd(a, b, c);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
simde_float32 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float32))];
simde_test_wasm_f32x4_random_full(8, 2, inputs, -SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN | SIMDE_TEST_VEC_FLOAT_EQUAL));
fputc('\n', stdout);
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f32x4_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f32x4_relaxed_nmadd(a, b, c);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f32x4_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_relaxed_nmadd(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 b[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 c[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 947.03) },
{ SIMDE_FLOAT64_C( 46.26), SIMDE_MATH_NAN },
{ SIMDE_FLOAT64_C( 46.26), SIMDE_MATH_NAN },
{ SIMDE_MATH_NAN, SIMDE_MATH_NAN } },
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 395.95) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 410.70) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 410.70) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C(-162205.96) } },
#endif
{ { SIMDE_FLOAT64_C( -705.54), SIMDE_FLOAT64_C( 240.18) },
{ SIMDE_FLOAT64_C( 850.34), SIMDE_FLOAT64_C( -268.62) },
{ SIMDE_FLOAT64_C( 850.34), SIMDE_FLOAT64_C( -268.62) },
{ SIMDE_FLOAT64_C(600799.22), SIMDE_FLOAT64_C( 64248.53) } },
{ { SIMDE_FLOAT64_C( -540.18), SIMDE_FLOAT64_C( -439.41) },
{ SIMDE_FLOAT64_C( -815.99), SIMDE_FLOAT64_C( 725.32) },
{ SIMDE_FLOAT64_C( -815.99), SIMDE_FLOAT64_C( 725.32) },
{ SIMDE_FLOAT64_C(-441597.47), SIMDE_FLOAT64_C(319438.18) } },
{ { SIMDE_FLOAT64_C( -121.51), SIMDE_FLOAT64_C( -187.20) },
{ SIMDE_FLOAT64_C( 834.54), SIMDE_FLOAT64_C( 779.49) },
{ SIMDE_FLOAT64_C( 834.54), SIMDE_FLOAT64_C( 779.49) },
{ SIMDE_FLOAT64_C(102239.50), SIMDE_FLOAT64_C(146700.02) } },
{ { SIMDE_FLOAT64_C( -553.07), SIMDE_FLOAT64_C( -219.01) },
{ SIMDE_FLOAT64_C( -682.33), SIMDE_FLOAT64_C( -81.13) },
{ SIMDE_FLOAT64_C( -682.33), SIMDE_FLOAT64_C( -81.13) },
{ SIMDE_FLOAT64_C(-378058.58), SIMDE_FLOAT64_C(-17849.41) } },
{ { SIMDE_FLOAT64_C( 223.30), SIMDE_FLOAT64_C( 664.04) },
{ SIMDE_FLOAT64_C( -188.97), SIMDE_FLOAT64_C( 941.25) },
{ SIMDE_FLOAT64_C( -188.97), SIMDE_FLOAT64_C( 941.25) },
{ SIMDE_FLOAT64_C( 42008.03), SIMDE_FLOAT64_C(-624086.40) } },
{ { SIMDE_FLOAT64_C( -463.27), SIMDE_FLOAT64_C( 754.60) },
{ SIMDE_FLOAT64_C( 261.15), SIMDE_FLOAT64_C( -326.00) },
{ SIMDE_FLOAT64_C( 261.15), SIMDE_FLOAT64_C( -326.00) },
{ SIMDE_FLOAT64_C(121244.11), SIMDE_FLOAT64_C(245673.60) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t c = simde_wasm_v128_load(test_vec[i].c);
simde_v128_t r = simde_wasm_f64x2_relaxed_nmadd(a, b, c);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
}
return 0;
#else
simde_float64 inputs[8 * 2 * (sizeof(simde_v128_t) / sizeof(simde_float64))];
simde_test_wasm_f64x2_random_full(8, 2, inputs, -SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0), HEDLEY_STATIC_CAST(SimdeTestVecFloatType, SIMDE_TEST_VEC_FLOAT_NAN));
fputc('\n', stdout);
for (size_t i = 0 ; i < 8 ; i++) {
simde_v128_t
a = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 0),
b = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
c = simde_test_wasm_f64x2_random_full_extract(2, inputs, i, 1),
r;
r = simde_wasm_f64x2_relaxed_nmadd(a, b, c);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_f64x2_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, c, SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_wasm_f64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_relaxed_nmadd)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_relaxed_nmadd)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

8
thirdparty/simde/test/wasm/relaxed-simd/swizzle.c vendored
View file

@ -26,7 +26,7 @@
#include "test-relaxed-simd.h"
static int
test_simde_wasm_i8x16_swizzle_relaxed(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i8x16_relaxed_swizzle(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
int8_t a[sizeof(simde_v128_t) / sizeof(int8_t)];
@ -86,7 +86,7 @@ test_simde_wasm_i8x16_swizzle_relaxed(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_i8x16_swizzle_relaxed(a, b);
simde_v128_t r = simde_wasm_i8x16_relaxed_swizzle(a, b);
simde_test_wasm_i8x16_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -98,7 +98,7 @@ test_simde_wasm_i8x16_swizzle_relaxed(SIMDE_MUNIT_TEST_ARGS) {
b = simde_wasm_v128_and(simde_test_wasm_i8x16_random(), simde_wasm_i8x16_splat(15)),
r;
r = simde_wasm_i8x16_swizzle_relaxed(a, b);
r = simde_wasm_i8x16_relaxed_swizzle(a, b);
simde_test_wasm_i8x16_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i8x16_write(3, b, SIMDE_TEST_VEC_POS_MIDDLE);
@ -109,7 +109,7 @@ test_simde_wasm_i8x16_swizzle_relaxed(SIMDE_MUNIT_TEST_ARGS) {
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_swizzle_relaxed)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_relaxed_swizzle)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

32
thirdparty/simde/test/wasm/relaxed-simd/trunc.c vendored
View file

@ -26,7 +26,7 @@
#include "test-relaxed-simd.h"
static int
test_simde_wasm_i32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i32x4_relaxed_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
@ -52,7 +52,7 @@ test_simde_wasm_i32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_i32x4_trunc_f32x4(a);
simde_v128_t r = simde_wasm_i32x4_relaxed_trunc_f32x4(a);
simde_test_wasm_i32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -63,7 +63,7 @@ test_simde_wasm_i32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
a = simde_test_wasm_f32x4_random(HEDLEY_STATIC_CAST(simde_float32, INT32_MIN), HEDLEY_STATIC_CAST(simde_float32, INT32_MAX)),
r;
r = simde_wasm_i32x4_trunc_f32x4(a);
r = simde_wasm_i32x4_relaxed_trunc_f32x4(a);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
@ -73,7 +73,7 @@ test_simde_wasm_i32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_u32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_u32x4_relaxed_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
@ -99,7 +99,7 @@ test_simde_wasm_u32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_u32x4_trunc_f32x4(a);
simde_v128_t r = simde_wasm_u32x4_relaxed_trunc_f32x4(a);
simde_test_wasm_u32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -110,7 +110,7 @@ test_simde_wasm_u32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
a = simde_test_wasm_f32x4_random(SIMDE_FLOAT32_C(0.0), HEDLEY_STATIC_CAST(simde_float32, UINT32_MAX)),
r;
r = simde_wasm_u32x4_trunc_f32x4(a);
r = simde_wasm_u32x4_relaxed_trunc_f32x4(a);
simde_test_wasm_f32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
@ -120,7 +120,7 @@ test_simde_wasm_u32x4_trunc_f32x4(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_i32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_i32x4_relaxed_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
@ -146,7 +146,7 @@ test_simde_wasm_i32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_i32x4_trunc_f64x2_zero(a);
simde_v128_t r = simde_wasm_i32x4_relaxed_trunc_f64x2_zero(a);
simde_test_wasm_i32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -157,7 +157,7 @@ test_simde_wasm_i32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
a = simde_test_wasm_f64x2_random(HEDLEY_STATIC_CAST(simde_float64, INT32_MIN), HEDLEY_STATIC_CAST(simde_float64, INT32_MAX)),
r;
r = simde_wasm_i32x4_trunc_f64x2_zero(a);
r = simde_wasm_i32x4_relaxed_trunc_f64x2_zero(a);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_i32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
@ -167,7 +167,7 @@ test_simde_wasm_i32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
}
static int
test_simde_wasm_u32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
test_simde_wasm_u32x4_relaxed_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
@ -193,7 +193,7 @@ test_simde_wasm_u32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_u32x4_trunc_f64x2_zero(a);
simde_v128_t r = simde_wasm_u32x4_relaxed_trunc_f64x2_zero(a);
simde_test_wasm_u32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
@ -204,7 +204,7 @@ test_simde_wasm_u32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
a = simde_test_wasm_f64x2_random(SIMDE_FLOAT64_C(0.0), HEDLEY_STATIC_CAST(simde_float64, UINT32_MAX)),
r;
r = simde_wasm_u32x4_trunc_f64x2_zero(a);
r = simde_wasm_u32x4_relaxed_trunc_f64x2_zero(a);
simde_test_wasm_f64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
@ -214,10 +214,10 @@ test_simde_wasm_u32x4_trunc_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_trunc_f32x4)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_trunc_f32x4)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_trunc_f64x2_zero)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_trunc_f64x2_zero)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_relaxed_trunc_f32x4)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_relaxed_trunc_f32x4)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_relaxed_trunc_f64x2_zero)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_relaxed_trunc_f64x2_zero)
SIMDE_TEST_FUNC_LIST_END
#include "test-relaxed-simd-footer.h"

12
thirdparty/simde/test/wasm/simd128/abs.c vendored
View file

@ -259,7 +259,11 @@ test_simde_wasm_f32x4_abs(SIMDE_MUNIT_TEST_ARGS) {
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
simde_float32 r[sizeof(simde_v128_t) / sizeof(simde_float32)];
} test_vec[8] = {
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00) },
{ SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00) } },
#endif
{ { SIMDE_FLOAT32_C( 394.19), SIMDE_FLOAT32_C( -636.32), SIMDE_FLOAT32_C( -182.62), SIMDE_FLOAT32_C( 658.49) },
{ SIMDE_FLOAT32_C( 394.19), SIMDE_FLOAT32_C( 636.32), SIMDE_FLOAT32_C( 182.62), SIMDE_FLOAT32_C( 658.49) } },
{ { SIMDE_FLOAT32_C( 649.33), SIMDE_FLOAT32_C( 338.36), SIMDE_FLOAT32_C( 58.28), SIMDE_FLOAT32_C( 54.16) },
@ -305,7 +309,11 @@ test_simde_wasm_f64x2_abs(SIMDE_MUNIT_TEST_ARGS) {
SIMDE_TEST_STRUCT_MODIFIERS struct {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
simde_float64 r[sizeof(simde_v128_t) / sizeof(simde_float64)];
} test_vec[8] = {
} test_vec[] = {
#if !defined(SIMDE_FAST_MATH)
{ { SIMDE_FLOAT64_C( -0.00), SIMDE_FLOAT64_C( -0.00) },
{ SIMDE_FLOAT64_C( 0.00), SIMDE_FLOAT64_C( 0.00) } },
#endif
{ { SIMDE_FLOAT64_C( 658.91), SIMDE_FLOAT64_C( -816.22) },
{ SIMDE_FLOAT64_C( 658.91), SIMDE_FLOAT64_C( 816.22) } },
{ { SIMDE_FLOAT64_C( -765.26), SIMDE_FLOAT64_C( 308.24) },

614
thirdparty/simde/test/wasm/simd128/const.c vendored Normal file
View file

@ -0,0 +1,614 @@
/* Copyright (c) 2023 Michael R. Crusoe <crusoe@debian.org>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define SIMDE_TEST_WASM_SIMD128_INSN make_const
#include "../../../simde/wasm/simd128.h"
#include "test-simd128.h"
static int
test_simde_wasm_i8x16_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS int8_t test_vec[8][sizeof(simde_v128_t) / sizeof(int8_t)] = {
{ INT8_C( 81), -INT8_C( 79), INT8_C( 36), INT8_C( 93), -INT8_C( 88), INT8_C( 37), -INT8_C( 56), INT8_C( 87),
-INT8_C( 55), -INT8_C( 94), -INT8_C( 99), -INT8_C( 86), -INT8_C( 70), INT8_C( 96), -INT8_C( 104), -INT8_C( 71) },
{ INT8_C( 61), -INT8_C( 127), INT8_C( 123), -INT8_C( 73), INT8_C( 11), -INT8_C( 54), -INT8_C( 123), -INT8_C( 37),
-INT8_C( 101), -INT8_C( 111), -INT8_C( 29), INT8_C( 68), -INT8_C( 35), -INT8_C( 78), -INT8_C( 4), -INT8_C( 107) },
{ INT8_C( 81), INT8_C( 68), -INT8_C( 58), INT8_C( 28), -INT8_C( 44), -INT8_C( 20), -INT8_C( 12), -INT8_C( 16),
-INT8_C( 109), -INT8_C( 1), INT8_C( 3), -INT8_C( 63), -INT8_C( 41), -INT8_C( 64), -INT8_C( 83), INT8_C( 71) },
{ INT8_C( 1), INT8_C( 93), INT8_C( 67), -INT8_C( 46), -INT8_C( 4), -INT8_C( 13), INT8_C( 77), -INT8_C( 125),
INT8_C( 94), -INT8_C( 114), -INT8_C( 22), INT8_C( 50), INT8_C( 83), -INT8_C( 15), INT8_C( 91), INT8_C( 111) },
{ INT8_C( 75), INT8_C( 93), -INT8_C( 60), -INT8_C( 56), -INT8_C( 69), INT8_C( 24), -INT8_C( 119), -INT8_C( 26),
INT8_C( 114), INT8_C( 63), -INT8_C( 86), -INT8_C( 109), INT8_C( 102), -INT8_C( 12), -INT8_C( 114), -INT8_C( 115) },
{ -INT8_C( 29), -INT8_C( 60), INT8_C( 121), -INT8_C( 58), -INT8_C( 24), INT8_C( 47), INT8_C( 80), -INT8_C( 83),
-INT8_C( 55), INT8_C( 113), INT8_C( 83), INT8_C( 73), INT8_C( 61), -INT8_C( 70), -INT8_C( 52), -INT8_C( 101) },
{ -INT8_C( 17), INT8_C( 45), INT8_C( 71), INT8_C( 35), INT8_C( 92), -INT8_C( 76), -INT8_C( 58), -INT8_C( 13),
INT8_C( 2), INT8_C( 10), INT8_C( 29), -INT8_C( 16), -INT8_C( 117), INT8_C( 104), INT8_C( 112), -INT8_C( 27) },
{ -INT8_C( 41), INT8_C( 76), INT8_C( 31), -INT8_C( 116), -INT8_C( 57), -INT8_C( 118), -INT8_C( 59), -INT8_C( 109),
INT8_C( 71), INT8_C( 57), INT8_C( 83), -INT8_C( 7), INT8_C( 41), -INT8_C( 42), -INT8_C( 96), INT8_C( 126) },
};
simde_v128_t a;
a = simde_wasm_i8x16_const( 81, -79, 36, 93, -88, 37, -56, 87, -55, -94, -99, -86, -70, 96, -104, -71);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_i8x16_const( 61, -127, 123, -73, 11, -54, -123, -37, -101, -111, -29, 68, -35, -78, -4, -107);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_i8x16_const( 81, 68, -58, 28, -44, -20, -12, -16, -109, -1, 3, -63, -41, -64, -83, 71);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_i8x16_const( 1, 93, 67, -46, -4, -13, 77, -125, 94, -114, -22, 50, 83, -15, 91, 111);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_i8x16_const( 75, 93, -60, -56, -69, 24, -119, -26, 114, 63, -86, -109, 102, -12, -114, -115);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_i8x16_const( -29, -60, 121, -58, -24, 47, 80, -83, -55, 113, 83, 73, 61, -70, -52, -101);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_i8x16_const( -17, 45, 71, 35, 92, -76, -58, -13, 2, 10, 29, -16, -117, 104, 112, -27);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_i8x16_const( -41, 76, 31, -116, -57, -118, -59, -109, 71, 57, 83, -7, 41, -42, -96, 126);
simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
int8_t a[sizeof(simde_v128_t) / sizeof(int8_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_i8x16_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_i8x16_const(%4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ", %4" PRId8 ");\n",
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_i8x16_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_i8x16_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_u8x16_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS uint8_t test_vec[8][sizeof(simde_v128_t) / sizeof(int8_t)] = {
{ UINT8_C(227), UINT8_C(134), UINT8_C(206), UINT8_C(114), UINT8_C( 70), UINT8_C(113), UINT8_C(173), UINT8_C(251),
UINT8_C( 1), UINT8_C( 67), UINT8_C(230), UINT8_C( 63), UINT8_C(170), UINT8_C(205), UINT8_C(172), UINT8_C( 12) },
{ UINT8_C(155), UINT8_C( 47), UINT8_C( 91), UINT8_C(105), UINT8_C(130), UINT8_C( 10), UINT8_C( 37), UINT8_C( 61),
UINT8_C( 69), UINT8_C(164), UINT8_C(161), UINT8_C(105), UINT8_C( 64), UINT8_C(139), UINT8_C( 53), UINT8_C( 76) },
{ UINT8_C(186), UINT8_C(210), UINT8_C(231), UINT8_C(106), UINT8_C(129), UINT8_C(175), UINT8_C( 47), UINT8_C( 98),
UINT8_C(188), UINT8_C(254), UINT8_C(168), UINT8_C( 76), UINT8_C( 58), UINT8_C(192), UINT8_C( 0), UINT8_C(152) },
{ UINT8_C(125), UINT8_C( 41), UINT8_C( 12), UINT8_C( 63), UINT8_C(160), UINT8_C(155), UINT8_C(108), UINT8_C( 60),
UINT8_C(111), UINT8_C(220), UINT8_C( 92), UINT8_C( 14), UINT8_C( 35), UINT8_C( 92), UINT8_C( 90), UINT8_C( 15) },
{ UINT8_C( 62), UINT8_C(246), UINT8_C(185), UINT8_C(141), UINT8_C(169), UINT8_C(186), UINT8_C( 56), UINT8_C( 41),
UINT8_C(176), UINT8_C(223), UINT8_C(243), UINT8_C(252), UINT8_C( 53), UINT8_C( 26), UINT8_C( 92), UINT8_C(123) },
{ UINT8_C(210), UINT8_C(233), UINT8_C(134), UINT8_C(151), UINT8_C(214), UINT8_C(201), UINT8_C( 81), UINT8_C( 90),
UINT8_C(249), UINT8_C(231), UINT8_C( 97), UINT8_C(219), UINT8_C(205), UINT8_C( 35), UINT8_C(145), UINT8_C(212) },
{ UINT8_C(199), UINT8_C(127), UINT8_C( 24), UINT8_C(128), UINT8_C(146), UINT8_C(216), UINT8_C(105), UINT8_C(237),
UINT8_C(105), UINT8_C( 19), UINT8_C( 22), UINT8_C(116), UINT8_C( 88), UINT8_C(209), UINT8_C( 81), UINT8_C( 84) },
{ UINT8_C( 8), UINT8_C(115), UINT8_C( 13), UINT8_C(132), UINT8_C(126), UINT8_C(176), UINT8_C( 34), UINT8_C( 93),
UINT8_C(101), UINT8_C(253), UINT8_C( 1), UINT8_C(217), UINT8_C( 75), UINT8_C( 30), UINT8_C( 71), UINT8_C(161) }
};
simde_v128_t a;
a = simde_wasm_u8x16_const( 227, 134, 206, 114, 70, 113, 173, 251, 1, 67, 230, 63, 170, 205, 172, 12);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_u8x16_const( 155, 47, 91, 105, 130, 10, 37, 61, 69, 164, 161, 105, 64, 139, 53, 76);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_u8x16_const( 186, 210, 231, 106, 129, 175, 47, 98, 188, 254, 168, 76, 58, 192, 0, 152);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_u8x16_const( 125, 41, 12, 63, 160, 155, 108, 60, 111, 220, 92, 14, 35, 92, 90, 15);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_u8x16_const( 62, 246, 185, 141, 169, 186, 56, 41, 176, 223, 243, 252, 53, 26, 92, 123);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_u8x16_const( 210, 233, 134, 151, 214, 201, 81, 90, 249, 231, 97, 219, 205, 35, 145, 212);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_u8x16_const( 199, 127, 24, 128, 146, 216, 105, 237, 105, 19, 22, 116, 88, 209, 81, 84);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_u8x16_const( 8, 115, 13, 132, 126, 176, 34, 93, 101, 253, 1, 217, 75, 30, 71, 161);
simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint8_t a[sizeof(simde_v128_t) / sizeof(uint8_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_u8x16_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_u8x16_const(%4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ", %4" PRIu8 ");\n",
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_u8x16_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_u8x16_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_i16x8_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS int16_t test_vec[8][sizeof(simde_v128_t) / sizeof(int16_t)] = {
{ INT16_C( 9810), -INT16_C( 23557), -INT16_C( 22740), -INT16_C( 14337), -INT16_C( 17462), -INT16_C( 9114), INT16_C( 11912), -INT16_C( 28507) },
{ -INT16_C( 24562), INT16_C( 17406), INT16_C( 20254), -INT16_C( 31299), INT16_C( 11086), INT16_C( 14081), -INT16_C( 28208), -INT16_C( 1144) },
{ -INT16_C( 31477), INT16_C( 19024), -INT16_C( 28800), -INT16_C( 23139), INT16_C( 624), -INT16_C( 1802), -INT16_C( 27223), INT16_C( 11270) },
{ -INT16_C( 25711), INT16_C( 10867), -INT16_C( 21730), -INT16_C( 21219), INT16_C( 9615), -INT16_C( 27373), INT16_C( 21320), INT16_C( 26223) },
{ INT16_C( 21332), INT16_C( 27493), -INT16_C( 23519), INT16_C( 14492), -INT16_C( 16485), INT16_C( 15321), -INT16_C( 11530), -INT16_C( 2248) },
{ -INT16_C( 10298), INT16_C( 7779), -INT16_C( 31235), -INT16_C( 4243), -INT16_C( 22040), -INT16_C( 10022), -INT16_C( 10124), INT16_C( 27669) },
{ INT16_C( 8521), -INT16_C( 10818), INT16_C( 5928), INT16_C( 20442), -INT16_C( 29801), INT16_C( 21983), -INT16_C( 7718), INT16_C( 21700) },
{ -INT16_C( 28234), -INT16_C( 31685), INT16_C( 31242), -INT16_C( 13678), INT16_C( 21288), -INT16_C( 31900), -INT16_C( 18309), INT16_C( 7424) }
};
simde_v128_t a;
a = simde_wasm_i16x8_const(9810, -23557, -22740, -14337, -17462, -9114, 11912, -28507);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_i16x8_const(-24562, 17406, 20254, -31299, 11086, 14081, -28208, -1144);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_i16x8_const(-31477, 19024, -28800, -23139, 624, -1802, -27223, 11270);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_i16x8_const(-25711, 10867, -21730, -21219, 9615, -27373, 21320, 26223);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_i16x8_const(21332, 27493, -23519, 14492, -16485, 15321, -11530, -2248);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_i16x8_const(-10298, 7779, -31235, -4243, -22040, -10022, -10124, 27669);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_i16x8_const(8521, -10818, 5928, 20442, -29801, 21983, -7718, 21700);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_i16x8_const(-28234, -31685, 31242, -13678, 21288, -31900, -18309, 7424);
simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
int16_t a[sizeof(simde_v128_t) / sizeof(int16_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_i16x8_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_i16x8_const(%4" PRId16 ", %4" PRId16 ", %4" PRId16 ", %4" PRId16 ", %4" PRId16 ", %4" PRId16 ", %4" PRId16 ", %4" PRId16 ");\n",
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_i16x8_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_i16x8_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_u16x8_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS uint16_t test_vec[8][sizeof(simde_v128_t) / sizeof(uint16_t)] = {
{ UINT16_C(38093), UINT16_C(57469), UINT16_C( 8106), UINT16_C(48650), UINT16_C(24224), UINT16_C(19159), UINT16_C(15426), UINT16_C(33063) },
{ UINT16_C(50940), UINT16_C(46085), UINT16_C(46236), UINT16_C(48961), UINT16_C(64978), UINT16_C(33071), UINT16_C(49929), UINT16_C( 4624) },
{ UINT16_C( 8202), UINT16_C(42041), UINT16_C(26028), UINT16_C(48514), UINT16_C(43592), UINT16_C( 1354), UINT16_C(43128), UINT16_C(21891) },
{ UINT16_C(44564), UINT16_C(61184), UINT16_C( 5318), UINT16_C(31109), UINT16_C(38724), UINT16_C(32929), UINT16_C(33244), UINT16_C(62448) },
{ UINT16_C(17276), UINT16_C(42338), UINT16_C(60829), UINT16_C(53898), UINT16_C(62564), UINT16_C(27327), UINT16_C(30585), UINT16_C(34760) },
{ UINT16_C(47902), UINT16_C(53187), UINT16_C(56977), UINT16_C(28119), UINT16_C(33887), UINT16_C(48654), UINT16_C(18148), UINT16_C(30726) },
{ UINT16_C(16248), UINT16_C( 3870), UINT16_C(33357), UINT16_C(11309), UINT16_C(62315), UINT16_C(59507), UINT16_C(24525), UINT16_C(28779) },
{ UINT16_C( 3876), UINT16_C(15067), UINT16_C(57776), UINT16_C( 166), UINT16_C(30126), UINT16_C(24882), UINT16_C(47574), UINT16_C(59871) }
};
simde_v128_t a;
a = simde_wasm_u16x8_const(38093, 57469, 8106, 48650, 24224, 19159, 15426, 33063);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_u16x8_const(50940, 46085, 46236, 48961, 64978, 33071, 49929, 4624);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_u16x8_const(8202, 42041, 26028, 48514, 43592, 1354, 43128, 21891);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_u16x8_const(44564, 61184, 5318, 31109, 38724, 32929, 33244, 62448);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_u16x8_const(17276, 42338, 60829, 53898, 62564, 27327, 30585, 34760);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_u16x8_const(47902, 53187, 56977, 28119, 33887, 48654, 18148, 30726);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_u16x8_const(16248, 3870, 33357, 11309, 62315, 59507, 24525, 28779);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_u16x8_const(3876, 15067, 57776, 166, 30126, 24882, 47574, 59871);
simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint16_t a[sizeof(simde_v128_t) / sizeof(uint16_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_u16x8_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_u16x8_const(%4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ", %4" PRIu16 ");\n",
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_u16x8_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_u16x8_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_i32x4_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS int32_t test_vec[8][sizeof(simde_v128_t) / sizeof(int32_t)] = {
{ INT32_C( 1638487602), -INT32_C( 1937529758), -INT32_C( 1918818205), INT32_C( 1267645659) },
{ -INT32_C( 689210396), INT32_C( 644424890), INT32_C( 1160888587), INT32_C( 639753794) },
{ -INT32_C( 1540192956), -INT32_C( 1534596015), -INT32_C( 1690699706), -INT32_C( 38511165) },
{ -INT32_C( 45615081), -INT32_C( 1993338144), INT32_C( 1410941640), INT32_C( 704029741) },
{ INT32_C( 524140725), -INT32_C( 27262509), -INT32_C( 1759294487), INT32_C( 1425003442) },
{ INT32_C( 773366325), INT32_C( 699343649), INT32_C( 1440527447), INT32_C( 100724517) },
{ -INT32_C( 2038453375), INT32_C( 1496578013), -INT32_C( 520183197), -INT32_C( 863356994) },
{ INT32_C( 33174463), -INT32_C( 2100361721), INT32_C( 1104381806), INT32_C( 1925456090) }
};
simde_v128_t a;
a = simde_wasm_i32x4_const(1638487602, -1937529758, -1918818205, 1267645659);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_i32x4_const(-689210396, 644424890, 1160888587, 639753794);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_i32x4_const(-1540192956, -1534596015, -1690699706, -38511165);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_i32x4_const(-45615081, -1993338144, 1410941640, 704029741);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_i32x4_const(524140725, -27262509, -1759294487, 1425003442);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_i32x4_const(773366325, 699343649, 1440527447, 100724517);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_i32x4_const(-2038453375, 1496578013, -520183197, -863356994);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_i32x4_const(33174463, -2100361721, 1104381806, 1925456090);
simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
int32_t a[sizeof(simde_v128_t) / sizeof(int32_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_i32x4_make(
a[0], a[1], a[ 2], a[ 3]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_i32x4_const(%4" PRId32 ", %4" PRId32 ", %4" PRId32 ", %4" PRId32 ");\n",
a[0], a[1], a[ 2], a[ 3]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_i32x4_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_i32x4_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_u32x4_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS uint32_t test_vec[8][sizeof(simde_v128_t) / sizeof(uint32_t)] = {
{ UINT32_C(2990593695), UINT32_C(2490450969), UINT32_C(3193747699), UINT32_C(3527440183) },
{ UINT32_C(2568421379), UINT32_C( 717050584), UINT32_C( 381502383), UINT32_C(3248301619) },
{ UINT32_C(3459807367), UINT32_C( 161949914), UINT32_C(4169504360), UINT32_C(2246451843) },
{ UINT32_C(2597024358), UINT32_C(4219054161), UINT32_C( 708468433), UINT32_C(1847919338) },
{ UINT32_C( 300788028), UINT32_C(2009830291), UINT32_C(3887412491), UINT32_C(4237996658) },
{ UINT32_C(2562850601), UINT32_C(2950981340), UINT32_C(4224685893), UINT32_C( 489347227) },
{ UINT32_C(3918864336), UINT32_C(1611504337), UINT32_C( 131634430), UINT32_C( 108287508) },
{ UINT32_C( 194095795), UINT32_C( 139513668), UINT32_C(2288046941), UINT32_C( 437942115) }
};
simde_v128_t a;
a = simde_wasm_u32x4_const(2990593695, 2490450969, 3193747699, 3527440183);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_u32x4_const(2568421379, 717050584, 381502383, 3248301619);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_u32x4_const(3459807367, 161949914, 4169504360, 2246451843);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_u32x4_const(2597024358, 4219054161, 708468433, 1847919338);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_u32x4_const(300788028, 2009830291, 3887412491, 4237996658);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_u32x4_const(2562850601, 2950981340, 4224685893, 489347227);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_u32x4_const(3918864336, 1611504337, 131634430, 108287508);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_u32x4_const(194095795, 139513668, 2288046941, 437942115);
simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint32_t a[sizeof(simde_v128_t) / sizeof(uint32_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_u32x4_make(
a[0], a[1], a[ 2], a[ 3]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_u32x4_const(%4" PRIu32 ", %4" PRIu32 ", %4" PRIu32 ", %4" PRIu32 ");\n",
a[0], a[1], a[ 2], a[ 3]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_u32x4_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_u32x4_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_i64x2_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS int64_t test_vec[8][sizeof(simde_v128_t) / sizeof(int64_t)] = {
{ -INT64_C( 1430358319906461586), INT64_C( 8049127797954466860) },
{ INT64_C( 8183518753680522323), INT64_C( 7130153617536153843) },
{ INT64_C( 5919523007599387869), -INT64_C( 4291532896501508949) },
{ INT64_C( 2488131728690805642), INT64_C( 2355775262575314579) },
{ -INT64_C( 5565429007222390390), -INT64_C( 7869783713455747421) },
{ -INT64_C( 4670088175240434732), -INT64_C( 5315216180009454819) },
{ -INT64_C( 9211876366893238512), INT64_C( 3281632195185830839) },
{ -INT64_C( 8990902038405019670), INT64_C( 4241488893781657582) }
};
simde_v128_t a;
a = simde_wasm_i64x2_const(-1430358319906461586, 8049127797954466860);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_i64x2_const(8183518753680522323, 7130153617536153843);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_i64x2_const(5919523007599387869, -4291532896501508949);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_i64x2_const(2488131728690805642, 2355775262575314579);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_i64x2_const(-5565429007222390390, -7869783713455747421);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_i64x2_const(-4670088175240434732, -5315216180009454819);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_i64x2_const(-9211876366893238512, 3281632195185830839);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_i64x2_const(-8990902038405019670, 4241488893781657582);
simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
int64_t a[sizeof(simde_v128_t) / sizeof(int64_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_i64x2_make(
a[0], a[1]) ;
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_i64x2_const(%4" PRId64 ", %4" PRId64 ");\n",
a[0], a[1]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_i64x2_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_i64x2_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_u64x2_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS uint64_t test_vec[8][sizeof(simde_v128_t) / sizeof(uint64_t)] = {
{ UINT64_C( 8695826832778371234), UINT64_C( 1009371111174596241) },
{ UINT64_C( 5486143349099483814), UINT64_C( 6420274701089511671) },
{ UINT64_C( 7304997411725805900), UINT64_C(14807585266053360361) },
{ UINT64_C( 3868854925187994044), UINT64_C( 6027551375026117307) },
{ UINT64_C( 5427991744971193115), UINT64_C( 1913838352194814696) },
{ UINT64_C(15074309786091588449), UINT64_C(12347910930813565020) },
{ UINT64_C(11902320771049894625), UINT64_C( 6653414154723180806) },
{ UINT64_C( 9415881128792558302), UINT64_C(10794488662514399326) }
};
simde_v128_t a;
a = simde_wasm_u64x2_const(UINT64_C(8695826832778371234), UINT64_C(1009371111174596241));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[0]));
a = simde_wasm_u64x2_const(UINT64_C(5486143349099483814), UINT64_C(6420274701089511671));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[1]));
a = simde_wasm_u64x2_const(UINT64_C(7304997411725805900), UINT64_C(14807585266053360361));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[2]));
a = simde_wasm_u64x2_const(UINT64_C(3868854925187994044), UINT64_C(6027551375026117307));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[3]));
a = simde_wasm_u64x2_const(UINT64_C(5427991744971193115), UINT64_C(1913838352194814696));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[4]));
a = simde_wasm_u64x2_const(UINT64_C(15074309786091588449), UINT64_C(12347910930813565020));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[5]));
a = simde_wasm_u64x2_const(UINT64_C(11902320771049894625), UINT64_C(6653414154723180806));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[6]));
a = simde_wasm_u64x2_const(UINT64_C(9415881128792558302), UINT64_C(10794488662514399326));
simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[7]));
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint64_t a[sizeof(simde_v128_t) / sizeof(uint64_t)];
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
test_vec[i] = simde_wasm_u64x2_make(
a[0], a[1]) ;
fprintf(SIMDE_CODEGEN_FP, SIMDE_CODEGEN_FP, " a = simde_wasm_u64x2_const(UINT64_C(%4" PRIu64 "), UINT64_C(%4" PRIu64 "));\n",
a[0], a[1]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_u64x2_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]));\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_u64x2_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_f32x4_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS simde_float32 test_vec[8][sizeof(simde_v128_t) / sizeof(simde_float32)] = {
{ SIMDE_FLOAT32_C( -503.56), SIMDE_FLOAT32_C( -779.53), SIMDE_FLOAT32_C( 169.44), SIMDE_FLOAT32_C( -759.92) },
{ SIMDE_FLOAT32_C( 460.41), SIMDE_FLOAT32_C( 25.79), SIMDE_FLOAT32_C( 265.80), SIMDE_FLOAT32_C( 979.01) },
{ SIMDE_FLOAT32_C( -135.97), SIMDE_FLOAT32_C( -745.97), SIMDE_FLOAT32_C( -462.58), SIMDE_FLOAT32_C( 953.57) },
{ SIMDE_FLOAT32_C( 818.79), SIMDE_FLOAT32_C( -259.19), SIMDE_FLOAT32_C( 864.52), SIMDE_FLOAT32_C( -229.15) },
{ SIMDE_FLOAT32_C( 15.80), SIMDE_FLOAT32_C( -103.02), SIMDE_FLOAT32_C( 637.40), SIMDE_FLOAT32_C( -552.43) },
{ SIMDE_FLOAT32_C( 923.68), SIMDE_FLOAT32_C( 518.55), SIMDE_FLOAT32_C( 739.08), SIMDE_FLOAT32_C( -178.48) },
{ SIMDE_FLOAT32_C( -358.63), SIMDE_FLOAT32_C( -122.90), SIMDE_FLOAT32_C( 745.93), SIMDE_FLOAT32_C( 362.62) },
{ SIMDE_FLOAT32_C( -871.24), SIMDE_FLOAT32_C( 285.53), SIMDE_FLOAT32_C( 805.96), SIMDE_FLOAT32_C( 218.02) }
};
simde_v128_t a;
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( -503.56), SIMDE_FLOAT32_C( -779.53), SIMDE_FLOAT32_C( 169.44), SIMDE_FLOAT32_C( -759.92));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[0]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( 460.41), SIMDE_FLOAT32_C( 25.79), SIMDE_FLOAT32_C( 265.80), SIMDE_FLOAT32_C( 979.01));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[1]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( -135.97), SIMDE_FLOAT32_C( -745.97), SIMDE_FLOAT32_C( -462.58), SIMDE_FLOAT32_C( 953.57));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[2]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( 818.79), SIMDE_FLOAT32_C( -259.19), SIMDE_FLOAT32_C( 864.52), SIMDE_FLOAT32_C( -229.15));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[3]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( 15.80), SIMDE_FLOAT32_C( -103.02), SIMDE_FLOAT32_C( 637.40), SIMDE_FLOAT32_C( -552.43));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[4]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( 923.68), SIMDE_FLOAT32_C( 518.55), SIMDE_FLOAT32_C( 739.08), SIMDE_FLOAT32_C( -178.48));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[5]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( -358.63), SIMDE_FLOAT32_C( -122.90), SIMDE_FLOAT32_C( 745.93), SIMDE_FLOAT32_C( 362.62));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[6]), 1);
a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C( -871.24), SIMDE_FLOAT32_C( 285.53), SIMDE_FLOAT32_C( 805.96), SIMDE_FLOAT32_C( 218.02));
simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[7]), 1);
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
simde_float32 a[sizeof(simde_v128_t) / sizeof(simde_float32)];
test_vec[i] = simde_test_wasm_f32x4_random(-SIMDE_FLOAT32_C(1000.0), SIMDE_FLOAT32_C(1000.0));
a[0] = simde_wasm_f32x4_extract_lane(test_vec[i], 0);
a[1] = simde_wasm_f32x4_extract_lane(test_vec[i], 1);
a[2] = simde_wasm_f32x4_extract_lane(test_vec[i], 2);
a[3] = simde_wasm_f32x4_extract_lane(test_vec[i], 3);
fprintf(SIMDE_CODEGEN_FP, " a = simde_wasm_f32x4_const(SIMDE_FLOAT32_C(%9.2f), SIMDE_FLOAT32_C(%9.2f), SIMDE_FLOAT32_C(%9.2f), SIMDE_FLOAT32_C(%9.2f));\n",
HEDLEY_STATIC_CAST(double, a[0]), HEDLEY_STATIC_CAST(double, a[1]), HEDLEY_STATIC_CAST(double, a[ 2]), HEDLEY_STATIC_CAST(double, a[ 3]));
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_f32x4_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]), 1);\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_f32x4_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
static int
test_simde_wasm_f64x2_const(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS simde_float64 test_vec[8][sizeof(simde_v128_t) / sizeof(simde_float64)] = {
{ SIMDE_FLOAT64_C( -404.27), SIMDE_FLOAT64_C( 744.17) },
{ SIMDE_FLOAT64_C( -796.31), SIMDE_FLOAT64_C( -631.57) },
{ SIMDE_FLOAT64_C( 109.35), SIMDE_FLOAT64_C( 907.86) },
{ SIMDE_FLOAT64_C( -796.44), SIMDE_FLOAT64_C( 17.86) },
{ SIMDE_FLOAT64_C( -9.08), SIMDE_FLOAT64_C( -411.51) },
{ SIMDE_FLOAT64_C( -241.29), SIMDE_FLOAT64_C( 839.64) },
{ SIMDE_FLOAT64_C( -35.03), SIMDE_FLOAT64_C( -131.07) },
{ SIMDE_FLOAT64_C( -934.16), SIMDE_FLOAT64_C( -953.38) }
};
simde_v128_t a;
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -404.27), SIMDE_FLOAT64_C( 744.17));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[0]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -796.31), SIMDE_FLOAT64_C( -631.57));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[1]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( 109.35), SIMDE_FLOAT64_C( 907.86));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[2]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -796.44), SIMDE_FLOAT64_C( 17.86));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[3]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -9.08), SIMDE_FLOAT64_C( -411.51));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[4]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -241.29), SIMDE_FLOAT64_C( 839.64));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[5]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -35.03), SIMDE_FLOAT64_C( -131.07));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[6]), 1);
a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C( -934.16), SIMDE_FLOAT64_C( -953.38));
simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[7]), 1);
return 0;
#else
simde_v128_t test_vec[8];
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
simde_float64 a[sizeof(simde_v128_t) / sizeof(simde_float64)];
test_vec[i] = simde_test_wasm_f64x2_random(-SIMDE_FLOAT64_C(1000.0), SIMDE_FLOAT64_C(1000.0));
a[0] = simde_wasm_f64x2_extract_lane(test_vec[i], 0);
a[1] = simde_wasm_f64x2_extract_lane(test_vec[i], 1);
fprintf(SIMDE_CODEGEN_FP," a = simde_wasm_f64x2_const(SIMDE_FLOAT64_C(%9.2f), SIMDE_FLOAT64_C(%9.2f));\n",
a[0], a[1]);
fprintf(SIMDE_CODEGEN_FP, " simde_test_wasm_f64x2_assert_equal(a, simde_wasm_v128_load(test_vec[%1" PRId8 "]), 1);\n", i);
}
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_test_wasm_f64x2_write(2, test_vec[i], SIMDE_TEST_VEC_POS_MIDDLE);
}
return 1;
#endif
}
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u8x16_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i16x8_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u16x8_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u64x2_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_const)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_const)
SIMDE_TEST_FUNC_LIST_END
#include "test-simd128-footer.h"

2
thirdparty/simde/test/wasm/simd128/demote.c vendored
View file

@ -55,7 +55,7 @@ test_simde_wasm_f32x4_demote_f64x2_zero(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f32x4_demote_f64x2_zero(a);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

126
thirdparty/simde/test/wasm/simd128/extract_lane.c vendored
View file

@ -1,4 +1,5 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
* 2023 Michael R. Crusoe <crusoe@debian.org>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
@ -417,6 +418,127 @@ test_simde_wasm_u16x8_extract_lane(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u32x4_extract_lane(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint32_t a[sizeof(simde_v128_t) / sizeof(uint32_t)];
int lane;
uint32_t r;
} test_vec[] = {
{ { UINT32_C(1719605738), UINT32_C(3599425988), UINT32_C(2962826176), UINT32_C(4268748626) },
INT8_C( 2),
UINT32_C(2962826176) },
{ { UINT32_C(4109671779), UINT32_C(1643006785), UINT32_C( 538242111), UINT32_C(1449534184) },
INT8_C( 3),
UINT32_C(1449534184) },
{ { UINT32_C(2828006514), UINT32_C(3919870387), UINT32_C(1922765764), UINT32_C(3129516636) },
INT8_C( 0),
UINT32_C(2828006514) },
{ { UINT32_C(2396636887), UINT32_C(2091096732), UINT32_C(1251487119), UINT32_C(1997271597) },
INT8_C( 0),
UINT32_C(2396636887) },
{ { UINT32_C(1579862640), UINT32_C(1650158210), UINT32_C( 54305675), UINT32_C(1352283799) },
INT8_C( 1),
UINT32_C(1650158210) },
{ { UINT32_C(1121639188), UINT32_C(1813026860), UINT32_C(1290115818), UINT32_C(3776001374) },
INT8_C( 3),
UINT32_C(3776001374) },
{ { UINT32_C(3141794609), UINT32_C(2223925471), UINT32_C( 806090807), UINT32_C(1275178224) },
INT8_C( 1),
UINT32_C(2223925471) },
{ { UINT32_C(4090438997), UINT32_C(2707843994), UINT32_C(1375072311), UINT32_C( 812490190) },
INT8_C( 0),
UINT32_C(4090438997) },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
uint32_t r;
SIMDE_CONSTIFY_8_(simde_wasm_u32x4_extract_lane, r, (HEDLEY_UNREACHABLE(), UINT32_C(0)), test_vec[i].lane, a);
simde_assert_equal_u32(r, test_vec[i].r);
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
simde_v128_t a = simde_test_wasm_u32x4_random();
int lane = simde_test_codegen_random_i8() & 3;
uint32_t r;
SIMDE_CONSTIFY_4_(simde_wasm_u32x4_extract_lane, r, (HEDLEY_UNREACHABLE(), UINT32_C(0)), lane, a);
simde_test_wasm_u32x4_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_codegen_write_i8(3, HEDLEY_STATIC_CAST(int8_t, lane), SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_codegen_write_u32(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_u64x2_extract_lane(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint64_t a[sizeof(simde_v128_t) / sizeof(uint64_t)];
int lane;
uint64_t r;
} test_vec[] = {
{ { UINT64_C( 4022665760836781013), UINT64_C(18122392777482954827) },
INT8_C( 0),
UINT64_C( 4022665760836781013) },
{ { UINT64_C( 5749937325716462562), UINT64_C(17041874736480366930) },
INT8_C( 1),
UINT64_C(17041874736480366930) },
{ { UINT64_C(16854706235832665020), UINT64_C(15030198599773493448) },
INT8_C( 1),
UINT64_C(15030198599773493448) },
{ { UINT64_C( 4106195067958712193), UINT64_C(18321293018596027890) },
INT8_C( 0),
UINT64_C( 4106195067958712193) },
{ { UINT64_C( 1162171412459174152), UINT64_C(11983900068038535349) },
INT8_C( 0),
UINT64_C( 1162171412459174152) },
{ { UINT64_C( 5102303595770628181), UINT64_C( 7779896525456456271) },
INT8_C( 1),
UINT64_C( 7779896525456456271) },
{ { UINT64_C( 1585092722817858043), UINT64_C(16845515228554182949) },
INT8_C( 0),
UINT64_C( 1585092722817858043) },
{ { UINT64_C(12313933609542050325), UINT64_C( 6001822958931376953) },
INT8_C( 0),
UINT64_C(12313933609542050325) },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
uint64_t r;
SIMDE_CONSTIFY_8_(simde_wasm_u64x2_extract_lane, r, (HEDLEY_UNREACHABLE(), UINT64_C(0)), test_vec[i].lane, a);
simde_assert_equal_u64(r, test_vec[i].r);
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
simde_v128_t a = simde_test_wasm_u64x2_random();
int lane = simde_test_codegen_random_i8() & 1;
uint64_t r;
SIMDE_CONSTIFY_2_(simde_wasm_u64x2_extract_lane, r, (HEDLEY_UNREACHABLE(), UINT64_C(0)), lane, a);
simde_test_wasm_u64x2_write(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_codegen_write_i8(3, HEDLEY_STATIC_CAST(int8_t, lane), SIMDE_TEST_VEC_POS_MIDDLE);
simde_test_codegen_write_u64(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f32x4_extract_lane(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -455,7 +577,7 @@ test_simde_wasm_f32x4_extract_lane(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_float32 r;
SIMDE_CONSTIFY_8_(simde_wasm_f32x4_extract_lane, r, (HEDLEY_UNREACHABLE(), -1), test_vec[i].lane, a);
SIMDE_CONSTIFY_8_(simde_wasm_f32x4_extract_lane, r, (HEDLEY_UNREACHABLE(), SIMDE_FLOAT32_C(-1.0)), test_vec[i].lane, a);
simde_assert_equal_f32(r, test_vec[i].r, 1);
}
@ -544,6 +666,8 @@ SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u8x16_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u16x8_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u64x2_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_extract_lane)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_extract_lane)
SIMDE_TEST_FUNC_LIST_END

4
thirdparty/simde/test/wasm/simd128/floor.c vendored
View file

@ -55,7 +55,7 @@ test_simde_wasm_f32x4_floor(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f32x4_floor(a);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -106,7 +106,7 @@ test_simde_wasm_f64x2_floor(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f64x2_floor(a);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

219
thirdparty/simde/test/wasm/simd128/make.c vendored
View file

@ -1,4 +1,5 @@
/* Copyright (c) 2021 Evan Nemerson <evan@nemerson.com>
* 2023 Michael R. Crusoe <crusoe@debian.org>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
@ -94,6 +95,75 @@ test_simde_wasm_i8x16_make(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u8x16_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint8_t a[sizeof(simde_v128_t) / sizeof(uint8_t)];
uint8_t r[sizeof(simde_v128_t) / sizeof(uint8_t)];
} test_vec[] = {
{ { UINT8_C( 9), UINT8_C(209), UINT8_C(247), UINT8_C(100), UINT8_C(114), UINT8_C(139), UINT8_C(221), UINT8_C(224),
UINT8_C(200), UINT8_C( 17), UINT8_C( 43), UINT8_C(165), UINT8_C( 92), UINT8_C(164), UINT8_C(111), UINT8_C( 35) },
{ UINT8_C( 9), UINT8_C(209), UINT8_C(247), UINT8_C(100), UINT8_C(114), UINT8_C(139), UINT8_C(221), UINT8_C(224),
UINT8_C(200), UINT8_C( 17), UINT8_C( 43), UINT8_C(165), UINT8_C( 92), UINT8_C(164), UINT8_C(111), UINT8_C( 35) } },
{ { UINT8_C(147), UINT8_C(100), UINT8_C(235), UINT8_C( 87), UINT8_C(191), UINT8_C(237), UINT8_C( 6), UINT8_C( 93),
UINT8_C( 85), UINT8_C(109), UINT8_C(140), UINT8_C(221), UINT8_C(126), UINT8_C( 96), UINT8_C( 36), UINT8_C(112) },
{ UINT8_C(147), UINT8_C(100), UINT8_C(235), UINT8_C( 87), UINT8_C(191), UINT8_C(237), UINT8_C( 6), UINT8_C( 93),
UINT8_C( 85), UINT8_C(109), UINT8_C(140), UINT8_C(221), UINT8_C(126), UINT8_C( 96), UINT8_C( 36), UINT8_C(112) } },
{ { UINT8_C( 24), UINT8_C(115), UINT8_C(140), UINT8_C(171), UINT8_C(209), UINT8_MAX, UINT8_C(145), UINT8_C(156),
UINT8_C(219), UINT8_C(147), UINT8_C(191), UINT8_C( 89), UINT8_C(218), UINT8_C(190), UINT8_C(150), UINT8_C( 70) },
{ UINT8_C( 24), UINT8_C(115), UINT8_C(140), UINT8_C(171), UINT8_C(209), UINT8_MAX, UINT8_C(145), UINT8_C(156),
UINT8_C(219), UINT8_C(147), UINT8_C(191), UINT8_C( 89), UINT8_C(218), UINT8_C(190), UINT8_C(150), UINT8_C( 70) } },
{ { UINT8_C(223), UINT8_C(156), UINT8_C( 26), UINT8_C( 91), UINT8_C( 93), UINT8_C(111), UINT8_C(140), UINT8_C( 34),
UINT8_C( 17), UINT8_C(212), UINT8_C(155), UINT8_C( 20), UINT8_C(125), UINT8_C(121), UINT8_C(225), UINT8_C( 92) },
{ UINT8_C(223), UINT8_C(156), UINT8_C( 26), UINT8_C( 91), UINT8_C( 93), UINT8_C(111), UINT8_C(140), UINT8_C( 34),
UINT8_C( 17), UINT8_C(212), UINT8_C(155), UINT8_C( 20), UINT8_C(125), UINT8_C(121), UINT8_C(225), UINT8_C( 92) } },
{ { UINT8_C(203), UINT8_C(212), UINT8_C( 31), UINT8_C(184), UINT8_C(230), UINT8_C(233), UINT8_C( 33), UINT8_C( 22),
UINT8_C( 86), UINT8_C(124), UINT8_C(111), UINT8_C( 86), UINT8_C( 3), UINT8_C( 87), UINT8_C(244), UINT8_C(165) },
{ UINT8_C(203), UINT8_C(212), UINT8_C( 31), UINT8_C(184), UINT8_C(230), UINT8_C(233), UINT8_C( 33), UINT8_C( 22),
UINT8_C( 86), UINT8_C(124), UINT8_C(111), UINT8_C( 86), UINT8_C( 3), UINT8_C( 87), UINT8_C(244), UINT8_C(165) } },
{ { UINT8_C( 46), UINT8_C(233), UINT8_C( 13), UINT8_C( 87), UINT8_C( 97), UINT8_C(235), UINT8_C( 89), UINT8_C(169),
UINT8_C( 50), UINT8_C( 49), UINT8_C(209), UINT8_C(140), UINT8_C(169), UINT8_C(207), UINT8_C(190), UINT8_C( 25) },
{ UINT8_C( 46), UINT8_C(233), UINT8_C( 13), UINT8_C( 87), UINT8_C( 97), UINT8_C(235), UINT8_C( 89), UINT8_C(169),
UINT8_C( 50), UINT8_C( 49), UINT8_C(209), UINT8_C(140), UINT8_C(169), UINT8_C(207), UINT8_C(190), UINT8_C( 25) } },
{ { UINT8_C(110), UINT8_C(151), UINT8_C(159), UINT8_C(191), UINT8_C( 11), UINT8_C( 13), UINT8_C( 21), UINT8_C( 44),
UINT8_C(129), UINT8_C(168), UINT8_C(249), UINT8_C(185), UINT8_C( 73), UINT8_C(225), UINT8_C( 63), UINT8_C(244) },
{ UINT8_C(110), UINT8_C(151), UINT8_C(159), UINT8_C(191), UINT8_C( 11), UINT8_C( 13), UINT8_C( 21), UINT8_C( 44),
UINT8_C(129), UINT8_C(168), UINT8_C(249), UINT8_C(185), UINT8_C( 73), UINT8_C(225), UINT8_C( 63), UINT8_C(244) } },
{ { UINT8_C( 2), UINT8_C(194), UINT8_C(136), UINT8_C(110), UINT8_C(245), UINT8_C( 79), UINT8_C(159), UINT8_C( 82),
UINT8_C(163), UINT8_C( 60), UINT8_C( 24), UINT8_C(240), UINT8_C(215), UINT8_C(179), UINT8_C( 4), UINT8_C(221) },
{ UINT8_C( 2), UINT8_C(194), UINT8_C(136), UINT8_C(110), UINT8_C(245), UINT8_C( 79), UINT8_C(159), UINT8_C( 82),
UINT8_C(163), UINT8_C( 60), UINT8_C( 24), UINT8_C(240), UINT8_C(215), UINT8_C(179), UINT8_C( 4), UINT8_C(221) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
const uint8_t* a = test_vec[i].a;
simde_v128_t r =
simde_wasm_u8x16_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
simde_test_wasm_i8x16_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint8_t a[sizeof(simde_v128_t) / sizeof(uint8_t)];
simde_v128_t r;
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
r = simde_wasm_u8x16_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7],
a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
simde_test_codegen_write_vu8(3, sizeof(a) / sizeof(a[0]), a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u8x16_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i16x8_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -143,6 +213,55 @@ test_simde_wasm_i16x8_make(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u16x8_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint16_t a[sizeof(simde_v128_t) / sizeof(uint16_t)];
uint16_t r[sizeof(simde_v128_t) / sizeof(uint16_t)];
} test_vec[] = {
{ { UINT16_C(20545), UINT16_C(44253), UINT16_C(58828), UINT16_C( 7787), UINT16_C(59469), UINT16_C(22081), UINT16_C(27088), UINT16_C(32395) },
{ UINT16_C(20545), UINT16_C(44253), UINT16_C(58828), UINT16_C( 7787), UINT16_C(59469), UINT16_C(22081), UINT16_C(27088), UINT16_C(32395) } },
{ { UINT16_C( 5775), UINT16_C(43217), UINT16_C(64334), UINT16_C( 1400), UINT16_C( 5738), UINT16_C(16205), UINT16_C(47899), UINT16_C( 2562) },
{ UINT16_C( 5775), UINT16_C(43217), UINT16_C(64334), UINT16_C( 1400), UINT16_C( 5738), UINT16_C(16205), UINT16_C(47899), UINT16_C( 2562) } },
{ { UINT16_C(29015), UINT16_C(25900), UINT16_C(65021), UINT16_C(47325), UINT16_C(54164), UINT16_C(53071), UINT16_C(52198), UINT16_C(13308) },
{ UINT16_C(29015), UINT16_C(25900), UINT16_C(65021), UINT16_C(47325), UINT16_C(54164), UINT16_C(53071), UINT16_C(52198), UINT16_C(13308) } },
{ { UINT16_C(62050), UINT16_C(62478), UINT16_C(55936), UINT16_C( 8179), UINT16_C(55718), UINT16_C(43779), UINT16_C(47349), UINT16_C( 892) },
{ UINT16_C(62050), UINT16_C(62478), UINT16_C(55936), UINT16_C( 8179), UINT16_C(55718), UINT16_C(43779), UINT16_C(47349), UINT16_C( 892) } },
{ { UINT16_C(44543), UINT16_C(33402), UINT16_C(50502), UINT16_C( 945), UINT16_C( 990), UINT16_C(15563), UINT16_C(27884), UINT16_C(14576) },
{ UINT16_C(44543), UINT16_C(33402), UINT16_C(50502), UINT16_C( 945), UINT16_C( 990), UINT16_C(15563), UINT16_C(27884), UINT16_C(14576) } },
{ { UINT16_C(42883), UINT16_C(43039), UINT16_C(63439), UINT16_C(58016), UINT16_C(38425), UINT16_C(63667), UINT16_C(12040), UINT16_C(30097) },
{ UINT16_C(42883), UINT16_C(43039), UINT16_C(63439), UINT16_C(58016), UINT16_C(38425), UINT16_C(63667), UINT16_C(12040), UINT16_C(30097) } },
{ { UINT16_C(57249), UINT16_C(38125), UINT16_C(59964), UINT16_C(29954), UINT16_C(59043), UINT16_C(17652), UINT16_C(28627), UINT16_C(63143) },
{ UINT16_C(57249), UINT16_C(38125), UINT16_C(59964), UINT16_C(29954), UINT16_C(59043), UINT16_C(17652), UINT16_C(28627), UINT16_C(63143) } },
{ { UINT16_C(29972), UINT16_C(31988), UINT16_C(38534), UINT16_C(25494), UINT16_C(57891), UINT16_C(22914), UINT16_C(20301), UINT16_C(10030) },
{ UINT16_C(29972), UINT16_C(31988), UINT16_C(38534), UINT16_C(25494), UINT16_C(57891), UINT16_C(22914), UINT16_C(20301), UINT16_C(10030) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
const uint16_t* a = test_vec[i].a;
simde_v128_t r = simde_wasm_u16x8_make(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
simde_test_wasm_u16x8_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint16_t a[sizeof(simde_v128_t) / sizeof(uint16_t)];
simde_v128_t r;
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
r = simde_wasm_u16x8_make(
a[0], a[1], a[ 2], a[ 3], a[ 4], a[ 5], a[ 6], a[ 7]);
simde_test_codegen_write_vu16(3, sizeof(a) / sizeof(a[0]), a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u16x8_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i32x4_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -191,6 +310,54 @@ test_simde_wasm_i32x4_make(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u32x4_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint32_t a[sizeof(simde_v128_t) / sizeof(uint32_t)];
uint32_t r[sizeof(simde_v128_t) / sizeof(uint32_t)];
} test_vec[] = {
{ { UINT32_C(3741086244), UINT32_C(2676567540), UINT32_C(3206543888), UINT32_C(2842651914) },
{ UINT32_C(3741086244), UINT32_C(2676567540), UINT32_C(3206543888), UINT32_C(2842651914) } },
{ { UINT32_C( 242331003), UINT32_C(4194749509), UINT32_C(3530874187), UINT32_C(1290889414) },
{ UINT32_C( 242331003), UINT32_C(4194749509), UINT32_C(3530874187), UINT32_C(1290889414) } },
{ { UINT32_C(2534034387), UINT32_C(1542371856), UINT32_C(3568344646), UINT32_C(1867754224) },
{ UINT32_C(2534034387), UINT32_C(1542371856), UINT32_C(3568344646), UINT32_C(1867754224) } },
{ { UINT32_C(3753926397), UINT32_C( 809341656), UINT32_C( 321631296), UINT32_C(1385685678) },
{ UINT32_C(3753926397), UINT32_C( 809341656), UINT32_C( 321631296), UINT32_C(1385685678) } },
{ { UINT32_C(2810325179), UINT32_C(2123103834), UINT32_C(2526303009), UINT32_C(3594571724) },
{ UINT32_C(2810325179), UINT32_C(2123103834), UINT32_C(2526303009), UINT32_C(3594571724) } },
{ { UINT32_C(3476255978), UINT32_C( 792158346), UINT32_C(3676351836), UINT32_C( 736736561) },
{ UINT32_C(3476255978), UINT32_C( 792158346), UINT32_C(3676351836), UINT32_C( 736736561) } },
{ { UINT32_C(3933311122), UINT32_C( 62652880), UINT32_C( 658539897), UINT32_C(3971227963) },
{ UINT32_C(3933311122), UINT32_C( 62652880), UINT32_C( 658539897), UINT32_C(3971227963) } },
{ { UINT32_C( 563898168), UINT32_C(2997174771), UINT32_C(3613371558), UINT32_C( 606428827) },
{ UINT32_C( 563898168), UINT32_C(2997174771), UINT32_C(3613371558), UINT32_C( 606428827) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
const uint32_t* a = test_vec[i].a;
simde_v128_t r = simde_wasm_u32x4_make(a[0], a[1], a[2], a[3]);
simde_test_wasm_u32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint32_t a[sizeof(simde_v128_t) / sizeof(uint32_t)];
simde_v128_t r;
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
r = simde_wasm_u32x4_make(a[0], a[1], a[2], a[3]);
simde_test_codegen_write_vu32(3, sizeof(a) / sizeof(a[0]), a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i64x2_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -239,6 +406,54 @@ test_simde_wasm_i64x2_make(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u64x2_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint64_t a[sizeof(simde_v128_t) / sizeof(uint64_t)];
uint64_t r[sizeof(simde_v128_t) / sizeof(uint64_t)];
} test_vec[] = {
{ { UINT64_C(13667080432244765976), UINT64_C(14908660942780224231) },
{ UINT64_C(13667080432244765976), UINT64_C(14908660942780224231) } },
{ { UINT64_C( 8032851988975082921), UINT64_C( 3524443896702843479) },
{ UINT64_C( 8032851988975082921), UINT64_C( 3524443896702843479) } },
{ { UINT64_C( 9626695193294003197), UINT64_C(13219513155173601028) },
{ UINT64_C( 9626695193294003197), UINT64_C(13219513155173601028) } },
{ { UINT64_C( 933752945553757041), UINT64_C(13014576830931341019) },
{ UINT64_C( 933752945553757041), UINT64_C(13014576830931341019) } },
{ { UINT64_C(16763484142101381182), UINT64_C(10273084224497800495) },
{ UINT64_C(16763484142101381182), UINT64_C(10273084224497800495) } },
{ { UINT64_C(10100836791351952211), UINT64_C(15952138415039713109) },
{ UINT64_C(10100836791351952211), UINT64_C(15952138415039713109) } },
{ { UINT64_C( 6493330894824637967), UINT64_C(17916322195326844626) },
{ UINT64_C( 6493330894824637967), UINT64_C(17916322195326844626) } },
{ { UINT64_C( 4331549136355019593), UINT64_C( 7743807550277083556) },
{ UINT64_C( 4331549136355019593), UINT64_C( 7743807550277083556) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
const uint64_t* a = test_vec[i].a;
simde_v128_t r = simde_wasm_u64x2_make(a[0], a[1]);
simde_test_wasm_u64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint64_t a[sizeof(simde_v128_t) / sizeof(uint64_t)];
simde_v128_t r;
simde_test_codegen_random_memory(sizeof(a), HEDLEY_REINTERPRET_CAST(uint8_t*, a));
r = simde_wasm_u64x2_make(a[0], a[1]);
simde_test_codegen_write_vu64(3, sizeof(a) / sizeof(a[0]), a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f32x4_make(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -337,9 +552,13 @@ test_simde_wasm_f64x2_make(SIMDE_MUNIT_TEST_ARGS) {
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u8x16_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i16x8_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u16x8_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u64x2_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_make)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_make)
SIMDE_TEST_FUNC_LIST_END

10
thirdparty/simde/test/wasm/simd128/max.c vendored
View file

@ -439,6 +439,9 @@ test_simde_wasm_f32x4_max(SIMDE_MUNIT_TEST_ARGS) {
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 354.79), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 338.79) },
{ SIMDE_FLOAT32_C( 864.37), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 338.79) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( 338.79) } },
{ { SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00) },
{ SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00) },
{ SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( 0.00) } },
#endif
{ { SIMDE_FLOAT32_C( -920.07), SIMDE_FLOAT32_C( 830.32), SIMDE_FLOAT32_C( -196.85), SIMDE_FLOAT32_C( 291.81) },
{ SIMDE_FLOAT32_C( -289.04), SIMDE_FLOAT32_C( 49.93), SIMDE_FLOAT32_C( -928.55), SIMDE_FLOAT32_C( 69.77) },
@ -467,7 +470,7 @@ test_simde_wasm_f32x4_max(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_max(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -505,6 +508,9 @@ test_simde_wasm_f64x2_max(SIMDE_MUNIT_TEST_ARGS) {
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 450.40) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 652.50) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 652.50) } },
{ { SIMDE_FLOAT64_C( -0.00), SIMDE_FLOAT64_C( 0.00) },
{ SIMDE_FLOAT64_C( 0.00), SIMDE_FLOAT64_C( -0.00) },
{ SIMDE_FLOAT64_C( 0.00), SIMDE_FLOAT64_C( 0.00) } },
#endif
{ { SIMDE_FLOAT64_C( 523.06), SIMDE_FLOAT64_C( -600.30) },
{ SIMDE_FLOAT64_C( 212.57), SIMDE_FLOAT64_C( -725.13) },
@ -530,7 +536,7 @@ test_simde_wasm_f64x2_max(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_max(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

1
thirdparty/simde/test/wasm/simd128/meson.build vendored
View file

@ -10,6 +10,7 @@ simde_test_wasm_simd128_tests = [
'bitmask',
'bitselect',
'ceil',
'const',
'convert',
'demote',
'div',

10
thirdparty/simde/test/wasm/simd128/min.c vendored
View file

@ -439,6 +439,9 @@ test_simde_wasm_f32x4_min(SIMDE_MUNIT_TEST_ARGS) {
{ { SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -390.25), SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -196.34) },
{ SIMDE_FLOAT32_C( 205.16), SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -196.34) },
{ SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_MATH_NANF, SIMDE_FLOAT32_C( -196.34) } },
{ { SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00) },
{ SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( 0.00), SIMDE_FLOAT32_C( -0.00) },
{ SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00), SIMDE_FLOAT32_C( -0.00) } },
#endif
{ { SIMDE_FLOAT32_C( -384.73), SIMDE_FLOAT32_C( -820.97), SIMDE_FLOAT32_C( 258.75), SIMDE_FLOAT32_C( -90.51) },
{ SIMDE_FLOAT32_C( 635.11), SIMDE_FLOAT32_C( -21.53), SIMDE_FLOAT32_C( -197.11), SIMDE_FLOAT32_C( 959.39) },
@ -467,7 +470,7 @@ test_simde_wasm_f32x4_min(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_min(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -505,6 +508,9 @@ test_simde_wasm_f64x2_min(SIMDE_MUNIT_TEST_ARGS) {
{ { SIMDE_MATH_NAN, SIMDE_FLOAT64_C( -518.63) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( 303.06) },
{ SIMDE_MATH_NAN, SIMDE_FLOAT64_C( -518.63) } },
{ { SIMDE_FLOAT64_C( 0.00), SIMDE_FLOAT64_C( -0.00) },
{ SIMDE_FLOAT64_C( -0.00), SIMDE_FLOAT64_C( 0.00) },
{ SIMDE_FLOAT64_C( -0.00), SIMDE_FLOAT64_C( -0.00) } },
#endif
{ { SIMDE_FLOAT64_C( -79.92), SIMDE_FLOAT64_C( 907.35) },
{ SIMDE_FLOAT64_C( -343.94), SIMDE_FLOAT64_C( 358.40) },
@ -530,7 +536,7 @@ test_simde_wasm_f64x2_min(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_min(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

4
thirdparty/simde/test/wasm/simd128/nearest.c vendored
View file

@ -59,7 +59,7 @@ test_simde_wasm_f32x4_nearest(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f32x4_nearest(a);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -114,7 +114,7 @@ test_simde_wasm_f64x2_nearest(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f64x2_nearest(a);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

4
thirdparty/simde/test/wasm/simd128/pmax.c vendored
View file

@ -65,7 +65,7 @@ test_simde_wasm_f32x4_pmax(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_pmax(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -128,7 +128,7 @@ test_simde_wasm_f64x2_pmax(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_pmax(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

4
thirdparty/simde/test/wasm/simd128/pmin.c vendored
View file

@ -65,7 +65,7 @@ test_simde_wasm_f32x4_pmin(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f32x4_pmin(a, b);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -128,7 +128,7 @@ test_simde_wasm_f64x2_pmin(SIMDE_MUNIT_TEST_ARGS) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t b = simde_wasm_v128_load(test_vec[i].b);
simde_v128_t r = simde_wasm_f64x2_pmin(a, b);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

5
thirdparty/simde/test/wasm/simd128/q15mulr_sat.c vendored
View file

@ -56,7 +56,10 @@ test_simde_wasm_i16x8_q15mulr_sat(SIMDE_MUNIT_TEST_ARGS) {
{ INT16_C( 16004), INT16_C( 1745), -INT16_C( 23715), -INT16_C( 12096), INT16_C( 5669), -INT16_C( 10830), INT16_C( 1033), -INT16_C( 6671) } },
{ { -INT16_C( 14011), -INT16_C( 18667), -INT16_C( 21159), -INT16_C( 18954), -INT16_C( 6465), INT16_C( 18108), -INT16_C( 27487), -INT16_C( 3690) },
{ INT16_C( 24419), INT16_C( 13705), INT16_C( 10014), -INT16_C( 12144), INT16_C( 30660), -INT16_C( 13574), -INT16_C( 19585), INT16_C( 24488) },
{ -INT16_C( 10441), -INT16_C( 7807), -INT16_C( 6466), INT16_C( 7024), -INT16_C( 6049), -INT16_C( 7501), INT16_C( 16429), -INT16_C( 2758) } }
{ -INT16_C( 10441), -INT16_C( 7807), -INT16_C( 6466), INT16_C( 7024), -INT16_C( 6049), -INT16_C( 7501), INT16_C( 16429), -INT16_C( 2758) } },
{ { INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768) },
{ INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768), INT16_C(-32768) },
{ INT16_C( 32767), INT16_C( 32767), INT16_C( 32767), INT16_C( 32767), INT16_C( 32767), INT16_C( 32767), INT16_C( 32767), INT16_C( 32767) } }
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {

192
thirdparty/simde/test/wasm/simd128/splat.c vendored
View file

@ -78,6 +78,59 @@ test_simde_wasm_i8x16_splat(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u8x16_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint8_t a;
uint8_t r[sizeof(simde_v128_t) / sizeof(uint8_t)];
} test_vec[] = {
{ UINT8_C( 92),
{ UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92),
UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92), UINT8_C( 92) } },
{ UINT8_C(128),
{ UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128),
UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128), UINT8_C(128) } },
{ UINT8_C(238),
{ UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238),
UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238), UINT8_C(238) } },
{ UINT8_C(244),
{ UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244),
UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244), UINT8_C(244) } },
{ UINT8_C( 54),
{ UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54),
UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54), UINT8_C( 54) } },
{ UINT8_C(148),
{ UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148),
UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148), UINT8_C(148) } },
{ UINT8_C(253),
{ UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253),
UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253), UINT8_C(253) } },
{ UINT8_C(185),
{ UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185),
UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185), UINT8_C(185) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t r = simde_wasm_u8x16_splat(test_vec[i].a);
simde_test_wasm_u8x16_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint8_t a = simde_test_codegen_random_u8();
simde_v128_t r;
r = simde_wasm_u8x16_splat(a);
simde_test_codegen_write_u8(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u8x16_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i16x8_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -123,6 +176,51 @@ test_simde_wasm_i16x8_splat(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u16x8_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint16_t a;
uint16_t r[sizeof(simde_v128_t) / sizeof(uint16_t)];
} test_vec[8] = {
{ UINT16_C(14861),
{ UINT16_C(14861), UINT16_C(14861), UINT16_C(14861), UINT16_C(14861), UINT16_C(14861), UINT16_C(14861), UINT16_C(14861), UINT16_C(14861) } },
{ UINT16_C(33042),
{ UINT16_C(33042), UINT16_C(33042), UINT16_C(33042), UINT16_C(33042), UINT16_C(33042), UINT16_C(33042), UINT16_C(33042), UINT16_C(33042) } },
{ UINT16_C(45949),
{ UINT16_C(45949), UINT16_C(45949), UINT16_C(45949), UINT16_C(45949), UINT16_C(45949), UINT16_C(45949), UINT16_C(45949), UINT16_C(45949) } },
{ UINT16_C(30008),
{ UINT16_C(30008), UINT16_C(30008), UINT16_C(30008), UINT16_C(30008), UINT16_C(30008), UINT16_C(30008), UINT16_C(30008), UINT16_C(30008) } },
{ UINT16_C(33394),
{ UINT16_C(33394), UINT16_C(33394), UINT16_C(33394), UINT16_C(33394), UINT16_C(33394), UINT16_C(33394), UINT16_C(33394), UINT16_C(33394) } },
{ UINT16_C(15014),
{ UINT16_C(15014), UINT16_C(15014), UINT16_C(15014), UINT16_C(15014), UINT16_C(15014), UINT16_C(15014), UINT16_C(15014), UINT16_C(15014) } },
{ UINT16_C( 5927),
{ UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927), UINT16_C( 5927) } },
{ UINT16_C( 3319),
{ UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319), UINT16_C( 3319) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t r = simde_wasm_u16x8_splat(test_vec[i].a);
simde_test_wasm_u16x8_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint16_t a = simde_test_codegen_random_u16();
simde_v128_t r;
r = simde_wasm_u16x8_splat(a);
simde_test_codegen_write_u16(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u16x8_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i32x4_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -168,6 +266,51 @@ test_simde_wasm_i32x4_splat(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u32x4_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint32_t a;
uint32_t r[sizeof(simde_v128_t) / sizeof(uint32_t)];
} test_vec[8] = {
{ UINT32_C(2975126680),
{ UINT32_C(2975126680), UINT32_C(2975126680), UINT32_C(2975126680), UINT32_C(2975126680) } },
{ UINT32_C(1285121060),
{ UINT32_C(1285121060), UINT32_C(1285121060), UINT32_C(1285121060), UINT32_C(1285121060) } },
{ UINT32_C(2413518924),
{ UINT32_C(2413518924), UINT32_C(2413518924), UINT32_C(2413518924), UINT32_C(2413518924) } },
{ UINT32_C( 491903476),
{ UINT32_C( 491903476), UINT32_C( 491903476), UINT32_C( 491903476), UINT32_C( 491903476) } },
{ UINT32_C(3103709002),
{ UINT32_C(3103709002), UINT32_C(3103709002), UINT32_C(3103709002), UINT32_C(3103709002) } },
{ UINT32_C( 801096537),
{ UINT32_C( 801096537), UINT32_C( 801096537), UINT32_C( 801096537), UINT32_C( 801096537) } },
{ UINT32_C(2605969948),
{ UINT32_C(2605969948), UINT32_C(2605969948), UINT32_C(2605969948), UINT32_C(2605969948) } },
{ UINT32_C(1567561904),
{ UINT32_C(1567561904), UINT32_C(1567561904), UINT32_C(1567561904), UINT32_C(1567561904) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t r = simde_wasm_u32x4_splat(test_vec[i].a);
simde_test_wasm_u32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint32_t a = simde_test_codegen_random_u32();
simde_v128_t r;
r = simde_wasm_u32x4_splat(a);
simde_test_codegen_write_u32(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u32x4_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_i64x2_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -213,6 +356,51 @@ test_simde_wasm_i64x2_splat(SIMDE_MUNIT_TEST_ARGS) {
#endif
}
static int
test_simde_wasm_u64x2_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
SIMDE_TEST_STRUCT_MODIFIERS struct {
uint64_t a;
uint64_t r[sizeof(simde_v128_t) / sizeof(uint64_t)];
} test_vec[8] = {
{ UINT64_C( 7132691792976625565),
{ UINT64_C( 7132691792976625565), UINT64_C( 7132691792976625565) } },
{ UINT64_C(14300499752629954042),
{ UINT64_C(14300499752629954042), UINT64_C(14300499752629954042) } },
{ UINT64_C( 7097148800183537898),
{ UINT64_C( 7097148800183537898), UINT64_C( 7097148800183537898) } },
{ UINT64_C( 2779430508868147369),
{ UINT64_C( 2779430508868147369), UINT64_C( 2779430508868147369) } },
{ UINT64_C( 4010387163490798142),
{ UINT64_C( 4010387163490798142), UINT64_C( 4010387163490798142) } },
{ UINT64_C(15656940686994346834),
{ UINT64_C(15656940686994346834), UINT64_C(15656940686994346834) } },
{ UINT64_C(17812203231116185058),
{ UINT64_C(17812203231116185058), UINT64_C(17812203231116185058) } },
{ UINT64_C( 8883241973645748423),
{ UINT64_C( 8883241973645748423), UINT64_C( 8883241973645748423) } },
};
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t r = simde_wasm_u64x2_splat(test_vec[i].a);
simde_test_wasm_u64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r));
}
return 0;
#else
fputc('\n', stdout);
for (int i = 0 ; i < 8 ; i++) {
uint64_t a = simde_test_codegen_random_u64();
simde_v128_t r;
r = simde_wasm_u64x2_splat(a);
simde_test_codegen_write_u64(3, a, SIMDE_TEST_VEC_POS_FIRST);
simde_test_wasm_u64x2_write(3, r, SIMDE_TEST_VEC_POS_LAST);
}
return 1;
#endif
}
static int
test_simde_wasm_f32x4_splat(SIMDE_MUNIT_TEST_ARGS) {
#if 1
@ -305,9 +493,13 @@ test_simde_wasm_f64x2_splat(SIMDE_MUNIT_TEST_ARGS) {
SIMDE_TEST_FUNC_LIST_BEGIN
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i8x16_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u8x16_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i16x8_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u16x8_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i32x4_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u32x4_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_i64x2_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_u64x2_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f32x4_splat)
SIMDE_TEST_FUNC_LIST_ENTRY(wasm_f64x2_splat)
SIMDE_TEST_FUNC_LIST_END

4
thirdparty/simde/test/wasm/simd128/trunc.c vendored
View file

@ -55,7 +55,7 @@ test_simde_wasm_f32x4_trunc(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f32x4_trunc(a);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f32x4_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else
@ -106,7 +106,7 @@ test_simde_wasm_f64x2_trunc(SIMDE_MUNIT_TEST_ARGS) {
for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) {
simde_v128_t a = simde_wasm_v128_load(test_vec[i].a);
simde_v128_t r = simde_wasm_f64x2_trunc(a);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), 1);
simde_test_wasm_f64x2_assert_equal(r, simde_wasm_v128_load(test_vec[i].r), INT_MAX);
}
return 0;
#else

6
thirdparty/simde/test/wasm/test-simd128.h vendored
View file

@ -4,6 +4,9 @@
#include "../../simde/wasm/simd128.h"
#include "../test.h"
HEDLEY_DIAGNOSTIC_PUSH
HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#define SIMDE_TEST_WASM_SIMD128_GENERATE_INT_FUNCS_(Element_Width, Element_Count) \
static int \
simde_test_wasm_i##Element_Width##x##Element_Count##_assert_equal_( \
@ -116,4 +119,7 @@ SIMDE_TEST_WASM_SIMD128_GENERATE_FLOAT_FUNCS_(64, 2)
#define simde_test_wasm_f32x4_assert_equal(a, b, precision) do { if (simde_test_wasm_f32x4_assert_equal_(a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) return 1; } while (0)
#define simde_test_wasm_f64x2_assert_equal(a, b, precision) do { if (simde_test_wasm_f64x2_assert_equal_(a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)) return 1; } while (0)
/* HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION */
HEDLEY_DIAGNOSTIC_POP
#endif /* !defined(SIMDE_TEST_WASM_TEST_SIMD128_H) */