2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
5 /* Expected values of cumulative_saturation flag with negative unput. */
6 int VECT_VAR(expected_cumulative_sat_neg
,int,16,8) = 0;
7 int VECT_VAR(expected_cumulative_sat_neg
,int,32,4) = 0;
8 int VECT_VAR(expected_cumulative_sat_neg
,int,64,2) = 1;
10 /* Expected results with negative input. */
11 VECT_VAR_DECL(expected_neg
,uint
,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
13 VECT_VAR_DECL(expected_neg
,uint
,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
14 VECT_VAR_DECL(expected_neg
,uint
,32,2) [] = { 0x0, 0x0 };
16 /* Expected values of cumulative_saturation flag with max input value
18 int VECT_VAR(expected_cumulative_sat_max_sh1
,int,16,8) = 1;
19 int VECT_VAR(expected_cumulative_sat_max_sh1
,int,32,4) = 1;
20 int VECT_VAR(expected_cumulative_sat_max_sh1
,int,64,2) = 1;
22 /* Expected results with max input value shifted by 1. */
23 VECT_VAR_DECL(expected_max_sh1
,uint
,8,8) [] = { 0xff, 0xff, 0xff, 0xff,
24 0xff, 0xff, 0xff, 0xff };
25 VECT_VAR_DECL(expected_max_sh1
,uint
,16,4) [] = { 0xffff, 0xffff,
27 VECT_VAR_DECL(expected_max_sh1
,uint
,32,2) [] = { 0xffffffff, 0xffffffff };
28 VECT_VAR_DECL(expected_max_sh1
,uint
,64,1) [] = { 0x3333333333333333 };
30 /* Expected values of cumulative_saturation flag with max input value
31 shifted by max amount. */
32 int VECT_VAR(expected_cumulative_sat_max_shmax
,int,16,8) = 0;
33 int VECT_VAR(expected_cumulative_sat_max_shmax
,int,32,4) = 0;
34 int VECT_VAR(expected_cumulative_sat_max_shmax
,int,64,2) = 0;
36 /* Expected results with max input value shifted by max amount. */
37 VECT_VAR_DECL(expected_max_shmax
,uint
,8,8) [] = { 0x80, 0x80, 0x80, 0x80,
38 0x80, 0x80, 0x80, 0x80 };
39 VECT_VAR_DECL(expected_max_shmax
,uint
,16,4) [] = { 0x8000, 0x8000,
41 VECT_VAR_DECL(expected_max_shmax
,uint
,32,2) [] = { 0x80000000, 0x80000000 };
43 /* Expected values of cumulative_saturation flag with min input value
44 shifted by max amount. */
45 int VECT_VAR(expected_cumulative_sat_min_shmax
,int,16,8) = 1;
46 int VECT_VAR(expected_cumulative_sat_min_shmax
,int,32,4) = 1;
47 int VECT_VAR(expected_cumulative_sat_min_shmax
,int,64,2) = 1;
49 /* Expected results with min input value shifted by max amount. */
50 VECT_VAR_DECL(expected_min_shmax
,uint
,8,8) [] = { 0x0, 0x0, 0x0, 0x0,
52 VECT_VAR_DECL(expected_min_shmax
,uint
,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
53 VECT_VAR_DECL(expected_min_shmax
,uint
,32,2) [] = { 0x0, 0x0 };
55 /* Expected values of cumulative_saturation flag with inputs in usual
57 int VECT_VAR(expected_cumulative_sat
,int,16,8) = 0;
58 int VECT_VAR(expected_cumulative_sat
,int,32,4) = 1;
59 int VECT_VAR(expected_cumulative_sat
,int,64,2) = 0;
61 /* Expected results with inputs in usual range. */
62 VECT_VAR_DECL(expected
,uint
,8,8) [] = { 0x49, 0x49, 0x49, 0x49,
63 0x49, 0x49, 0x49, 0x49 };
64 VECT_VAR_DECL(expected
,uint
,16,4) [] = { 0x0, 0x0, 0x0, 0x0 };
65 VECT_VAR_DECL(expected
,uint
,32,2) [] = { 0xdeadbf, 0xdeadbf };
67 #define INSN vqrshrun_n
68 #define TEST_MSG "VQRSHRUN_N"
70 #define FNNAME1(NAME) void exec_ ## NAME (void)
71 #define FNNAME(NAME) FNNAME1(NAME)
75 /* Basic test: y=vqrshrun_n(x,v), then store the result. */
76 #define TEST_VQRSHRUN_N2(INSN, T1, T2, W, W2, N, V, EXPECTED_CUMULATIVE_SAT, CMT) \
77 Set_Neon_Cumulative_Sat(0, VECT_VAR(vector_res, uint, W2, N)); \
78 VECT_VAR(vector_res, uint, W2, N) = \
79 INSN##_##T2##W(VECT_VAR(vector, T1, W, N), \
81 vst1_u##W2(VECT_VAR(result, uint, W2, N), \
82 VECT_VAR(vector_res, uint, W2, N)); \
83 CHECK_CUMULATIVE_SAT(TEST_MSG, T1, W, N, EXPECTED_CUMULATIVE_SAT, CMT)
85 /* Two auxliary macros are necessary to expand INSN */
86 #define TEST_VQRSHRUN_N1(INSN, T1, T2, W, W2, N, V, EXPECTED_CUMULATIVE_SAT, CMT) \
87 TEST_VQRSHRUN_N2(INSN, T1, T2, W, W2, N, V, EXPECTED_CUMULATIVE_SAT, CMT)
89 #define TEST_VQRSHRUN_N(T1, T2, W, W2, N, V, EXPECTED_CUMULATIVE_SAT, CMT) \
90 TEST_VQRSHRUN_N1(INSN, T1, T2, W, W2, N, V, EXPECTED_CUMULATIVE_SAT, CMT)
93 /* vector is twice as large as vector_res. */
94 DECL_VARIABLE(vector
, int, 16, 8);
95 DECL_VARIABLE(vector
, int, 32, 4);
96 DECL_VARIABLE(vector
, int, 64, 2);
98 DECL_VARIABLE(vector_res
, uint
, 8, 8);
99 DECL_VARIABLE(vector_res
, uint
, 16, 4);
100 DECL_VARIABLE(vector_res
, uint
, 32, 2);
104 /* Fill input vector with negative values, to check saturation on
106 VDUP(vector
, q
, int, s
, 16, 8, -2);
107 VDUP(vector
, q
, int, s
, 32, 4, -3);
108 VDUP(vector
, q
, int, s
, 64, 2, -4);
110 /* Choose shift amount arbitrarily. */
111 #define CMT " (negative input)"
112 TEST_VQRSHRUN_N(int, s
, 16, 8, 8, 3, expected_cumulative_sat_neg
, CMT
);
113 TEST_VQRSHRUN_N(int, s
, 32, 16, 4, 4, expected_cumulative_sat_neg
, CMT
);
114 TEST_VQRSHRUN_N(int, s
, 64, 32, 2, 2, expected_cumulative_sat_neg
, CMT
);
116 CHECK(TEST_MSG
, uint
, 8, 8, PRIx8
, expected_neg
, CMT
);
117 CHECK(TEST_MSG
, uint
, 16, 4, PRIx16
, expected_neg
, CMT
);
118 CHECK(TEST_MSG
, uint
, 32, 2, PRIx32
, expected_neg
, CMT
);
121 /* Fill input vector with max value, to check saturation on
123 VDUP(vector
, q
, int, s
, 16, 8, 0x7FFF);
124 VDUP(vector
, q
, int, s
, 32, 4, 0x7FFFFFFF);
125 VDUP(vector
, q
, int, s
, 64, 2, 0x7FFFFFFFFFFFFFFFLL
);
129 #define CMT " (check cumulative saturation: shift by 1)"
130 TEST_VQRSHRUN_N(int, s
, 16, 8, 8, 1, expected_cumulative_sat_max_sh1
, CMT
);
131 TEST_VQRSHRUN_N(int, s
, 32, 16, 4, 1, expected_cumulative_sat_max_sh1
, CMT
);
132 TEST_VQRSHRUN_N(int, s
, 64, 32, 2, 1, expected_cumulative_sat_max_sh1
, CMT
);
134 CHECK(TEST_MSG
, uint
, 8, 8, PRIx8
, expected_max_sh1
, CMT
);
135 CHECK(TEST_MSG
, uint
, 16, 4, PRIx16
, expected_max_sh1
, CMT
);
136 CHECK(TEST_MSG
, uint
, 32, 2, PRIx32
, expected_max_sh1
, CMT
);
141 #define CMT " (check cumulative saturation: shift by max, positive input)"
142 TEST_VQRSHRUN_N(int, s
, 16, 8, 8, 8, expected_cumulative_sat_max_shmax
, CMT
);
143 TEST_VQRSHRUN_N(int, s
, 32, 16, 4, 16, expected_cumulative_sat_max_shmax
, CMT
);
144 TEST_VQRSHRUN_N(int, s
, 64, 32, 2, 32, expected_cumulative_sat_max_shmax
, CMT
);
146 CHECK(TEST_MSG
, uint
, 8, 8, PRIx8
, expected_max_shmax
, CMT
);
147 CHECK(TEST_MSG
, uint
, 16, 4, PRIx16
, expected_max_shmax
, CMT
);
148 CHECK(TEST_MSG
, uint
, 32, 2, PRIx32
, expected_max_shmax
, CMT
);
151 /* Fill input vector with min value, to check saturation on limits. */
152 VDUP(vector
, q
, int, s
, 16, 8, 0x8000);
153 VDUP(vector
, q
, int, s
, 32, 4, 0x80000000);
154 VDUP(vector
, q
, int, s
, 64, 2, 0x8000000000000000LL
);
158 #define CMT " (check cumulative saturation: shift by max, negative input)"
159 TEST_VQRSHRUN_N(int, s
, 16, 8, 8, 8, expected_cumulative_sat_min_shmax
, CMT
);
160 TEST_VQRSHRUN_N(int, s
, 32, 16, 4, 16, expected_cumulative_sat_min_shmax
, CMT
);
161 TEST_VQRSHRUN_N(int, s
, 64, 32, 2, 32, expected_cumulative_sat_min_shmax
, CMT
);
163 CHECK(TEST_MSG
, uint
, 8, 8, PRIx8
, expected_min_shmax
, CMT
);
164 CHECK(TEST_MSG
, uint
, 16, 4, PRIx16
, expected_min_shmax
, CMT
);
165 CHECK(TEST_MSG
, uint
, 32, 2, PRIx32
, expected_min_shmax
, CMT
);
168 /* Fill input vector with positive values, to check normal case. */
169 VDUP(vector
, q
, int, s
, 16, 8, 0x1234);
170 VDUP(vector
, q
, int, s
, 32, 4, 0x87654321);
171 VDUP(vector
, q
, int, s
, 64, 2, 0xDEADBEEF);
173 /* shift arbitrary amount. */
176 TEST_VQRSHRUN_N(int, s
, 16, 8, 8, 6, expected_cumulative_sat
, CMT
);
177 TEST_VQRSHRUN_N(int, s
, 32, 16, 4, 7, expected_cumulative_sat
, CMT
);
178 TEST_VQRSHRUN_N(int, s
, 64, 32, 2, 8, expected_cumulative_sat
, CMT
);
180 CHECK(TEST_MSG
, uint
, 8, 8, PRIx8
, expected
, CMT
);
181 CHECK(TEST_MSG
, uint
, 16, 4, PRIx16
, expected
, CMT
);
182 CHECK(TEST_MSG
, uint
, 32, 2, PRIx32
, expected
, CMT
);