]>
Commit | Line | Data |
---|---|---|
7adcbafe | 1 | // Copyright (C) 2020-2022 Free Software Foundation, Inc. |
02e32295 MK |
2 | // |
3 | // This file is part of the GNU ISO C++ Library. This library is free | |
4 | // software; you can redistribute it and/or modify it under the | |
5 | // terms of the GNU General Public License as published by the | |
6 | // Free Software Foundation; either version 3, or (at your option) | |
7 | // any later version. | |
8 | // | |
9 | // This library is distributed in the hope that it will be useful, | |
10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | // GNU General Public License for more details. | |
13 | // | |
14 | // You should have received a copy of the GNU General Public License along | |
15 | // with this library; see the file COPYING3. If not see | |
16 | // <http://www.gnu.org/licenses/>. | |
17 | ||
aa89c53c | 18 | // expensive: * [1-9] * * |
02e32295 MK |
19 | #include "bits/verify.h" |
20 | #include "bits/metahelpers.h" | |
21 | ||
22 | // type with sizeof(char) but different signedness | |
23 | using xchar = std::conditional_t<std::is_unsigned_v<char>, schar, uchar>; | |
24 | ||
25 | using vschar = std::experimental::native_simd<schar>; | |
26 | using vuchar = std::experimental::native_simd<uchar>; | |
27 | using vshort = std::experimental::native_simd<short>; | |
28 | using vushort = std::experimental::native_simd<ushort>; | |
29 | using vint = std::experimental::native_simd<int>; | |
30 | using vuint = std::experimental::native_simd<uint>; | |
31 | using vlong = std::experimental::native_simd<long>; | |
32 | using vulong = std::experimental::native_simd<ulong>; | |
33 | using vllong = std::experimental::native_simd<llong>; | |
34 | using vullong = std::experimental::native_simd<ullong>; | |
35 | using vfloat = std::experimental::native_simd<float>; | |
36 | using vdouble = std::experimental::native_simd<double>; | |
37 | using vldouble = std::experimental::native_simd<long double>; | |
38 | using vchar = std::experimental::native_simd<char>; | |
39 | using vxchar = std::experimental::native_simd<xchar>; | |
40 | ||
41 | template <typename T> | |
42 | using vi8 = std::experimental::fixed_size_simd<T, vschar::size()>; | |
43 | template <typename T> | |
44 | using vi16 = std::experimental::fixed_size_simd<T, vshort::size()>; | |
45 | template <typename T> | |
46 | using vf32 = std::experimental::fixed_size_simd<T, vfloat::size()>; | |
47 | template <typename T> | |
48 | using vi32 = std::experimental::fixed_size_simd<T, vint::size()>; | |
49 | template <typename T> | |
50 | using vf64 = std::experimental::fixed_size_simd<T, vdouble::size()>; | |
51 | template <typename T> | |
52 | using vi64 = std::experimental::fixed_size_simd<T, vllong::size()>; | |
53 | template <typename T> | |
54 | using vl = typename std::conditional<sizeof(long) == sizeof(llong), vi64<T>, | |
55 | vi32<T>>::type; | |
56 | ||
57 | template <class A, class B, class Expected = A> | |
58 | void | |
59 | binary_op_return_type() | |
60 | { | |
61 | using namespace vir::test; | |
62 | static_assert(std::is_same<A, Expected>::value, ""); | |
63 | using AC = std::add_const_t<A>; | |
64 | using BC = std::add_const_t<B>; | |
65 | COMPARE(typeid(A() + B()), typeid(Expected)); | |
66 | COMPARE(typeid(B() + A()), typeid(Expected)); | |
67 | COMPARE(typeid(AC() + BC()), typeid(Expected)); | |
68 | COMPARE(typeid(BC() + AC()), typeid(Expected)); | |
69 | } | |
70 | ||
71 | template <typename V> | |
72 | void | |
73 | test() | |
74 | { | |
75 | using T = typename V::value_type; | |
76 | namespace simd_abi = std::experimental::simd_abi; | |
77 | binary_op_return_type<V, V, V>(); | |
78 | binary_op_return_type<V, T, V>(); | |
79 | binary_op_return_type<V, int, V>(); | |
80 | ||
81 | if constexpr (std::is_same_v<V, vfloat>) | |
82 | { | |
83 | binary_op_return_type<vfloat, schar>(); | |
84 | binary_op_return_type<vfloat, uchar>(); | |
85 | binary_op_return_type<vfloat, short>(); | |
86 | binary_op_return_type<vfloat, ushort>(); | |
87 | ||
88 | binary_op_return_type<vf32<float>, schar>(); | |
89 | binary_op_return_type<vf32<float>, uchar>(); | |
90 | binary_op_return_type<vf32<float>, short>(); | |
91 | binary_op_return_type<vf32<float>, ushort>(); | |
92 | binary_op_return_type<vf32<float>, int>(); | |
93 | binary_op_return_type<vf32<float>, float>(); | |
94 | ||
95 | binary_op_return_type<vf32<float>, vf32<schar>>(); | |
96 | binary_op_return_type<vf32<float>, vf32<uchar>>(); | |
97 | binary_op_return_type<vf32<float>, vf32<short>>(); | |
98 | binary_op_return_type<vf32<float>, vf32<ushort>>(); | |
99 | binary_op_return_type<vf32<float>, vf32<float>>(); | |
100 | ||
101 | VERIFY((is_substitution_failure<vfloat, uint>)); | |
102 | VERIFY((is_substitution_failure<vfloat, long>)); | |
103 | VERIFY((is_substitution_failure<vfloat, ulong>)); | |
104 | VERIFY((is_substitution_failure<vfloat, llong>)); | |
105 | VERIFY((is_substitution_failure<vfloat, ullong>)); | |
106 | VERIFY((is_substitution_failure<vfloat, double>)); | |
107 | VERIFY((is_substitution_failure<vfloat, vf32<schar>>)); | |
108 | VERIFY((is_substitution_failure<vfloat, vf32<uchar>>)); | |
109 | VERIFY((is_substitution_failure<vfloat, vf32<short>>)); | |
110 | VERIFY((is_substitution_failure<vfloat, vf32<ushort>>)); | |
111 | VERIFY((is_substitution_failure<vfloat, vf32<int>>)); | |
112 | VERIFY((is_substitution_failure<vfloat, vf32<uint>>)); | |
113 | VERIFY((is_substitution_failure<vfloat, vf32<long>>)); | |
114 | VERIFY((is_substitution_failure<vfloat, vf32<ulong>>)); | |
115 | VERIFY((is_substitution_failure<vfloat, vf32<llong>>)); | |
116 | VERIFY((is_substitution_failure<vfloat, vf32<ullong>>)); | |
117 | VERIFY((is_substitution_failure<vfloat, vf32<float>>)); | |
118 | ||
119 | VERIFY((is_substitution_failure<vf32<float>, vfloat>)); | |
120 | VERIFY((is_substitution_failure<vf32<float>, uint>)); | |
121 | VERIFY((is_substitution_failure<vf32<float>, long>)); | |
122 | VERIFY((is_substitution_failure<vf32<float>, ulong>)); | |
123 | VERIFY((is_substitution_failure<vf32<float>, llong>)); | |
124 | VERIFY((is_substitution_failure<vf32<float>, ullong>)); | |
125 | VERIFY((is_substitution_failure<vf32<float>, double>)); | |
126 | VERIFY((is_substitution_failure<vf32<float>, vf32<int>>)); | |
127 | VERIFY((is_substitution_failure<vf32<float>, vf32<uint>>)); | |
128 | VERIFY((is_substitution_failure<vf32<float>, vf32<long>>)); | |
129 | VERIFY((is_substitution_failure<vf32<float>, vf32<ulong>>)); | |
130 | VERIFY((is_substitution_failure<vf32<float>, vf32<llong>>)); | |
131 | VERIFY((is_substitution_failure<vf32<float>, vf32<ullong>>)); | |
132 | ||
133 | VERIFY((is_substitution_failure<vfloat, vf32<double>>)); | |
134 | } | |
135 | else if constexpr (std::is_same_v<V, vdouble>) | |
136 | { | |
137 | binary_op_return_type<vdouble, float, vdouble>(); | |
138 | binary_op_return_type<vdouble, schar>(); | |
139 | binary_op_return_type<vdouble, uchar>(); | |
140 | binary_op_return_type<vdouble, short>(); | |
141 | binary_op_return_type<vdouble, ushort>(); | |
142 | binary_op_return_type<vdouble, uint>(); | |
143 | ||
144 | binary_op_return_type<vf64<double>, schar>(); | |
145 | binary_op_return_type<vf64<double>, uchar>(); | |
146 | binary_op_return_type<vf64<double>, short>(); | |
147 | binary_op_return_type<vf64<double>, ushort>(); | |
148 | binary_op_return_type<vf64<double>, uint>(); | |
149 | binary_op_return_type<vf64<double>, int, vf64<double>>(); | |
150 | binary_op_return_type<vf64<double>, float, vf64<double>>(); | |
151 | binary_op_return_type<vf64<double>, double, vf64<double>>(); | |
152 | binary_op_return_type<vf64<double>, vf64<double>, vf64<double>>(); | |
153 | binary_op_return_type<vf32<double>, schar>(); | |
154 | binary_op_return_type<vf32<double>, uchar>(); | |
155 | binary_op_return_type<vf32<double>, short>(); | |
156 | binary_op_return_type<vf32<double>, ushort>(); | |
157 | binary_op_return_type<vf32<double>, uint>(); | |
158 | binary_op_return_type<vf32<double>, int, vf32<double>>(); | |
159 | binary_op_return_type<vf32<double>, float, vf32<double>>(); | |
160 | binary_op_return_type<vf32<double>, double, vf32<double>>(); | |
161 | binary_op_return_type<vf64<double>, vf64<schar>>(); | |
162 | binary_op_return_type<vf64<double>, vf64<uchar>>(); | |
163 | binary_op_return_type<vf64<double>, vf64<short>>(); | |
164 | binary_op_return_type<vf64<double>, vf64<ushort>>(); | |
165 | binary_op_return_type<vf64<double>, vf64<int>>(); | |
166 | binary_op_return_type<vf64<double>, vf64<uint>>(); | |
167 | binary_op_return_type<vf64<double>, vf64<float>>(); | |
168 | ||
169 | VERIFY((is_substitution_failure<vdouble, llong>)); | |
170 | VERIFY((is_substitution_failure<vdouble, ullong>)); | |
171 | VERIFY((is_substitution_failure<vdouble, vf64<schar>>)); | |
172 | VERIFY((is_substitution_failure<vdouble, vf64<uchar>>)); | |
173 | VERIFY((is_substitution_failure<vdouble, vf64<short>>)); | |
174 | VERIFY((is_substitution_failure<vdouble, vf64<ushort>>)); | |
175 | VERIFY((is_substitution_failure<vdouble, vf64<int>>)); | |
176 | VERIFY((is_substitution_failure<vdouble, vf64<uint>>)); | |
177 | VERIFY((is_substitution_failure<vdouble, vf64<long>>)); | |
178 | VERIFY((is_substitution_failure<vdouble, vf64<ulong>>)); | |
179 | VERIFY((is_substitution_failure<vdouble, vf64<llong>>)); | |
180 | VERIFY((is_substitution_failure<vdouble, vf64<ullong>>)); | |
181 | VERIFY((is_substitution_failure<vdouble, vf64<float>>)); | |
182 | VERIFY((is_substitution_failure<vdouble, vf64<double>>)); | |
183 | ||
184 | VERIFY((is_substitution_failure<vf64<double>, vdouble>)); | |
185 | VERIFY((is_substitution_failure<vf64<double>, llong>)); | |
186 | VERIFY((is_substitution_failure<vf64<double>, ullong>)); | |
187 | VERIFY((is_substitution_failure<vf64<double>, vf64<llong>>)); | |
188 | VERIFY((is_substitution_failure<vf64<double>, vf64<ullong>>)); | |
189 | ||
190 | VERIFY((is_substitution_failure<vf32<double>, llong>)); | |
191 | VERIFY((is_substitution_failure<vf32<double>, ullong>)); | |
192 | ||
193 | if constexpr (sizeof(long) == sizeof(llong)) | |
194 | { | |
195 | VERIFY((is_substitution_failure<vdouble, long>)); | |
196 | VERIFY((is_substitution_failure<vdouble, ulong>)); | |
197 | VERIFY((is_substitution_failure<vf64<double>, long>)); | |
198 | VERIFY((is_substitution_failure<vf64<double>, ulong>)); | |
199 | VERIFY((is_substitution_failure<vf64<double>, vf64<long>>)); | |
200 | VERIFY((is_substitution_failure<vf64<double>, vf64<ulong>>)); | |
201 | VERIFY((is_substitution_failure<vf32<double>, long>)); | |
202 | VERIFY((is_substitution_failure<vf32<double>, ulong>)); | |
203 | } | |
204 | else | |
205 | { | |
206 | binary_op_return_type<vdouble, long>(); | |
207 | binary_op_return_type<vdouble, ulong>(); | |
208 | binary_op_return_type<vf64<double>, long>(); | |
209 | binary_op_return_type<vf64<double>, ulong>(); | |
210 | binary_op_return_type<vf64<double>, vf64<long>>(); | |
211 | binary_op_return_type<vf64<double>, vf64<ulong>>(); | |
212 | binary_op_return_type<vf32<double>, long>(); | |
213 | binary_op_return_type<vf32<double>, ulong>(); | |
214 | } | |
215 | } | |
216 | else if constexpr (std::is_same_v<V, vldouble>) | |
217 | { | |
218 | binary_op_return_type<vldouble, schar>(); | |
219 | binary_op_return_type<vldouble, uchar>(); | |
220 | binary_op_return_type<vldouble, short>(); | |
221 | binary_op_return_type<vldouble, ushort>(); | |
222 | binary_op_return_type<vldouble, uint>(); | |
223 | binary_op_return_type<vldouble, long>(); | |
224 | binary_op_return_type<vldouble, ulong>(); | |
225 | binary_op_return_type<vldouble, float>(); | |
226 | binary_op_return_type<vldouble, double>(); | |
227 | ||
228 | binary_op_return_type<vf64<long double>, schar>(); | |
229 | binary_op_return_type<vf64<long double>, uchar>(); | |
230 | binary_op_return_type<vf64<long double>, short>(); | |
231 | binary_op_return_type<vf64<long double>, ushort>(); | |
232 | binary_op_return_type<vf64<long double>, int>(); | |
233 | binary_op_return_type<vf64<long double>, uint>(); | |
234 | binary_op_return_type<vf64<long double>, long>(); | |
235 | binary_op_return_type<vf64<long double>, ulong>(); | |
236 | binary_op_return_type<vf64<long double>, float>(); | |
237 | binary_op_return_type<vf64<long double>, double>(); | |
238 | binary_op_return_type<vf64<long double>, vf64<long double>>(); | |
239 | ||
240 | using std::experimental::simd; | |
241 | using A = simd_abi::fixed_size<vldouble::size()>; | |
242 | binary_op_return_type<simd<long double, A>, schar>(); | |
243 | binary_op_return_type<simd<long double, A>, uchar>(); | |
244 | binary_op_return_type<simd<long double, A>, short>(); | |
245 | binary_op_return_type<simd<long double, A>, ushort>(); | |
246 | binary_op_return_type<simd<long double, A>, int>(); | |
247 | binary_op_return_type<simd<long double, A>, uint>(); | |
248 | binary_op_return_type<simd<long double, A>, long>(); | |
249 | binary_op_return_type<simd<long double, A>, ulong>(); | |
250 | binary_op_return_type<simd<long double, A>, float>(); | |
251 | binary_op_return_type<simd<long double, A>, double>(); | |
252 | ||
253 | if constexpr (sizeof(ldouble) == sizeof(double)) | |
254 | { | |
255 | VERIFY((is_substitution_failure<vldouble, llong>)); | |
256 | VERIFY((is_substitution_failure<vldouble, ullong>)); | |
257 | VERIFY((is_substitution_failure<vf64<ldouble>, llong>)); | |
258 | VERIFY((is_substitution_failure<vf64<ldouble>, ullong>)); | |
259 | VERIFY((is_substitution_failure<simd<ldouble, A>, llong>)); | |
260 | VERIFY((is_substitution_failure<simd<ldouble, A>, ullong>)); | |
261 | } | |
262 | else | |
263 | { | |
264 | binary_op_return_type<vldouble, llong>(); | |
265 | binary_op_return_type<vldouble, ullong>(); | |
266 | binary_op_return_type<vf64<long double>, llong>(); | |
267 | binary_op_return_type<vf64<long double>, ullong>(); | |
268 | binary_op_return_type<simd<long double, A>, llong>(); | |
269 | binary_op_return_type<simd<long double, A>, ullong>(); | |
270 | } | |
271 | ||
272 | VERIFY((is_substitution_failure<vf64<long double>, vldouble>)); | |
273 | COMPARE((is_substitution_failure<simd<long double, A>, vldouble>), | |
274 | (!std::is_same<A, vldouble::abi_type>::value)); | |
275 | } | |
276 | else if constexpr (std::is_same_v<V, vlong>) | |
277 | { | |
278 | VERIFY((is_substitution_failure<vi32<long>, double>)); | |
279 | VERIFY((is_substitution_failure<vi32<long>, float>)); | |
280 | VERIFY((is_substitution_failure<vi32<long>, vi32<float>>)); | |
281 | if constexpr (sizeof(long) == sizeof(llong)) | |
282 | { | |
283 | binary_op_return_type<vlong, uint>(); | |
284 | binary_op_return_type<vlong, llong>(); | |
285 | binary_op_return_type<vi32<long>, uint>(); | |
286 | binary_op_return_type<vi32<long>, llong>(); | |
287 | binary_op_return_type<vi64<long>, uint>(); | |
288 | binary_op_return_type<vi64<long>, llong>(); | |
289 | binary_op_return_type<vi32<long>, vi32<uint>>(); | |
290 | binary_op_return_type<vi64<long>, vi64<uint>>(); | |
291 | VERIFY((is_substitution_failure<vi32<long>, vi32<double>>)); | |
292 | VERIFY((is_substitution_failure<vi64<long>, vi64<double>>)); | |
293 | } | |
294 | else | |
295 | { | |
296 | VERIFY((is_substitution_failure<vlong, uint>)); | |
297 | VERIFY((is_substitution_failure<vlong, llong>)); | |
298 | VERIFY((is_substitution_failure<vi32<long>, uint>)); | |
299 | VERIFY((is_substitution_failure<vi32<long>, llong>)); | |
300 | VERIFY((is_substitution_failure<vi64<long>, uint>)); | |
301 | VERIFY((is_substitution_failure<vi64<long>, llong>)); | |
302 | VERIFY((is_substitution_failure<vi32<long>, vi32<uint>>)); | |
303 | VERIFY((is_substitution_failure<vi64<long>, vi64<uint>>)); | |
304 | binary_op_return_type<vi32<double>, vi32<long>>(); | |
305 | binary_op_return_type<vi64<double>, vi64<long>>(); | |
306 | } | |
307 | ||
308 | binary_op_return_type<vlong, schar, vlong>(); | |
309 | binary_op_return_type<vlong, uchar, vlong>(); | |
310 | binary_op_return_type<vlong, short, vlong>(); | |
311 | binary_op_return_type<vlong, ushort, vlong>(); | |
312 | ||
313 | binary_op_return_type<vi32<long>, schar, vi32<long>>(); | |
314 | binary_op_return_type<vi32<long>, uchar, vi32<long>>(); | |
315 | binary_op_return_type<vi32<long>, short, vi32<long>>(); | |
316 | binary_op_return_type<vi32<long>, ushort, vi32<long>>(); | |
317 | binary_op_return_type<vi32<long>, int, vi32<long>>(); | |
318 | binary_op_return_type<vi32<long>, long, vi32<long>>(); | |
319 | binary_op_return_type<vi32<long>, vi32<long>, vi32<long>>(); | |
320 | binary_op_return_type<vi64<long>, schar, vi64<long>>(); | |
321 | binary_op_return_type<vi64<long>, uchar, vi64<long>>(); | |
322 | binary_op_return_type<vi64<long>, short, vi64<long>>(); | |
323 | binary_op_return_type<vi64<long>, ushort, vi64<long>>(); | |
324 | binary_op_return_type<vi64<long>, int, vi64<long>>(); | |
325 | binary_op_return_type<vi64<long>, long, vi64<long>>(); | |
326 | binary_op_return_type<vi64<long>, vi64<long>, vi64<long>>(); | |
327 | ||
328 | VERIFY((is_substitution_failure<vlong, vulong>)); | |
329 | VERIFY((is_substitution_failure<vlong, ulong>)); | |
330 | VERIFY((is_substitution_failure<vlong, ullong>)); | |
331 | VERIFY((is_substitution_failure<vlong, float>)); | |
332 | VERIFY((is_substitution_failure<vlong, double>)); | |
333 | VERIFY((is_substitution_failure<vlong, vl<schar>>)); | |
334 | VERIFY((is_substitution_failure<vlong, vl<uchar>>)); | |
335 | VERIFY((is_substitution_failure<vlong, vl<short>>)); | |
336 | VERIFY((is_substitution_failure<vlong, vl<ushort>>)); | |
337 | VERIFY((is_substitution_failure<vlong, vl<int>>)); | |
338 | VERIFY((is_substitution_failure<vlong, vl<uint>>)); | |
339 | VERIFY((is_substitution_failure<vlong, vl<long>>)); | |
340 | VERIFY((is_substitution_failure<vlong, vl<ulong>>)); | |
341 | VERIFY((is_substitution_failure<vlong, vl<llong>>)); | |
342 | VERIFY((is_substitution_failure<vlong, vl<ullong>>)); | |
343 | VERIFY((is_substitution_failure<vlong, vl<float>>)); | |
344 | VERIFY((is_substitution_failure<vlong, vl<double>>)); | |
345 | VERIFY((is_substitution_failure<vl<long>, vlong>)); | |
346 | VERIFY((is_substitution_failure<vl<long>, vulong>)); | |
347 | VERIFY((is_substitution_failure<vi32<long>, ulong>)); | |
348 | VERIFY((is_substitution_failure<vi32<long>, ullong>)); | |
349 | binary_op_return_type<vi32<long>, vi32<schar>>(); | |
350 | binary_op_return_type<vi32<long>, vi32<uchar>>(); | |
351 | binary_op_return_type<vi32<long>, vi32<short>>(); | |
352 | binary_op_return_type<vi32<long>, vi32<ushort>>(); | |
353 | binary_op_return_type<vi32<long>, vi32<int>>(); | |
354 | VERIFY((is_substitution_failure<vi32<long>, vi32<ulong>>)); | |
355 | VERIFY((is_substitution_failure<vi32<long>, vi32<ullong>>)); | |
356 | VERIFY((is_substitution_failure<vi64<long>, ulong>)); | |
357 | VERIFY((is_substitution_failure<vi64<long>, ullong>)); | |
358 | VERIFY((is_substitution_failure<vi64<long>, float>)); | |
359 | VERIFY((is_substitution_failure<vi64<long>, double>)); | |
360 | binary_op_return_type<vi64<long>, vi64<schar>>(); | |
361 | binary_op_return_type<vi64<long>, vi64<uchar>>(); | |
362 | binary_op_return_type<vi64<long>, vi64<short>>(); | |
363 | binary_op_return_type<vi64<long>, vi64<ushort>>(); | |
364 | binary_op_return_type<vi64<long>, vi64<int>>(); | |
365 | VERIFY((is_substitution_failure<vi64<long>, vi64<ulong>>)); | |
366 | VERIFY((is_substitution_failure<vi64<long>, vi64<ullong>>)); | |
367 | VERIFY((is_substitution_failure<vi64<long>, vi64<float>>)); | |
368 | ||
369 | binary_op_return_type<vi32<llong>, vi32<long>>(); | |
370 | binary_op_return_type<vi64<llong>, vi64<long>>(); | |
371 | } | |
372 | else if constexpr (std::is_same_v<V, vulong>) | |
373 | { | |
374 | if constexpr (sizeof(long) == sizeof(llong)) | |
375 | { | |
376 | binary_op_return_type<vulong, ullong, vulong>(); | |
377 | binary_op_return_type<vi32<ulong>, ullong, vi32<ulong>>(); | |
378 | binary_op_return_type<vi64<ulong>, ullong, vi64<ulong>>(); | |
379 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<llong>>)); | |
380 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<double>>)); | |
381 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<llong>>)); | |
382 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<double>>)); | |
383 | } | |
384 | else | |
385 | { | |
386 | VERIFY((is_substitution_failure<vulong, ullong>)); | |
387 | VERIFY((is_substitution_failure<vi32<ulong>, ullong>)); | |
388 | VERIFY((is_substitution_failure<vi64<ulong>, ullong>)); | |
389 | binary_op_return_type<vi32<llong>, vi32<ulong>>(); | |
390 | binary_op_return_type<vi32<double>, vi32<ulong>>(); | |
391 | binary_op_return_type<vi64<llong>, vi64<ulong>>(); | |
392 | binary_op_return_type<vi64<double>, vi64<ulong>>(); | |
393 | } | |
394 | ||
395 | binary_op_return_type<vulong, uchar, vulong>(); | |
396 | binary_op_return_type<vulong, ushort, vulong>(); | |
397 | binary_op_return_type<vulong, uint, vulong>(); | |
398 | binary_op_return_type<vi32<ulong>, uchar, vi32<ulong>>(); | |
399 | binary_op_return_type<vi32<ulong>, ushort, vi32<ulong>>(); | |
400 | binary_op_return_type<vi32<ulong>, int, vi32<ulong>>(); | |
401 | binary_op_return_type<vi32<ulong>, uint, vi32<ulong>>(); | |
402 | binary_op_return_type<vi32<ulong>, ulong, vi32<ulong>>(); | |
403 | binary_op_return_type<vi32<ulong>, vi32<ulong>, vi32<ulong>>(); | |
404 | binary_op_return_type<vi64<ulong>, uchar, vi64<ulong>>(); | |
405 | binary_op_return_type<vi64<ulong>, ushort, vi64<ulong>>(); | |
406 | binary_op_return_type<vi64<ulong>, int, vi64<ulong>>(); | |
407 | binary_op_return_type<vi64<ulong>, uint, vi64<ulong>>(); | |
408 | binary_op_return_type<vi64<ulong>, ulong, vi64<ulong>>(); | |
409 | binary_op_return_type<vi64<ulong>, vi64<ulong>, vi64<ulong>>(); | |
410 | ||
411 | VERIFY((is_substitution_failure<vi32<ulong>, llong>)); | |
412 | VERIFY((is_substitution_failure<vi32<ulong>, float>)); | |
413 | VERIFY((is_substitution_failure<vi32<ulong>, double>)); | |
414 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<float>>)); | |
415 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<float>>)); | |
416 | VERIFY((is_substitution_failure<vulong, schar>)); | |
417 | VERIFY((is_substitution_failure<vulong, short>)); | |
418 | VERIFY((is_substitution_failure<vulong, vlong>)); | |
419 | VERIFY((is_substitution_failure<vulong, long>)); | |
420 | VERIFY((is_substitution_failure<vulong, llong>)); | |
421 | VERIFY((is_substitution_failure<vulong, float>)); | |
422 | VERIFY((is_substitution_failure<vulong, double>)); | |
423 | VERIFY((is_substitution_failure<vulong, vl<schar>>)); | |
424 | VERIFY((is_substitution_failure<vulong, vl<uchar>>)); | |
425 | VERIFY((is_substitution_failure<vulong, vl<short>>)); | |
426 | VERIFY((is_substitution_failure<vulong, vl<ushort>>)); | |
427 | VERIFY((is_substitution_failure<vulong, vl<int>>)); | |
428 | VERIFY((is_substitution_failure<vulong, vl<uint>>)); | |
429 | VERIFY((is_substitution_failure<vulong, vl<long>>)); | |
430 | VERIFY((is_substitution_failure<vulong, vl<ulong>>)); | |
431 | VERIFY((is_substitution_failure<vulong, vl<llong>>)); | |
432 | VERIFY((is_substitution_failure<vulong, vl<ullong>>)); | |
433 | VERIFY((is_substitution_failure<vulong, vl<float>>)); | |
434 | VERIFY((is_substitution_failure<vulong, vl<double>>)); | |
435 | VERIFY((is_substitution_failure<vl<ulong>, vlong>)); | |
436 | VERIFY((is_substitution_failure<vl<ulong>, vulong>)); | |
437 | VERIFY((is_substitution_failure<vi32<ulong>, schar>)); | |
438 | VERIFY((is_substitution_failure<vi32<ulong>, short>)); | |
439 | VERIFY((is_substitution_failure<vi32<ulong>, long>)); | |
440 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<schar>>)); | |
441 | binary_op_return_type<vi32<ulong>, vi32<uchar>>(); | |
442 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<short>>)); | |
443 | binary_op_return_type<vi32<ulong>, vi32<ushort>>(); | |
444 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<int>>)); | |
445 | binary_op_return_type<vi32<ulong>, vi32<uint>>(); | |
446 | VERIFY((is_substitution_failure<vi32<ulong>, vi32<long>>)); | |
447 | binary_op_return_type<vi32<ullong>, vi32<ulong>>(); | |
448 | VERIFY((is_substitution_failure<vi64<ulong>, schar>)); | |
449 | VERIFY((is_substitution_failure<vi64<ulong>, short>)); | |
450 | VERIFY((is_substitution_failure<vi64<ulong>, long>)); | |
451 | VERIFY((is_substitution_failure<vi64<ulong>, llong>)); | |
452 | VERIFY((is_substitution_failure<vi64<ulong>, float>)); | |
453 | VERIFY((is_substitution_failure<vi64<ulong>, double>)); | |
454 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<schar>>)); | |
455 | binary_op_return_type<vi64<ulong>, vi64<uchar>>(); | |
456 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<short>>)); | |
457 | binary_op_return_type<vi64<ulong>, vi64<ushort>>(); | |
458 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<int>>)); | |
459 | binary_op_return_type<vi64<ulong>, vi64<uint>>(); | |
460 | VERIFY((is_substitution_failure<vi64<ulong>, vi64<long>>)); | |
461 | binary_op_return_type<vi64<ullong>, vi64<ulong>>(); | |
462 | } | |
463 | else if constexpr (std::is_same_v<V, vllong>) | |
464 | { | |
465 | binary_op_return_type<vllong, schar, vllong>(); | |
466 | binary_op_return_type<vllong, uchar, vllong>(); | |
467 | binary_op_return_type<vllong, short, vllong>(); | |
468 | binary_op_return_type<vllong, ushort, vllong>(); | |
469 | binary_op_return_type<vllong, uint, vllong>(); | |
470 | binary_op_return_type<vllong, long, vllong>(); | |
471 | binary_op_return_type<vi32<llong>, schar, vi32<llong>>(); | |
472 | binary_op_return_type<vi32<llong>, uchar, vi32<llong>>(); | |
473 | binary_op_return_type<vi32<llong>, short, vi32<llong>>(); | |
474 | binary_op_return_type<vi32<llong>, ushort, vi32<llong>>(); | |
475 | binary_op_return_type<vi32<llong>, int, vi32<llong>>(); | |
476 | binary_op_return_type<vi32<llong>, uint, vi32<llong>>(); | |
477 | binary_op_return_type<vi32<llong>, long, vi32<llong>>(); | |
478 | binary_op_return_type<vi32<llong>, llong, vi32<llong>>(); | |
479 | binary_op_return_type<vi32<llong>, vi32<llong>, vi32<llong>>(); | |
480 | binary_op_return_type<vi64<llong>, schar, vi64<llong>>(); | |
481 | binary_op_return_type<vi64<llong>, uchar, vi64<llong>>(); | |
482 | binary_op_return_type<vi64<llong>, short, vi64<llong>>(); | |
483 | binary_op_return_type<vi64<llong>, ushort, vi64<llong>>(); | |
484 | binary_op_return_type<vi64<llong>, int, vi64<llong>>(); | |
485 | binary_op_return_type<vi64<llong>, uint, vi64<llong>>(); | |
486 | binary_op_return_type<vi64<llong>, long, vi64<llong>>(); | |
487 | binary_op_return_type<vi64<llong>, llong, vi64<llong>>(); | |
488 | binary_op_return_type<vi64<llong>, vi64<llong>>(); | |
489 | binary_op_return_type<vi32<llong>, vi32<schar>>(); | |
490 | binary_op_return_type<vi32<llong>, vi32<uchar>>(); | |
491 | binary_op_return_type<vi32<llong>, vi32<short>>(); | |
492 | binary_op_return_type<vi32<llong>, vi32<ushort>>(); | |
493 | binary_op_return_type<vi32<llong>, vi32<int>>(); | |
494 | binary_op_return_type<vi32<llong>, vi32<uint>>(); | |
495 | binary_op_return_type<vi32<llong>, vi32<long>>(); | |
496 | if constexpr (sizeof(long) == sizeof(llong)) | |
497 | { | |
498 | VERIFY((is_substitution_failure<vi32<llong>, vi32<ulong>>)); | |
499 | VERIFY((is_substitution_failure<vi32<llong>, ulong>)); | |
500 | VERIFY((is_substitution_failure<vi64<llong>, ulong>)); | |
501 | VERIFY((is_substitution_failure<vllong, ulong>)); | |
502 | } | |
503 | else | |
504 | { | |
505 | binary_op_return_type<vi32<llong>, vi32<ulong>>(); | |
506 | binary_op_return_type<vi32<llong>, ulong>(); | |
507 | binary_op_return_type<vi64<llong>, ulong>(); | |
508 | binary_op_return_type<vllong, ulong>(); | |
509 | } | |
510 | ||
511 | VERIFY((is_substitution_failure<vllong, vullong>)); | |
512 | VERIFY((is_substitution_failure<vllong, ullong>)); | |
513 | VERIFY((is_substitution_failure<vllong, float>)); | |
514 | VERIFY((is_substitution_failure<vllong, double>)); | |
515 | VERIFY((is_substitution_failure<vllong, vi64<schar>>)); | |
516 | VERIFY((is_substitution_failure<vllong, vi64<uchar>>)); | |
517 | VERIFY((is_substitution_failure<vllong, vi64<short>>)); | |
518 | VERIFY((is_substitution_failure<vllong, vi64<ushort>>)); | |
519 | VERIFY((is_substitution_failure<vllong, vi64<int>>)); | |
520 | VERIFY((is_substitution_failure<vllong, vi64<uint>>)); | |
521 | VERIFY((is_substitution_failure<vllong, vi64<long>>)); | |
522 | VERIFY((is_substitution_failure<vllong, vi64<ulong>>)); | |
523 | VERIFY((is_substitution_failure<vllong, vi64<llong>>)); | |
524 | VERIFY((is_substitution_failure<vllong, vi64<ullong>>)); | |
525 | VERIFY((is_substitution_failure<vllong, vi64<float>>)); | |
526 | VERIFY((is_substitution_failure<vllong, vi64<double>>)); | |
527 | VERIFY((is_substitution_failure<vi32<llong>, ullong>)); | |
528 | VERIFY((is_substitution_failure<vi32<llong>, float>)); | |
529 | VERIFY((is_substitution_failure<vi32<llong>, double>)); | |
530 | VERIFY((is_substitution_failure<vi32<llong>, vi32<ullong>>)); | |
531 | VERIFY((is_substitution_failure<vi32<llong>, vi32<float>>)); | |
532 | VERIFY((is_substitution_failure<vi32<llong>, vi32<double>>)); | |
533 | VERIFY((is_substitution_failure<vi64<llong>, vllong>)); | |
534 | VERIFY((is_substitution_failure<vi64<llong>, vullong>)); | |
535 | VERIFY((is_substitution_failure<vi64<llong>, ullong>)); | |
536 | VERIFY((is_substitution_failure<vi64<llong>, float>)); | |
537 | VERIFY((is_substitution_failure<vi64<llong>, double>)); | |
538 | binary_op_return_type<vi64<llong>, vi64<schar>>(); | |
539 | binary_op_return_type<vi64<llong>, vi64<uchar>>(); | |
540 | binary_op_return_type<vi64<llong>, vi64<short>>(); | |
541 | binary_op_return_type<vi64<llong>, vi64<ushort>>(); | |
542 | binary_op_return_type<vi64<llong>, vi64<int>>(); | |
543 | binary_op_return_type<vi64<llong>, vi64<uint>>(); | |
544 | binary_op_return_type<vi64<llong>, vi64<long>>(); | |
545 | if constexpr (sizeof(long) == sizeof(llong)) | |
546 | { | |
547 | VERIFY((is_substitution_failure<vi64<llong>, vi64<ulong>>)); | |
548 | } | |
549 | else | |
550 | { | |
551 | binary_op_return_type<vi64<llong>, vi64<ulong>>(); | |
552 | } | |
553 | VERIFY((is_substitution_failure<vi64<llong>, vi64<ullong>>)); | |
554 | VERIFY((is_substitution_failure<vi64<llong>, vi64<float>>)); | |
555 | VERIFY((is_substitution_failure<vi64<llong>, vi64<double>>)); | |
556 | } | |
557 | else if constexpr (std::is_same_v<V, vullong>) | |
558 | { | |
559 | binary_op_return_type<vullong, uchar, vullong>(); | |
560 | binary_op_return_type<vullong, ushort, vullong>(); | |
561 | binary_op_return_type<vullong, uint, vullong>(); | |
562 | binary_op_return_type<vullong, ulong, vullong>(); | |
563 | binary_op_return_type<vi32<ullong>, uchar, vi32<ullong>>(); | |
564 | binary_op_return_type<vi32<ullong>, ushort, vi32<ullong>>(); | |
565 | binary_op_return_type<vi32<ullong>, int, vi32<ullong>>(); | |
566 | binary_op_return_type<vi32<ullong>, uint, vi32<ullong>>(); | |
567 | binary_op_return_type<vi32<ullong>, ulong, vi32<ullong>>(); | |
568 | binary_op_return_type<vi32<ullong>, ullong, vi32<ullong>>(); | |
569 | binary_op_return_type<vi32<ullong>, vi32<ullong>, vi32<ullong>>(); | |
570 | binary_op_return_type<vi64<ullong>, uchar, vi64<ullong>>(); | |
571 | binary_op_return_type<vi64<ullong>, ushort, vi64<ullong>>(); | |
572 | binary_op_return_type<vi64<ullong>, int, vi64<ullong>>(); | |
573 | binary_op_return_type<vi64<ullong>, uint, vi64<ullong>>(); | |
574 | binary_op_return_type<vi64<ullong>, ulong, vi64<ullong>>(); | |
575 | binary_op_return_type<vi64<ullong>, ullong, vi64<ullong>>(); | |
576 | binary_op_return_type<vi64<ullong>, vi64<ullong>, vi64<ullong>>(); | |
577 | ||
578 | VERIFY((is_substitution_failure<vullong, schar>)); | |
579 | VERIFY((is_substitution_failure<vullong, short>)); | |
580 | VERIFY((is_substitution_failure<vullong, long>)); | |
581 | VERIFY((is_substitution_failure<vullong, llong>)); | |
582 | VERIFY((is_substitution_failure<vullong, vllong>)); | |
583 | VERIFY((is_substitution_failure<vullong, float>)); | |
584 | VERIFY((is_substitution_failure<vullong, double>)); | |
585 | VERIFY((is_substitution_failure<vullong, vi64<schar>>)); | |
586 | VERIFY((is_substitution_failure<vullong, vi64<uchar>>)); | |
587 | VERIFY((is_substitution_failure<vullong, vi64<short>>)); | |
588 | VERIFY((is_substitution_failure<vullong, vi64<ushort>>)); | |
589 | VERIFY((is_substitution_failure<vullong, vi64<int>>)); | |
590 | VERIFY((is_substitution_failure<vullong, vi64<uint>>)); | |
591 | VERIFY((is_substitution_failure<vullong, vi64<long>>)); | |
592 | VERIFY((is_substitution_failure<vullong, vi64<ulong>>)); | |
593 | VERIFY((is_substitution_failure<vullong, vi64<llong>>)); | |
594 | VERIFY((is_substitution_failure<vullong, vi64<ullong>>)); | |
595 | VERIFY((is_substitution_failure<vullong, vi64<float>>)); | |
596 | VERIFY((is_substitution_failure<vullong, vi64<double>>)); | |
597 | VERIFY((is_substitution_failure<vi32<ullong>, schar>)); | |
598 | VERIFY((is_substitution_failure<vi32<ullong>, short>)); | |
599 | VERIFY((is_substitution_failure<vi32<ullong>, long>)); | |
600 | VERIFY((is_substitution_failure<vi32<ullong>, llong>)); | |
601 | VERIFY((is_substitution_failure<vi32<ullong>, float>)); | |
602 | VERIFY((is_substitution_failure<vi32<ullong>, double>)); | |
603 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<schar>>)); | |
604 | binary_op_return_type<vi32<ullong>, vi32<uchar>>(); | |
605 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<short>>)); | |
606 | binary_op_return_type<vi32<ullong>, vi32<ushort>>(); | |
607 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<int>>)); | |
608 | binary_op_return_type<vi32<ullong>, vi32<uint>>(); | |
609 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<long>>)); | |
610 | binary_op_return_type<vi32<ullong>, vi32<ulong>>(); | |
611 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<llong>>)); | |
612 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<float>>)); | |
613 | VERIFY((is_substitution_failure<vi32<ullong>, vi32<double>>)); | |
614 | VERIFY((is_substitution_failure<vi64<ullong>, schar>)); | |
615 | VERIFY((is_substitution_failure<vi64<ullong>, short>)); | |
616 | VERIFY((is_substitution_failure<vi64<ullong>, long>)); | |
617 | VERIFY((is_substitution_failure<vi64<ullong>, llong>)); | |
618 | VERIFY((is_substitution_failure<vi64<ullong>, vllong>)); | |
619 | VERIFY((is_substitution_failure<vi64<ullong>, vullong>)); | |
620 | VERIFY((is_substitution_failure<vi64<ullong>, float>)); | |
621 | VERIFY((is_substitution_failure<vi64<ullong>, double>)); | |
622 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<schar>>)); | |
623 | binary_op_return_type<vi64<ullong>, vi64<uchar>>(); | |
624 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<short>>)); | |
625 | binary_op_return_type<vi64<ullong>, vi64<ushort>>(); | |
626 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<int>>)); | |
627 | binary_op_return_type<vi64<ullong>, vi64<uint>>(); | |
628 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<long>>)); | |
629 | binary_op_return_type<vi64<ullong>, vi64<ulong>>(); | |
630 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<llong>>)); | |
631 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<float>>)); | |
632 | VERIFY((is_substitution_failure<vi64<ullong>, vi64<double>>)); | |
633 | } | |
634 | else if constexpr (std::is_same_v<V, vint>) | |
635 | { | |
636 | binary_op_return_type<vint, schar, vint>(); | |
637 | binary_op_return_type<vint, uchar, vint>(); | |
638 | binary_op_return_type<vint, short, vint>(); | |
639 | binary_op_return_type<vint, ushort, vint>(); | |
640 | binary_op_return_type<vi32<int>, schar, vi32<int>>(); | |
641 | binary_op_return_type<vi32<int>, uchar, vi32<int>>(); | |
642 | binary_op_return_type<vi32<int>, short, vi32<int>>(); | |
643 | binary_op_return_type<vi32<int>, ushort, vi32<int>>(); | |
644 | binary_op_return_type<vi32<int>, int, vi32<int>>(); | |
645 | binary_op_return_type<vi32<int>, vi32<int>, vi32<int>>(); | |
646 | binary_op_return_type<vi32<int>, vi32<schar>>(); | |
647 | binary_op_return_type<vi32<int>, vi32<uchar>>(); | |
648 | binary_op_return_type<vi32<int>, vi32<short>>(); | |
649 | binary_op_return_type<vi32<int>, vi32<ushort>>(); | |
650 | ||
651 | binary_op_return_type<vi32<llong>, vi32<int>>(); | |
652 | binary_op_return_type<vi32<double>, vi32<int>>(); | |
653 | ||
654 | // order is important for MSVC. This compiler is just crazy: It considers | |
655 | // operators from unrelated simd template instantiations as candidates - | |
656 | // but only after they have been tested. So e.g. vi32<int> + llong will | |
657 | // produce a vi32<llong> if a vi32<llong> operator test is done before the | |
658 | // vi32<int> + llong test. | |
659 | VERIFY((is_substitution_failure<vi32<int>, double>)); | |
660 | VERIFY((is_substitution_failure<vi32<int>, float>)); | |
661 | VERIFY((is_substitution_failure<vi32<int>, llong>)); | |
662 | VERIFY((is_substitution_failure<vi32<int>, vi32<float>>)); | |
663 | VERIFY((is_substitution_failure<vint, vuint>)); | |
664 | VERIFY((is_substitution_failure<vint, uint>)); | |
665 | VERIFY((is_substitution_failure<vint, ulong>)); | |
666 | VERIFY((is_substitution_failure<vint, llong>)); | |
667 | VERIFY((is_substitution_failure<vint, ullong>)); | |
668 | VERIFY((is_substitution_failure<vint, float>)); | |
669 | VERIFY((is_substitution_failure<vint, double>)); | |
670 | VERIFY((is_substitution_failure<vint, vi32<schar>>)); | |
671 | VERIFY((is_substitution_failure<vint, vi32<uchar>>)); | |
672 | VERIFY((is_substitution_failure<vint, vi32<short>>)); | |
673 | VERIFY((is_substitution_failure<vint, vi32<ushort>>)); | |
674 | VERIFY((is_substitution_failure<vint, vi32<int>>)); | |
675 | VERIFY((is_substitution_failure<vint, vi32<uint>>)); | |
676 | VERIFY((is_substitution_failure<vint, vi32<long>>)); | |
677 | VERIFY((is_substitution_failure<vint, vi32<ulong>>)); | |
678 | VERIFY((is_substitution_failure<vint, vi32<llong>>)); | |
679 | VERIFY((is_substitution_failure<vint, vi32<ullong>>)); | |
680 | VERIFY((is_substitution_failure<vint, vi32<float>>)); | |
681 | VERIFY((is_substitution_failure<vint, vi32<double>>)); | |
682 | VERIFY((is_substitution_failure<vi32<int>, vint>)); | |
683 | VERIFY((is_substitution_failure<vi32<int>, vuint>)); | |
684 | VERIFY((is_substitution_failure<vi32<int>, uint>)); | |
685 | VERIFY((is_substitution_failure<vi32<int>, ulong>)); | |
686 | VERIFY((is_substitution_failure<vi32<int>, ullong>)); | |
687 | VERIFY((is_substitution_failure<vi32<int>, vi32<uint>>)); | |
688 | VERIFY((is_substitution_failure<vi32<int>, vi32<ulong>>)); | |
689 | VERIFY((is_substitution_failure<vi32<int>, vi32<ullong>>)); | |
690 | ||
691 | binary_op_return_type<vi32<long>, vi32<int>>(); | |
692 | if constexpr (sizeof(long) == sizeof(llong)) | |
693 | { | |
694 | VERIFY((is_substitution_failure<vint, long>)); | |
695 | VERIFY((is_substitution_failure<vi32<int>, long>)); | |
696 | } | |
697 | else | |
698 | { | |
699 | binary_op_return_type<vint, long>(); | |
700 | binary_op_return_type<vi32<int>, long>(); | |
701 | } | |
702 | } | |
703 | else if constexpr (std::is_same_v<V, vuint>) | |
704 | { | |
705 | VERIFY((is_substitution_failure<vi32<uint>, llong>)); | |
706 | VERIFY((is_substitution_failure<vi32<uint>, ullong>)); | |
707 | VERIFY((is_substitution_failure<vi32<uint>, float>)); | |
708 | VERIFY((is_substitution_failure<vi32<uint>, double>)); | |
709 | VERIFY((is_substitution_failure<vi32<uint>, vi32<float>>)); | |
710 | ||
711 | binary_op_return_type<vuint, uchar, vuint>(); | |
712 | binary_op_return_type<vuint, ushort, vuint>(); | |
713 | binary_op_return_type<vi32<uint>, uchar, vi32<uint>>(); | |
714 | binary_op_return_type<vi32<uint>, ushort, vi32<uint>>(); | |
715 | binary_op_return_type<vi32<uint>, int, vi32<uint>>(); | |
716 | binary_op_return_type<vi32<uint>, uint, vi32<uint>>(); | |
717 | binary_op_return_type<vi32<uint>, vi32<uint>, vi32<uint>>(); | |
718 | binary_op_return_type<vi32<uint>, vi32<uchar>>(); | |
719 | binary_op_return_type<vi32<uint>, vi32<ushort>>(); | |
720 | ||
721 | binary_op_return_type<vi32<llong>, vi32<uint>>(); | |
722 | binary_op_return_type<vi32<ullong>, vi32<uint>>(); | |
723 | binary_op_return_type<vi32<double>, vi32<uint>>(); | |
724 | ||
725 | VERIFY((is_substitution_failure<vuint, schar>)); | |
726 | VERIFY((is_substitution_failure<vuint, short>)); | |
727 | VERIFY((is_substitution_failure<vuint, vint>)); | |
728 | VERIFY((is_substitution_failure<vuint, long>)); | |
729 | VERIFY((is_substitution_failure<vuint, llong>)); | |
730 | VERIFY((is_substitution_failure<vuint, ullong>)); | |
731 | VERIFY((is_substitution_failure<vuint, float>)); | |
732 | VERIFY((is_substitution_failure<vuint, double>)); | |
733 | VERIFY((is_substitution_failure<vuint, vi32<schar>>)); | |
734 | VERIFY((is_substitution_failure<vuint, vi32<uchar>>)); | |
735 | VERIFY((is_substitution_failure<vuint, vi32<short>>)); | |
736 | VERIFY((is_substitution_failure<vuint, vi32<ushort>>)); | |
737 | VERIFY((is_substitution_failure<vuint, vi32<int>>)); | |
738 | VERIFY((is_substitution_failure<vuint, vi32<uint>>)); | |
739 | VERIFY((is_substitution_failure<vuint, vi32<long>>)); | |
740 | VERIFY((is_substitution_failure<vuint, vi32<ulong>>)); | |
741 | VERIFY((is_substitution_failure<vuint, vi32<llong>>)); | |
742 | VERIFY((is_substitution_failure<vuint, vi32<ullong>>)); | |
743 | VERIFY((is_substitution_failure<vuint, vi32<float>>)); | |
744 | VERIFY((is_substitution_failure<vuint, vi32<double>>)); | |
745 | VERIFY((is_substitution_failure<vi32<uint>, schar>)); | |
746 | VERIFY((is_substitution_failure<vi32<uint>, short>)); | |
747 | VERIFY((is_substitution_failure<vi32<uint>, vint>)); | |
748 | VERIFY((is_substitution_failure<vi32<uint>, vuint>)); | |
749 | VERIFY((is_substitution_failure<vi32<uint>, long>)); | |
750 | VERIFY((is_substitution_failure<vi32<uint>, vi32<schar>>)); | |
751 | VERIFY((is_substitution_failure<vi32<uint>, vi32<short>>)); | |
752 | VERIFY((is_substitution_failure<vi32<uint>, vi32<int>>)); | |
753 | ||
754 | binary_op_return_type<vi32<ulong>, vi32<uint>>(); | |
755 | if constexpr (sizeof(long) == sizeof(llong)) | |
756 | { | |
757 | VERIFY((is_substitution_failure<vuint, ulong>)); | |
758 | VERIFY((is_substitution_failure<vi32<uint>, ulong>)); | |
759 | binary_op_return_type<vi32<long>, vi32<uint>>(); | |
760 | } | |
761 | else | |
762 | { | |
763 | binary_op_return_type<vuint, ulong>(); | |
764 | binary_op_return_type<vi32<uint>, ulong>(); | |
765 | VERIFY((is_substitution_failure<vi32<uint>, vi32<long>>)); | |
766 | } | |
767 | } | |
768 | else if constexpr (std::is_same_v<V, vshort>) | |
769 | { | |
770 | binary_op_return_type<vshort, schar, vshort>(); | |
771 | binary_op_return_type<vshort, uchar, vshort>(); | |
772 | binary_op_return_type<vi16<short>, schar, vi16<short>>(); | |
773 | binary_op_return_type<vi16<short>, uchar, vi16<short>>(); | |
774 | binary_op_return_type<vi16<short>, short, vi16<short>>(); | |
775 | binary_op_return_type<vi16<short>, int, vi16<short>>(); | |
776 | binary_op_return_type<vi16<short>, vi16<schar>>(); | |
777 | binary_op_return_type<vi16<short>, vi16<uchar>>(); | |
778 | binary_op_return_type<vi16<short>, vi16<short>>(); | |
779 | ||
780 | binary_op_return_type<vi16<int>, vi16<short>>(); | |
781 | binary_op_return_type<vi16<long>, vi16<short>>(); | |
782 | binary_op_return_type<vi16<llong>, vi16<short>>(); | |
783 | binary_op_return_type<vi16<float>, vi16<short>>(); | |
784 | binary_op_return_type<vi16<double>, vi16<short>>(); | |
785 | ||
786 | VERIFY((is_substitution_failure<vi16<short>, double>)); | |
787 | VERIFY((is_substitution_failure<vi16<short>, llong>)); | |
788 | VERIFY((is_substitution_failure<vshort, vushort>)); | |
789 | VERIFY((is_substitution_failure<vshort, ushort>)); | |
790 | VERIFY((is_substitution_failure<vshort, uint>)); | |
791 | VERIFY((is_substitution_failure<vshort, long>)); | |
792 | VERIFY((is_substitution_failure<vshort, ulong>)); | |
793 | VERIFY((is_substitution_failure<vshort, llong>)); | |
794 | VERIFY((is_substitution_failure<vshort, ullong>)); | |
795 | VERIFY((is_substitution_failure<vshort, float>)); | |
796 | VERIFY((is_substitution_failure<vshort, double>)); | |
797 | VERIFY((is_substitution_failure<vshort, vi16<schar>>)); | |
798 | VERIFY((is_substitution_failure<vshort, vi16<uchar>>)); | |
799 | VERIFY((is_substitution_failure<vshort, vi16<short>>)); | |
800 | VERIFY((is_substitution_failure<vshort, vi16<ushort>>)); | |
801 | VERIFY((is_substitution_failure<vshort, vi16<int>>)); | |
802 | VERIFY((is_substitution_failure<vshort, vi16<uint>>)); | |
803 | VERIFY((is_substitution_failure<vshort, vi16<long>>)); | |
804 | VERIFY((is_substitution_failure<vshort, vi16<ulong>>)); | |
805 | VERIFY((is_substitution_failure<vshort, vi16<llong>>)); | |
806 | VERIFY((is_substitution_failure<vshort, vi16<ullong>>)); | |
807 | VERIFY((is_substitution_failure<vshort, vi16<float>>)); | |
808 | VERIFY((is_substitution_failure<vshort, vi16<double>>)); | |
809 | VERIFY((is_substitution_failure<vi16<short>, vshort>)); | |
810 | VERIFY((is_substitution_failure<vi16<short>, vushort>)); | |
811 | VERIFY((is_substitution_failure<vi16<short>, ushort>)); | |
812 | VERIFY((is_substitution_failure<vi16<short>, uint>)); | |
813 | VERIFY((is_substitution_failure<vi16<short>, long>)); | |
814 | VERIFY((is_substitution_failure<vi16<short>, ulong>)); | |
815 | VERIFY((is_substitution_failure<vi16<short>, ullong>)); | |
816 | VERIFY((is_substitution_failure<vi16<short>, float>)); | |
817 | VERIFY((is_substitution_failure<vi16<short>, vi16<ushort>>)); | |
818 | VERIFY((is_substitution_failure<vi16<short>, vi16<uint>>)); | |
819 | VERIFY((is_substitution_failure<vi16<short>, vi16<ulong>>)); | |
820 | VERIFY((is_substitution_failure<vi16<short>, vi16<ullong>>)); | |
821 | } | |
822 | else if constexpr (std::is_same_v<V, vushort>) | |
823 | { | |
824 | binary_op_return_type<vushort, uchar, vushort>(); | |
825 | binary_op_return_type<vushort, uint, vushort>(); | |
826 | binary_op_return_type<vi16<ushort>, uchar, vi16<ushort>>(); | |
827 | binary_op_return_type<vi16<ushort>, ushort, vi16<ushort>>(); | |
828 | binary_op_return_type<vi16<ushort>, int, vi16<ushort>>(); | |
829 | binary_op_return_type<vi16<ushort>, uint, vi16<ushort>>(); | |
830 | binary_op_return_type<vi16<ushort>, vi16<uchar>>(); | |
831 | binary_op_return_type<vi16<ushort>, vi16<ushort>>(); | |
832 | ||
833 | binary_op_return_type<vi16<int>, vi16<ushort>>(); | |
834 | binary_op_return_type<vi16<long>, vi16<ushort>>(); | |
835 | binary_op_return_type<vi16<llong>, vi16<ushort>>(); | |
836 | binary_op_return_type<vi16<uint>, vi16<ushort>>(); | |
837 | binary_op_return_type<vi16<ulong>, vi16<ushort>>(); | |
838 | binary_op_return_type<vi16<ullong>, vi16<ushort>>(); | |
839 | binary_op_return_type<vi16<float>, vi16<ushort>>(); | |
840 | binary_op_return_type<vi16<double>, vi16<ushort>>(); | |
841 | ||
842 | VERIFY((is_substitution_failure<vi16<ushort>, llong>)); | |
843 | VERIFY((is_substitution_failure<vi16<ushort>, ullong>)); | |
844 | VERIFY((is_substitution_failure<vi16<ushort>, double>)); | |
845 | VERIFY((is_substitution_failure<vushort, schar>)); | |
846 | VERIFY((is_substitution_failure<vushort, short>)); | |
847 | VERIFY((is_substitution_failure<vushort, vshort>)); | |
848 | VERIFY((is_substitution_failure<vushort, long>)); | |
849 | VERIFY((is_substitution_failure<vushort, ulong>)); | |
850 | VERIFY((is_substitution_failure<vushort, llong>)); | |
851 | VERIFY((is_substitution_failure<vushort, ullong>)); | |
852 | VERIFY((is_substitution_failure<vushort, float>)); | |
853 | VERIFY((is_substitution_failure<vushort, double>)); | |
854 | VERIFY((is_substitution_failure<vushort, vi16<schar>>)); | |
855 | VERIFY((is_substitution_failure<vushort, vi16<uchar>>)); | |
856 | VERIFY((is_substitution_failure<vushort, vi16<short>>)); | |
857 | VERIFY((is_substitution_failure<vushort, vi16<ushort>>)); | |
858 | VERIFY((is_substitution_failure<vushort, vi16<int>>)); | |
859 | VERIFY((is_substitution_failure<vushort, vi16<uint>>)); | |
860 | VERIFY((is_substitution_failure<vushort, vi16<long>>)); | |
861 | VERIFY((is_substitution_failure<vushort, vi16<ulong>>)); | |
862 | VERIFY((is_substitution_failure<vushort, vi16<llong>>)); | |
863 | VERIFY((is_substitution_failure<vushort, vi16<ullong>>)); | |
864 | VERIFY((is_substitution_failure<vushort, vi16<float>>)); | |
865 | VERIFY((is_substitution_failure<vushort, vi16<double>>)); | |
866 | VERIFY((is_substitution_failure<vi16<ushort>, schar>)); | |
867 | VERIFY((is_substitution_failure<vi16<ushort>, short>)); | |
868 | VERIFY((is_substitution_failure<vi16<ushort>, vshort>)); | |
869 | VERIFY((is_substitution_failure<vi16<ushort>, vushort>)); | |
870 | VERIFY((is_substitution_failure<vi16<ushort>, long>)); | |
871 | VERIFY((is_substitution_failure<vi16<ushort>, ulong>)); | |
872 | VERIFY((is_substitution_failure<vi16<ushort>, float>)); | |
873 | VERIFY((is_substitution_failure<vi16<ushort>, vi16<schar>>)); | |
874 | VERIFY((is_substitution_failure<vi16<ushort>, vi16<short>>)); | |
875 | } | |
876 | else if constexpr (std::is_same_v<V, vchar>) | |
877 | { | |
878 | binary_op_return_type<vi8<char>, char, vi8<char>>(); | |
879 | binary_op_return_type<vi8<char>, int, vi8<char>>(); | |
880 | binary_op_return_type<vi8<char>, vi8<char>, vi8<char>>(); | |
881 | ||
882 | if constexpr (vi8<schar>::size() <= simd_abi::max_fixed_size<short>) | |
883 | { | |
884 | VERIFY(!(is_substitution_failure<vi8<char>, vi8<short>>)); | |
885 | VERIFY(!(is_substitution_failure<vi8<char>, vi8<int>>)); | |
886 | VERIFY(!(is_substitution_failure<vi8<char>, vi8<long>>)); | |
887 | VERIFY(!(is_substitution_failure<vi8<char>, vi8<llong>>)); | |
888 | COMPARE((is_substitution_failure<vi8<char>, vi8<ushort>>), | |
889 | std::is_signed_v<char>); | |
890 | COMPARE((is_substitution_failure<vi8<char>, vi8<uint>>), | |
891 | std::is_signed_v<char>); | |
892 | COMPARE((is_substitution_failure<vi8<char>, vi8<ulong>>), | |
893 | std::is_signed_v<char>); | |
894 | COMPARE((is_substitution_failure<vi8<char>, vi8<ullong>>), | |
895 | std::is_signed_v<char>); | |
896 | if constexpr (std::is_signed_v<char>) | |
897 | { | |
898 | binary_op_return_type<vi8<short>, vi8<char>>(); | |
899 | binary_op_return_type<vi8<int>, vi8<char>>(); | |
900 | binary_op_return_type<vi8<long>, vi8<char>>(); | |
901 | binary_op_return_type<vi8<llong>, vi8<char>>(); | |
902 | } | |
903 | else | |
904 | { | |
905 | binary_op_return_type<vi8<ushort>, vi8<char>>(); | |
906 | binary_op_return_type<vi8<uint>, vi8<char>>(); | |
907 | binary_op_return_type<vi8<ulong>, vi8<char>>(); | |
908 | binary_op_return_type<vi8<ullong>, vi8<char>>(); | |
909 | } | |
910 | binary_op_return_type<vi8<float>, vi8<char>>(); | |
911 | binary_op_return_type<vi8<double>, vi8<char>>(); | |
912 | } | |
913 | ||
914 | VERIFY((is_substitution_failure<vi8<char>, llong>)); | |
915 | VERIFY((is_substitution_failure<vi8<char>, double>)); | |
916 | VERIFY((is_substitution_failure<vchar, vxchar>)); | |
917 | VERIFY((is_substitution_failure<vchar, xchar>)); | |
918 | VERIFY((is_substitution_failure<vchar, short>)); | |
919 | VERIFY((is_substitution_failure<vchar, ushort>)); | |
920 | COMPARE((is_substitution_failure<vchar, uint>), std::is_signed_v<char>); | |
921 | VERIFY((is_substitution_failure<vchar, long>)); | |
922 | VERIFY((is_substitution_failure<vchar, ulong>)); | |
923 | VERIFY((is_substitution_failure<vchar, llong>)); | |
924 | VERIFY((is_substitution_failure<vchar, ullong>)); | |
925 | VERIFY((is_substitution_failure<vchar, float>)); | |
926 | VERIFY((is_substitution_failure<vchar, double>)); | |
927 | VERIFY((is_substitution_failure<vchar, vi8<char>>)); | |
928 | VERIFY((is_substitution_failure<vchar, vi8<uchar>>)); | |
929 | VERIFY((is_substitution_failure<vchar, vi8<schar>>)); | |
930 | VERIFY((is_substitution_failure<vchar, vi8<short>>)); | |
931 | VERIFY((is_substitution_failure<vchar, vi8<ushort>>)); | |
932 | VERIFY((is_substitution_failure<vchar, vi8<int>>)); | |
933 | VERIFY((is_substitution_failure<vchar, vi8<uint>>)); | |
934 | VERIFY((is_substitution_failure<vchar, vi8<long>>)); | |
935 | VERIFY((is_substitution_failure<vchar, vi8<ulong>>)); | |
936 | VERIFY((is_substitution_failure<vchar, vi8<llong>>)); | |
937 | VERIFY((is_substitution_failure<vchar, vi8<ullong>>)); | |
938 | VERIFY((is_substitution_failure<vchar, vi8<float>>)); | |
939 | VERIFY((is_substitution_failure<vchar, vi8<double>>)); | |
940 | VERIFY((is_substitution_failure<vi8<char>, vchar>)); | |
941 | VERIFY((is_substitution_failure<vi8<char>, vuchar>)); | |
942 | VERIFY((is_substitution_failure<vi8<char>, vschar>)); | |
943 | VERIFY((is_substitution_failure<vi8<char>, xchar>)); | |
944 | VERIFY((is_substitution_failure<vi8<char>, short>)); | |
945 | VERIFY((is_substitution_failure<vi8<char>, ushort>)); | |
946 | COMPARE((is_substitution_failure<vi8<char>, uint>), | |
947 | std::is_signed_v<char>); | |
948 | VERIFY((is_substitution_failure<vi8<char>, long>)); | |
949 | VERIFY((is_substitution_failure<vi8<char>, ulong>)); | |
950 | VERIFY((is_substitution_failure<vi8<char>, ullong>)); | |
951 | VERIFY((is_substitution_failure<vi8<char>, float>)); | |
952 | ||
953 | // conversion between any char types must fail because the dst type's | |
954 | // integer conversion rank isn't greater (as required by 9.6.4p4.3) | |
955 | VERIFY((is_substitution_failure<vi8<char>, vi8<schar>>)); | |
956 | VERIFY((is_substitution_failure<vi8<char>, vi8<uchar>>)); | |
957 | } | |
958 | else if constexpr (std::is_same_v<V, vschar>) | |
959 | { | |
960 | binary_op_return_type<vi8<schar>, schar, vi8<schar>>(); | |
961 | binary_op_return_type<vi8<schar>, int, vi8<schar>>(); | |
962 | binary_op_return_type<vi8<schar>, vi8<schar>, vi8<schar>>(); | |
963 | ||
964 | if constexpr (vi8<schar>::size() <= simd_abi::max_fixed_size<short>) | |
965 | { | |
966 | binary_op_return_type<vi8<short>, vi8<schar>>(); | |
967 | binary_op_return_type<vi8<int>, vi8<schar>>(); | |
968 | binary_op_return_type<vi8<long>, vi8<schar>>(); | |
969 | binary_op_return_type<vi8<llong>, vi8<schar>>(); | |
970 | binary_op_return_type<vi8<float>, vi8<schar>>(); | |
971 | binary_op_return_type<vi8<double>, vi8<schar>>(); | |
972 | } | |
973 | ||
974 | VERIFY((is_substitution_failure<vi8<schar>, llong>)); | |
975 | VERIFY((is_substitution_failure<vi8<schar>, double>)); | |
976 | VERIFY((is_substitution_failure<vschar, vuchar>)); | |
977 | VERIFY((is_substitution_failure<vschar, uchar>)); | |
978 | VERIFY((is_substitution_failure<vschar, short>)); | |
979 | VERIFY((is_substitution_failure<vschar, ushort>)); | |
980 | VERIFY((is_substitution_failure<vschar, uint>)); | |
981 | VERIFY((is_substitution_failure<vschar, long>)); | |
982 | VERIFY((is_substitution_failure<vschar, ulong>)); | |
983 | VERIFY((is_substitution_failure<vschar, llong>)); | |
984 | VERIFY((is_substitution_failure<vschar, ullong>)); | |
985 | VERIFY((is_substitution_failure<vschar, float>)); | |
986 | VERIFY((is_substitution_failure<vschar, double>)); | |
987 | VERIFY((is_substitution_failure<vschar, vi8<schar>>)); | |
988 | VERIFY((is_substitution_failure<vschar, vi8<uchar>>)); | |
989 | VERIFY((is_substitution_failure<vschar, vi8<short>>)); | |
990 | VERIFY((is_substitution_failure<vschar, vi8<ushort>>)); | |
991 | VERIFY((is_substitution_failure<vschar, vi8<int>>)); | |
992 | VERIFY((is_substitution_failure<vschar, vi8<uint>>)); | |
993 | VERIFY((is_substitution_failure<vschar, vi8<long>>)); | |
994 | VERIFY((is_substitution_failure<vschar, vi8<ulong>>)); | |
995 | VERIFY((is_substitution_failure<vschar, vi8<llong>>)); | |
996 | VERIFY((is_substitution_failure<vschar, vi8<ullong>>)); | |
997 | VERIFY((is_substitution_failure<vschar, vi8<float>>)); | |
998 | VERIFY((is_substitution_failure<vschar, vi8<double>>)); | |
999 | VERIFY((is_substitution_failure<vi8<schar>, vschar>)); | |
1000 | VERIFY((is_substitution_failure<vi8<schar>, vuchar>)); | |
1001 | VERIFY((is_substitution_failure<vi8<schar>, uchar>)); | |
1002 | VERIFY((is_substitution_failure<vi8<schar>, short>)); | |
1003 | VERIFY((is_substitution_failure<vi8<schar>, ushort>)); | |
1004 | VERIFY((is_substitution_failure<vi8<schar>, uint>)); | |
1005 | VERIFY((is_substitution_failure<vi8<schar>, long>)); | |
1006 | VERIFY((is_substitution_failure<vi8<schar>, ulong>)); | |
1007 | VERIFY((is_substitution_failure<vi8<schar>, ullong>)); | |
1008 | VERIFY((is_substitution_failure<vi8<schar>, float>)); | |
1009 | VERIFY((is_substitution_failure<vi8<schar>, vi8<uchar>>)); | |
1010 | VERIFY((is_substitution_failure<vi8<schar>, vi8<ushort>>)); | |
1011 | VERIFY((is_substitution_failure<vi8<schar>, vi8<uint>>)); | |
1012 | VERIFY((is_substitution_failure<vi8<schar>, vi8<ulong>>)); | |
1013 | VERIFY((is_substitution_failure<vi8<schar>, vi8<ullong>>)); | |
1014 | } | |
1015 | else if constexpr (std::is_same_v<V, vuchar>) | |
1016 | { | |
1017 | VERIFY((is_substitution_failure<vi8<uchar>, llong>)); | |
1018 | ||
1019 | binary_op_return_type<vuchar, uint, vuchar>(); | |
1020 | binary_op_return_type<vi8<uchar>, uchar, vi8<uchar>>(); | |
1021 | binary_op_return_type<vi8<uchar>, int, vi8<uchar>>(); | |
1022 | binary_op_return_type<vi8<uchar>, uint, vi8<uchar>>(); | |
1023 | binary_op_return_type<vi8<uchar>, vi8<uchar>, vi8<uchar>>(); | |
1024 | ||
1025 | if constexpr (vi8<schar>::size() <= simd_abi::max_fixed_size<short>) | |
1026 | { | |
1027 | binary_op_return_type<vi8<short>, vi8<uchar>>(); | |
1028 | binary_op_return_type<vi8<ushort>, vi8<uchar>>(); | |
1029 | binary_op_return_type<vi8<int>, vi8<uchar>>(); | |
1030 | binary_op_return_type<vi8<uint>, vi8<uchar>>(); | |
1031 | binary_op_return_type<vi8<long>, vi8<uchar>>(); | |
1032 | binary_op_return_type<vi8<ulong>, vi8<uchar>>(); | |
1033 | binary_op_return_type<vi8<llong>, vi8<uchar>>(); | |
1034 | binary_op_return_type<vi8<ullong>, vi8<uchar>>(); | |
1035 | binary_op_return_type<vi8<float>, vi8<uchar>>(); | |
1036 | binary_op_return_type<vi8<double>, vi8<uchar>>(); | |
1037 | } | |
1038 | ||
1039 | VERIFY((is_substitution_failure<vi8<uchar>, ullong>)); | |
1040 | VERIFY((is_substitution_failure<vi8<uchar>, double>)); | |
1041 | VERIFY((is_substitution_failure<vuchar, schar>)); | |
1042 | VERIFY((is_substitution_failure<vuchar, vschar>)); | |
1043 | VERIFY((is_substitution_failure<vuchar, short>)); | |
1044 | VERIFY((is_substitution_failure<vuchar, ushort>)); | |
1045 | VERIFY((is_substitution_failure<vuchar, long>)); | |
1046 | VERIFY((is_substitution_failure<vuchar, ulong>)); | |
1047 | VERIFY((is_substitution_failure<vuchar, llong>)); | |
1048 | VERIFY((is_substitution_failure<vuchar, ullong>)); | |
1049 | VERIFY((is_substitution_failure<vuchar, float>)); | |
1050 | VERIFY((is_substitution_failure<vuchar, double>)); | |
1051 | VERIFY((is_substitution_failure<vuchar, vi8<schar>>)); | |
1052 | VERIFY((is_substitution_failure<vuchar, vi8<uchar>>)); | |
1053 | VERIFY((is_substitution_failure<vuchar, vi8<short>>)); | |
1054 | VERIFY((is_substitution_failure<vuchar, vi8<ushort>>)); | |
1055 | VERIFY((is_substitution_failure<vuchar, vi8<int>>)); | |
1056 | VERIFY((is_substitution_failure<vuchar, vi8<uint>>)); | |
1057 | VERIFY((is_substitution_failure<vuchar, vi8<long>>)); | |
1058 | VERIFY((is_substitution_failure<vuchar, vi8<ulong>>)); | |
1059 | VERIFY((is_substitution_failure<vuchar, vi8<llong>>)); | |
1060 | VERIFY((is_substitution_failure<vuchar, vi8<ullong>>)); | |
1061 | VERIFY((is_substitution_failure<vuchar, vi8<float>>)); | |
1062 | VERIFY((is_substitution_failure<vuchar, vi8<double>>)); | |
1063 | VERIFY((is_substitution_failure<vi8<uchar>, schar>)); | |
1064 | VERIFY((is_substitution_failure<vi8<uchar>, vschar>)); | |
1065 | VERIFY((is_substitution_failure<vi8<uchar>, vuchar>)); | |
1066 | VERIFY((is_substitution_failure<vi8<uchar>, short>)); | |
1067 | VERIFY((is_substitution_failure<vi8<uchar>, ushort>)); | |
1068 | VERIFY((is_substitution_failure<vi8<uchar>, long>)); | |
1069 | VERIFY((is_substitution_failure<vi8<uchar>, ulong>)); | |
1070 | VERIFY((is_substitution_failure<vi8<uchar>, float>)); | |
1071 | VERIFY((is_substitution_failure<vi8<uchar>, vi8<schar>>)); | |
1072 | } | |
1073 | } |