libstdc++-v3/testsuite/experimental/simd/tests/operator_cvt.cc

   1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
   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
  18 // expensive: * [1-9] * *
  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   }