1 // RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -Wno-bit-int-extension %s 2 // RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -Wno-bit-int-extension -triple ppc64-unknown-linux %s 3 // RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -Wno-bit-int-extension -triple ppc64le-unknown-linux %s 4 5 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 6 #define LITTLE_END 1 7 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 8 #define LITTLE_END 0 9 #else 10 #error "huh?" 11 #endif 12 13 // We also support _BitInt as long as it is >=8 and a power of 2. 14 typedef _BitInt(8) BitInt8; 15 typedef _BitInt(32) BitInt32; 16 typedef _BitInt(128) BitInt128; 17 18 typedef double vector4double __attribute__((__vector_size__(32))); 19 typedef float vector4float __attribute__((__vector_size__(16))); 20 typedef long long vector4long __attribute__((__vector_size__(32))); 21 typedef int vector4int __attribute__((__vector_size__(16))); 22 typedef unsigned long long vector4ulong __attribute__((__vector_size__(32))); 23 typedef unsigned int vector4uint __attribute__((__vector_size__(16))); 24 typedef short vector4short __attribute__((__vector_size__(8))); 25 typedef char vector4char __attribute__((__vector_size__(4))); 26 typedef BitInt8 vector4BitInt8 __attribute__((__vector_size__(4))); 27 typedef BitInt32 vector4BitInt32 __attribute__((__vector_size__(16))); 28 typedef BitInt128 vector4BitInt128 __attribute__((__vector_size__(64))); 29 typedef double vector8double __attribute__((__vector_size__(64))); 30 typedef float vector8float __attribute__((__vector_size__(32))); 31 typedef long long vector8long __attribute__((__vector_size__(64))); 32 typedef int vector8int __attribute__((__vector_size__(32))); 33 typedef short vector8short __attribute__((__vector_size__(16))); 34 typedef char vector8char __attribute__((__vector_size__(8))); 35 typedef BitInt8 vector8BitInt8 __attribute__((__vector_size__(8))); 36 typedef BitInt32 vector8BitInt32 __attribute__((__vector_size__(32))); 37 typedef BitInt128 vector8BitInt128 __attribute__((__vector_size__(128))); 38 39 #define CHECK_NUM(__size, __typeFrom, __typeTo, ...) \ 40 constexpr vector##__size##__typeTo \ 41 from_##vector##__size##__typeFrom##_to_##vector##__size##__typeTo##_var = \ 42 __builtin_convertvector((vector##__size##__typeFrom){__VA_ARGS__}, \ 43 vector##__size##__typeTo); 44 #define CHECK_TO_ALL_TYPES(__size, __typeFrom, ...) \ 45 CHECK_NUM(__size, __typeFrom, double, __VA_ARGS__) \ 46 CHECK_NUM(__size, __typeFrom, float, __VA_ARGS__) \ 47 CHECK_NUM(__size, __typeFrom, long, __VA_ARGS__) \ 48 CHECK_NUM(__size, __typeFrom, int, __VA_ARGS__) \ 49 CHECK_NUM(__size, __typeFrom, short, __VA_ARGS__) \ 50 CHECK_NUM(__size, __typeFrom, char, __VA_ARGS__) \ 51 CHECK_NUM(__size, __typeFrom, BitInt8, __VA_ARGS__) \ 52 CHECK_NUM(__size, __typeFrom, BitInt32, __VA_ARGS__) \ 53 CHECK_NUM(__size, __typeFrom, BitInt128, __VA_ARGS__) \ 54 static_assert( \ 55 __builtin_bit_cast( \ 56 unsigned, \ 57 __builtin_shufflevector( \ 58 from_vector##__size##__typeFrom##_to_vector##__size##char_var, \ 59 from_vector##__size##__typeFrom##_to_vector##__size##char_var, \ 60 0, 1, 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); \ 61 static_assert( \ 62 __builtin_bit_cast( \ 63 unsigned long long, \ 64 __builtin_shufflevector( \ 65 from_vector##__size##__typeFrom##_to_vector##__size##short_var, \ 66 from_vector##__size##__typeFrom##_to_vector##__size##short_var, \ 67 0, 1, 2, 3)) == \ 68 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 69 70 #define CHECK_ALL_COMBINATIONS(__size, ...) \ 71 CHECK_TO_ALL_TYPES(__size, double, __VA_ARGS__) \ 72 CHECK_TO_ALL_TYPES(__size, float, __VA_ARGS__) \ 73 CHECK_TO_ALL_TYPES(__size, long, __VA_ARGS__) \ 74 CHECK_TO_ALL_TYPES(__size, int, __VA_ARGS__) \ 75 CHECK_TO_ALL_TYPES(__size, short, __VA_ARGS__) \ 76 CHECK_TO_ALL_TYPES(__size, char, __VA_ARGS__) \ 77 CHECK_TO_ALL_TYPES(__size, BitInt8, __VA_ARGS__) \ 78 CHECK_TO_ALL_TYPES(__size, BitInt32, __VA_ARGS__) \ 79 CHECK_TO_ALL_TYPES(__size, BitInt128, __VA_ARGS__) 80 81 // The result below is expanded from these macros. Use them to autogenerate the 82 // test cases below. 83 // CHECK_ALL_COMBINATIONS(4, 0, 1, 2, 3); 84 // CHECK_ALL_COMBINATIONS(8, 0, 1, 2, 3, 4, 5, 6, 7); 85 86 constexpr vector4double from_vector4double_to_vector4double_var = 87 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4double); 88 constexpr vector4float from_vector4double_to_vector4float_var = 89 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4float); 90 constexpr vector4long from_vector4double_to_vector4long_var = 91 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4long); 92 constexpr vector4int from_vector4double_to_vector4int_var = 93 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4int); 94 constexpr vector4short from_vector4double_to_vector4short_var = 95 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4short); 96 constexpr vector4char from_vector4double_to_vector4char_var = 97 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4char); 98 constexpr vector4BitInt8 from_vector4double_to_vector4BitInt8_var = 99 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4BitInt8); 100 constexpr vector4BitInt32 from_vector4double_to_vector4BitInt32_var = 101 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4BitInt32); 102 constexpr vector4BitInt128 from_vector4double_to_vector4BitInt128_var = 103 __builtin_convertvector((vector4double){0, 1, 2, 3}, vector4BitInt128); 104 static_assert(__builtin_bit_cast( 105 unsigned, 106 __builtin_shufflevector(from_vector4double_to_vector4char_var, 107 from_vector4double_to_vector4char_var, 108 0, 1, 2, 3)) == 109 (LITTLE_END ? 0x03020100 : 0x00010203)); 110 static_assert(__builtin_bit_cast(unsigned long long, 111 __builtin_shufflevector( 112 from_vector4double_to_vector4short_var, 113 from_vector4double_to_vector4short_var, 0, 114 1, 2, 3)) == 115 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 116 constexpr vector4double from_vector4float_to_vector4double_var = 117 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4double); 118 constexpr vector4float from_vector4float_to_vector4float_var = 119 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4float); 120 constexpr vector4long from_vector4float_to_vector4long_var = 121 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4long); 122 constexpr vector4int from_vector4float_to_vector4int_var = 123 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4int); 124 constexpr vector4short from_vector4float_to_vector4short_var = 125 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4short); 126 constexpr vector4char from_vector4float_to_vector4char_var = 127 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4char); 128 constexpr vector4BitInt8 from_vector4float_to_vector4BitInt8_var = 129 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4BitInt8); 130 constexpr vector4BitInt32 from_vector4float_to_vector4BitInt32_var = 131 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4BitInt32); 132 constexpr vector4BitInt128 from_vector4float_to_vector4BitInt128_var = 133 __builtin_convertvector((vector4float){0, 1, 2, 3}, vector4BitInt128); 134 static_assert(__builtin_bit_cast(unsigned, 135 __builtin_shufflevector( 136 from_vector4float_to_vector4char_var, 137 from_vector4float_to_vector4char_var, 0, 1, 138 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 139 static_assert(__builtin_bit_cast( 140 unsigned long long, 141 __builtin_shufflevector(from_vector4float_to_vector4short_var, 142 from_vector4float_to_vector4short_var, 143 0, 1, 2, 3)) == 144 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 145 constexpr vector4double from_vector4long_to_vector4double_var = 146 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4double); 147 constexpr vector4float from_vector4long_to_vector4float_var = 148 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4float); 149 constexpr vector4long from_vector4long_to_vector4long_var = 150 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4long); 151 constexpr vector4int from_vector4long_to_vector4int_var = 152 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4int); 153 constexpr vector4short from_vector4long_to_vector4short_var = 154 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4short); 155 constexpr vector4char from_vector4long_to_vector4char_var = 156 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4char); 157 constexpr vector4BitInt8 from_vector4long_to_vector4BitInt8_var = 158 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4BitInt8); 159 constexpr vector4BitInt32 from_vector4long_to_vector4BitInt32_var = 160 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4BitInt32); 161 constexpr vector4BitInt128 from_vector4long_to_vector4BitInt128_var = 162 __builtin_convertvector((vector4long){0, 1, 2, 3}, vector4BitInt128); 163 static_assert(__builtin_bit_cast(unsigned, 164 __builtin_shufflevector( 165 from_vector4long_to_vector4char_var, 166 from_vector4long_to_vector4char_var, 0, 1, 167 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 168 static_assert(__builtin_bit_cast( 169 unsigned long long, 170 __builtin_shufflevector(from_vector4long_to_vector4short_var, 171 from_vector4long_to_vector4short_var, 172 0, 1, 2, 3)) == 173 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 174 constexpr vector4double from_vector4int_to_vector4double_var = 175 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4double); 176 constexpr vector4float from_vector4int_to_vector4float_var = 177 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4float); 178 constexpr vector4long from_vector4int_to_vector4long_var = 179 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4long); 180 constexpr vector4int from_vector4int_to_vector4int_var = 181 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4int); 182 constexpr vector4short from_vector4int_to_vector4short_var = 183 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4short); 184 constexpr vector4char from_vector4int_to_vector4char_var = 185 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4char); 186 constexpr vector4BitInt8 from_vector4int_to_vector4BitInt8_var = 187 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4BitInt8); 188 constexpr vector4BitInt32 from_vector4int_to_vector4BitInt32_var = 189 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4BitInt32); 190 constexpr vector4BitInt128 from_vector4int_to_vector4BitInt128_var = 191 __builtin_convertvector((vector4int){0, 1, 2, 3}, vector4BitInt128); 192 static_assert(__builtin_bit_cast(unsigned, 193 __builtin_shufflevector( 194 from_vector4int_to_vector4char_var, 195 from_vector4int_to_vector4char_var, 0, 1, 196 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 197 static_assert(__builtin_bit_cast( 198 unsigned long long, 199 __builtin_shufflevector(from_vector4int_to_vector4short_var, 200 from_vector4int_to_vector4short_var, 201 0, 1, 2, 3)) == 202 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 203 constexpr vector4double from_vector4short_to_vector4double_var = 204 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4double); 205 constexpr vector4float from_vector4short_to_vector4float_var = 206 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4float); 207 constexpr vector4long from_vector4short_to_vector4long_var = 208 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4long); 209 constexpr vector4int from_vector4short_to_vector4int_var = 210 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4int); 211 constexpr vector4short from_vector4short_to_vector4short_var = 212 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4short); 213 constexpr vector4char from_vector4short_to_vector4char_var = 214 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4char); 215 constexpr vector4BitInt8 from_vector4short_to_vector4BitInt8_var = 216 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4BitInt8); 217 constexpr vector4BitInt32 from_vector4short_to_vector4BitInt32_var = 218 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4BitInt32); 219 constexpr vector4BitInt128 from_vector4short_to_vector4BitInt128_var = 220 __builtin_convertvector((vector4short){0, 1, 2, 3}, vector4BitInt128); 221 static_assert(__builtin_bit_cast(unsigned, 222 __builtin_shufflevector( 223 from_vector4short_to_vector4char_var, 224 from_vector4short_to_vector4char_var, 0, 1, 225 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 226 static_assert(__builtin_bit_cast( 227 unsigned long long, 228 __builtin_shufflevector(from_vector4short_to_vector4short_var, 229 from_vector4short_to_vector4short_var, 230 0, 1, 2, 3)) == 231 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 232 constexpr vector4double from_vector4char_to_vector4double_var = 233 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4double); 234 constexpr vector4float from_vector4char_to_vector4float_var = 235 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4float); 236 constexpr vector4long from_vector4char_to_vector4long_var = 237 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4long); 238 constexpr vector4int from_vector4char_to_vector4int_var = 239 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4int); 240 constexpr vector4short from_vector4char_to_vector4short_var = 241 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4short); 242 constexpr vector4char from_vector4char_to_vector4char_var = 243 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4char); 244 constexpr vector4BitInt8 from_vector4char_to_vector4BitInt8_var = 245 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4BitInt8); 246 constexpr vector4BitInt32 from_vector4char_to_vector4BitInt32_var = 247 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4BitInt32); 248 constexpr vector4BitInt128 from_vector4char_to_vector4BitInt128_var = 249 __builtin_convertvector((vector4char){0, 1, 2, 3}, vector4BitInt128); 250 static_assert(__builtin_bit_cast(unsigned, 251 __builtin_shufflevector( 252 from_vector4char_to_vector4char_var, 253 from_vector4char_to_vector4char_var, 0, 1, 254 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 255 static_assert(__builtin_bit_cast( 256 unsigned long long, 257 __builtin_shufflevector(from_vector4char_to_vector4short_var, 258 from_vector4char_to_vector4short_var, 259 0, 1, 2, 3)) == 260 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 261 constexpr vector4double from_vector4BitInt8_to_vector4double_var = 262 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4double); 263 constexpr vector4float from_vector4BitInt8_to_vector4float_var = 264 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4float); 265 constexpr vector4long from_vector4BitInt8_to_vector4long_var = 266 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4long); 267 constexpr vector4int from_vector4BitInt8_to_vector4int_var = 268 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4int); 269 constexpr vector4short from_vector4BitInt8_to_vector4short_var = 270 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4short); 271 constexpr vector4char from_vector4BitInt8_to_vector4char_var = 272 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4char); 273 constexpr vector4BitInt8 from_vector4BitInt8_to_vector4BitInt8_var = 274 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4BitInt8); 275 constexpr vector4BitInt32 from_vector4BitInt8_to_vector4BitInt32_var = 276 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4BitInt32); 277 constexpr vector4BitInt128 from_vector4BitInt8_to_vector4BitInt128_var = 278 __builtin_convertvector((vector4BitInt8){0, 1, 2, 3}, vector4BitInt128); 279 static_assert(__builtin_bit_cast(unsigned, 280 __builtin_shufflevector( 281 from_vector4BitInt8_to_vector4char_var, 282 from_vector4BitInt8_to_vector4char_var, 0, 283 1, 2, 3)) == 284 (LITTLE_END ? 0x03020100 : 0x00010203)); 285 static_assert(__builtin_bit_cast(unsigned long long, 286 __builtin_shufflevector( 287 from_vector4BitInt8_to_vector4short_var, 288 from_vector4BitInt8_to_vector4short_var, 0, 289 1, 2, 3)) == 290 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 291 constexpr vector4double from_vector4BitInt32_to_vector4double_var = 292 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4double); 293 constexpr vector4float from_vector4BitInt32_to_vector4float_var = 294 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4float); 295 constexpr vector4long from_vector4BitInt32_to_vector4long_var = 296 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4long); 297 constexpr vector4int from_vector4BitInt32_to_vector4int_var = 298 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4int); 299 constexpr vector4short from_vector4BitInt32_to_vector4short_var = 300 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4short); 301 constexpr vector4char from_vector4BitInt32_to_vector4char_var = 302 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4char); 303 constexpr vector4BitInt8 from_vector4BitInt32_to_vector4BitInt8_var = 304 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4BitInt8); 305 constexpr vector4BitInt32 from_vector4BitInt32_to_vector4BitInt32_var = 306 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4BitInt32); 307 constexpr vector4BitInt128 from_vector4BitInt32_to_vector4BitInt128_var = 308 __builtin_convertvector((vector4BitInt32){0, 1, 2, 3}, vector4BitInt128); 309 static_assert(__builtin_bit_cast(unsigned, 310 __builtin_shufflevector( 311 from_vector4BitInt32_to_vector4char_var, 312 from_vector4BitInt32_to_vector4char_var, 0, 313 1, 2, 3)) == 314 (LITTLE_END ? 0x03020100 : 0x00010203)); 315 static_assert(__builtin_bit_cast(unsigned long long, 316 __builtin_shufflevector( 317 from_vector4BitInt32_to_vector4short_var, 318 from_vector4BitInt32_to_vector4short_var, 319 0, 1, 2, 3)) == 320 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 321 constexpr vector4double from_vector4BitInt128_to_vector4double_var = 322 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4double); 323 constexpr vector4float from_vector4BitInt128_to_vector4float_var = 324 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4float); 325 constexpr vector4long from_vector4BitInt128_to_vector4long_var = 326 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4long); 327 constexpr vector4int from_vector4BitInt128_to_vector4int_var = 328 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4int); 329 constexpr vector4short from_vector4BitInt128_to_vector4short_var = 330 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4short); 331 constexpr vector4char from_vector4BitInt128_to_vector4char_var = 332 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4char); 333 constexpr vector4BitInt8 from_vector4BitInt128_to_vector4BitInt8_var = 334 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4BitInt8); 335 constexpr vector4BitInt32 from_vector4BitInt128_to_vector4BitInt32_var = 336 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4BitInt32); 337 constexpr vector4BitInt128 from_vector4BitInt128_to_vector4BitInt128_var = 338 __builtin_convertvector((vector4BitInt128){0, 1, 2, 3}, vector4BitInt128); 339 static_assert(__builtin_bit_cast(unsigned, 340 __builtin_shufflevector( 341 from_vector4BitInt128_to_vector4char_var, 342 from_vector4BitInt128_to_vector4char_var, 343 0, 1, 2, 3)) == 344 (LITTLE_END ? 0x03020100 : 0x00010203)); 345 static_assert(__builtin_bit_cast(unsigned long long, 346 __builtin_shufflevector( 347 from_vector4BitInt128_to_vector4short_var, 348 from_vector4BitInt128_to_vector4short_var, 349 0, 1, 2, 3)) == 350 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 351 ; 352 constexpr vector8double from_vector8double_to_vector8double_var = 353 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 354 vector8double); 355 constexpr vector8float from_vector8double_to_vector8float_var = 356 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 357 vector8float); 358 constexpr vector8long from_vector8double_to_vector8long_var = 359 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 360 vector8long); 361 constexpr vector8int from_vector8double_to_vector8int_var = 362 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 363 vector8int); 364 constexpr vector8short from_vector8double_to_vector8short_var = 365 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 366 vector8short); 367 constexpr vector8char from_vector8double_to_vector8char_var = 368 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 369 vector8char); 370 constexpr vector8BitInt8 from_vector8double_to_vector8BitInt8_var = 371 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 372 vector8BitInt8); 373 constexpr vector8BitInt32 from_vector8double_to_vector8BitInt32_var = 374 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 375 vector8BitInt32); 376 constexpr vector8BitInt128 from_vector8double_to_vector8BitInt128_var = 377 __builtin_convertvector((vector8double){0, 1, 2, 3, 4, 5, 6, 7}, 378 vector8BitInt128); 379 static_assert(__builtin_bit_cast( 380 unsigned, 381 __builtin_shufflevector(from_vector8double_to_vector8char_var, 382 from_vector8double_to_vector8char_var, 383 0, 1, 2, 3)) == 384 (LITTLE_END ? 0x03020100 : 0x00010203)); 385 static_assert(__builtin_bit_cast(unsigned long long, 386 __builtin_shufflevector( 387 from_vector8double_to_vector8short_var, 388 from_vector8double_to_vector8short_var, 0, 389 1, 2, 3)) == 390 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 391 constexpr vector8double from_vector8float_to_vector8double_var = 392 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 393 vector8double); 394 constexpr vector8float from_vector8float_to_vector8float_var = 395 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 396 vector8float); 397 constexpr vector8long from_vector8float_to_vector8long_var = 398 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 399 vector8long); 400 constexpr vector8int from_vector8float_to_vector8int_var = 401 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, vector8int); 402 constexpr vector8short from_vector8float_to_vector8short_var = 403 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 404 vector8short); 405 constexpr vector8char from_vector8float_to_vector8char_var = 406 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 407 vector8char); 408 constexpr vector8BitInt8 from_vector8float_to_vector8BitInt8_var = 409 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 410 vector8BitInt8); 411 constexpr vector8BitInt32 from_vector8float_to_vector8BitInt32_var = 412 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 413 vector8BitInt32); 414 constexpr vector8BitInt128 from_vector8float_to_vector8BitInt128_var = 415 __builtin_convertvector((vector8float){0, 1, 2, 3, 4, 5, 6, 7}, 416 vector8BitInt128); 417 static_assert(__builtin_bit_cast(unsigned, 418 __builtin_shufflevector( 419 from_vector8float_to_vector8char_var, 420 from_vector8float_to_vector8char_var, 0, 1, 421 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 422 static_assert(__builtin_bit_cast( 423 unsigned long long, 424 __builtin_shufflevector(from_vector8float_to_vector8short_var, 425 from_vector8float_to_vector8short_var, 426 0, 1, 2, 3)) == 427 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 428 constexpr vector8double from_vector8long_to_vector8double_var = 429 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 430 vector8double); 431 constexpr vector8float from_vector8long_to_vector8float_var = 432 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 433 vector8float); 434 constexpr vector8long from_vector8long_to_vector8long_var = 435 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, vector8long); 436 constexpr vector8int from_vector8long_to_vector8int_var = 437 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, vector8int); 438 constexpr vector8short from_vector8long_to_vector8short_var = 439 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 440 vector8short); 441 constexpr vector8char from_vector8long_to_vector8char_var = 442 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, vector8char); 443 constexpr vector8BitInt8 from_vector8long_to_vector8BitInt8_var = 444 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 445 vector8BitInt8); 446 constexpr vector8BitInt32 from_vector8long_to_vector8BitInt32_var = 447 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 448 vector8BitInt32); 449 constexpr vector8BitInt128 from_vector8long_to_vector8BitInt128_var = 450 __builtin_convertvector((vector8long){0, 1, 2, 3, 4, 5, 6, 7}, 451 vector8BitInt128); 452 static_assert(__builtin_bit_cast(unsigned, 453 __builtin_shufflevector( 454 from_vector8long_to_vector8char_var, 455 from_vector8long_to_vector8char_var, 0, 1, 456 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 457 static_assert(__builtin_bit_cast( 458 unsigned long long, 459 __builtin_shufflevector(from_vector8long_to_vector8short_var, 460 from_vector8long_to_vector8short_var, 461 0, 1, 2, 3)) == 462 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 463 constexpr vector8double from_vector8int_to_vector8double_var = 464 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, 465 vector8double); 466 constexpr vector8float from_vector8int_to_vector8float_var = 467 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, vector8float); 468 constexpr vector8long from_vector8int_to_vector8long_var = 469 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, vector8long); 470 constexpr vector8int from_vector8int_to_vector8int_var = 471 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, vector8int); 472 constexpr vector8short from_vector8int_to_vector8short_var = 473 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, vector8short); 474 constexpr vector8char from_vector8int_to_vector8char_var = 475 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, vector8char); 476 constexpr vector8BitInt8 from_vector8int_to_vector8BitInt8_var = 477 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, 478 vector8BitInt8); 479 constexpr vector8BitInt32 from_vector8int_to_vector8BitInt32_var = 480 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, 481 vector8BitInt32); 482 constexpr vector8BitInt128 from_vector8int_to_vector8BitInt128_var = 483 __builtin_convertvector((vector8int){0, 1, 2, 3, 4, 5, 6, 7}, 484 vector8BitInt128); 485 static_assert(__builtin_bit_cast(unsigned, 486 __builtin_shufflevector( 487 from_vector8int_to_vector8char_var, 488 from_vector8int_to_vector8char_var, 0, 1, 489 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 490 static_assert(__builtin_bit_cast( 491 unsigned long long, 492 __builtin_shufflevector(from_vector8int_to_vector8short_var, 493 from_vector8int_to_vector8short_var, 494 0, 1, 2, 3)) == 495 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 496 constexpr vector8double from_vector8short_to_vector8double_var = 497 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 498 vector8double); 499 constexpr vector8float from_vector8short_to_vector8float_var = 500 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 501 vector8float); 502 constexpr vector8long from_vector8short_to_vector8long_var = 503 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 504 vector8long); 505 constexpr vector8int from_vector8short_to_vector8int_var = 506 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, vector8int); 507 constexpr vector8short from_vector8short_to_vector8short_var = 508 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 509 vector8short); 510 constexpr vector8char from_vector8short_to_vector8char_var = 511 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 512 vector8char); 513 constexpr vector8BitInt8 from_vector8short_to_vector8BitInt8_var = 514 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 515 vector8BitInt8); 516 constexpr vector8BitInt32 from_vector8short_to_vector8BitInt32_var = 517 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 518 vector8BitInt32); 519 constexpr vector8BitInt128 from_vector8short_to_vector8BitInt128_var = 520 __builtin_convertvector((vector8short){0, 1, 2, 3, 4, 5, 6, 7}, 521 vector8BitInt128); 522 static_assert(__builtin_bit_cast(unsigned, 523 __builtin_shufflevector( 524 from_vector8short_to_vector8char_var, 525 from_vector8short_to_vector8char_var, 0, 1, 526 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 527 static_assert(__builtin_bit_cast( 528 unsigned long long, 529 __builtin_shufflevector(from_vector8short_to_vector8short_var, 530 from_vector8short_to_vector8short_var, 531 0, 1, 2, 3)) == 532 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 533 constexpr vector8double from_vector8char_to_vector8double_var = 534 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 535 vector8double); 536 constexpr vector8float from_vector8char_to_vector8float_var = 537 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 538 vector8float); 539 constexpr vector8long from_vector8char_to_vector8long_var = 540 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, vector8long); 541 constexpr vector8int from_vector8char_to_vector8int_var = 542 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, vector8int); 543 constexpr vector8short from_vector8char_to_vector8short_var = 544 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 545 vector8short); 546 constexpr vector8char from_vector8char_to_vector8char_var = 547 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, vector8char); 548 constexpr vector8BitInt8 from_vector8char_to_vector8BitInt8_var = 549 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 550 vector8BitInt8); 551 constexpr vector8BitInt32 from_vector8char_to_vector8BitInt32_var = 552 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 553 vector8BitInt32); 554 constexpr vector8BitInt128 from_vector8char_to_vector8BitInt128_var = 555 __builtin_convertvector((vector8char){0, 1, 2, 3, 4, 5, 6, 7}, 556 vector8BitInt128); 557 static_assert(__builtin_bit_cast(unsigned, 558 __builtin_shufflevector( 559 from_vector8char_to_vector8char_var, 560 from_vector8char_to_vector8char_var, 0, 1, 561 2, 3)) == (LITTLE_END ? 0x03020100 : 0x00010203)); 562 static_assert(__builtin_bit_cast( 563 unsigned long long, 564 __builtin_shufflevector(from_vector8char_to_vector8short_var, 565 from_vector8char_to_vector8short_var, 566 0, 1, 2, 3)) == 567 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 568 constexpr vector8double from_vector8BitInt8_to_vector8double_var = 569 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 570 vector8double); 571 constexpr vector8float from_vector8BitInt8_to_vector8float_var = 572 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 573 vector8float); 574 constexpr vector8long from_vector8BitInt8_to_vector8long_var = 575 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 576 vector8long); 577 constexpr vector8int from_vector8BitInt8_to_vector8int_var = 578 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 579 vector8int); 580 constexpr vector8short from_vector8BitInt8_to_vector8short_var = 581 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 582 vector8short); 583 constexpr vector8char from_vector8BitInt8_to_vector8char_var = 584 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 585 vector8char); 586 constexpr vector8BitInt8 from_vector8BitInt8_to_vector8BitInt8_var = 587 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 588 vector8BitInt8); 589 constexpr vector8BitInt32 from_vector8BitInt8_to_vector8BitInt32_var = 590 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 591 vector8BitInt32); 592 constexpr vector8BitInt128 from_vector8BitInt8_to_vector8BitInt128_var = 593 __builtin_convertvector((vector8BitInt8){0, 1, 2, 3, 4, 5, 6, 7}, 594 vector8BitInt128); 595 static_assert(__builtin_bit_cast(unsigned, 596 __builtin_shufflevector( 597 from_vector8BitInt8_to_vector8char_var, 598 from_vector8BitInt8_to_vector8char_var, 0, 599 1, 2, 3)) == 600 (LITTLE_END ? 0x03020100 : 0x00010203)); 601 static_assert(__builtin_bit_cast(unsigned long long, 602 __builtin_shufflevector( 603 from_vector8BitInt8_to_vector8short_var, 604 from_vector8BitInt8_to_vector8short_var, 0, 605 1, 2, 3)) == 606 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 607 constexpr vector8double from_vector8BitInt32_to_vector8double_var = 608 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 609 vector8double); 610 constexpr vector8float from_vector8BitInt32_to_vector8float_var = 611 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 612 vector8float); 613 constexpr vector8long from_vector8BitInt32_to_vector8long_var = 614 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 615 vector8long); 616 constexpr vector8int from_vector8BitInt32_to_vector8int_var = 617 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 618 vector8int); 619 constexpr vector8short from_vector8BitInt32_to_vector8short_var = 620 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 621 vector8short); 622 constexpr vector8char from_vector8BitInt32_to_vector8char_var = 623 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 624 vector8char); 625 constexpr vector8BitInt8 from_vector8BitInt32_to_vector8BitInt8_var = 626 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 627 vector8BitInt8); 628 constexpr vector8BitInt32 from_vector8BitInt32_to_vector8BitInt32_var = 629 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 630 vector8BitInt32); 631 constexpr vector8BitInt128 from_vector8BitInt32_to_vector8BitInt128_var = 632 __builtin_convertvector((vector8BitInt32){0, 1, 2, 3, 4, 5, 6, 7}, 633 vector8BitInt128); 634 static_assert(__builtin_bit_cast(unsigned, 635 __builtin_shufflevector( 636 from_vector8BitInt32_to_vector8char_var, 637 from_vector8BitInt32_to_vector8char_var, 0, 638 1, 2, 3)) == 639 (LITTLE_END ? 0x03020100 : 0x00010203)); 640 static_assert(__builtin_bit_cast(unsigned long long, 641 __builtin_shufflevector( 642 from_vector8BitInt32_to_vector8short_var, 643 from_vector8BitInt32_to_vector8short_var, 644 0, 1, 2, 3)) == 645 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 646 constexpr vector8double from_vector8BitInt128_to_vector8double_var = 647 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 648 vector8double); 649 constexpr vector8float from_vector8BitInt128_to_vector8float_var = 650 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 651 vector8float); 652 constexpr vector8long from_vector8BitInt128_to_vector8long_var = 653 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 654 vector8long); 655 constexpr vector8int from_vector8BitInt128_to_vector8int_var = 656 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 657 vector8int); 658 constexpr vector8short from_vector8BitInt128_to_vector8short_var = 659 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 660 vector8short); 661 constexpr vector8char from_vector8BitInt128_to_vector8char_var = 662 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 663 vector8char); 664 constexpr vector8BitInt8 from_vector8BitInt128_to_vector8BitInt8_var = 665 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 666 vector8BitInt8); 667 constexpr vector8BitInt32 from_vector8BitInt128_to_vector8BitInt32_var = 668 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 669 vector8BitInt32); 670 constexpr vector8BitInt128 from_vector8BitInt128_to_vector8BitInt128_var = 671 __builtin_convertvector((vector8BitInt128){0, 1, 2, 3, 4, 5, 6, 7}, 672 vector8BitInt128); 673 static_assert(__builtin_bit_cast(unsigned, 674 __builtin_shufflevector( 675 from_vector8BitInt128_to_vector8char_var, 676 from_vector8BitInt128_to_vector8char_var, 677 0, 1, 2, 3)) == 678 (LITTLE_END ? 0x03020100 : 0x00010203)); 679 static_assert(__builtin_bit_cast(unsigned long long, 680 __builtin_shufflevector( 681 from_vector8BitInt128_to_vector8short_var, 682 from_vector8BitInt128_to_vector8short_var, 683 0, 1, 2, 3)) == 684 (LITTLE_END ? 0x0003000200010000 : 0x0000000100020003)); 685 ; 686 #undef CHECK_ALL_COMBINATIONS 687 #undef CHECK_TO_ALL_TYPES 688 #undef CHECK_NUM 689 690 // Shuffle vector 691 constexpr vector4char vector4charConst1 = {0, 1, 2, 3}; 692 constexpr vector4char vector4charConst2 = {4, 5, 6, 7}; 693 constexpr vector8char vector8intConst = {8, 9, 10, 11, 12, 13, 14, 15}; 694 695 constexpr vector4char vectorShuffle1 = 696 __builtin_shufflevector(vector4charConst1, vector4charConst2, 0, 1, 2, 3); 697 static_assert(__builtin_bit_cast(unsigned, vectorShuffle1) == 698 (LITTLE_END ? 0x03020100 : 0x00010203)); 699 constexpr vector4char vectorShuffle2 = 700 __builtin_shufflevector(vector4charConst1, vector4charConst2, 4, 5, 6, 7); 701 static_assert(__builtin_bit_cast(unsigned, vectorShuffle2) == 702 (LITTLE_END ? 0x07060504 : 0x04050607)); 703 constexpr vector4char vectorShuffle3 = 704 __builtin_shufflevector(vector4charConst1, vector4charConst2, 0, 2, 4, 6); 705 static_assert(__builtin_bit_cast(unsigned, vectorShuffle3) == 706 (LITTLE_END ? 0x06040200 : 0x00020406)); 707 constexpr vector8char vectorShuffle4 = __builtin_shufflevector( 708 vector8intConst, vector8intConst, 0, 2, 4, 6, 8, 10, 12, 14); 709 static_assert(__builtin_bit_cast(unsigned long long, vectorShuffle4) == 710 (LITTLE_END ? 0x0E0C0A080E0C0A08 : 0x080A0C0E080A0C0E)); 711 constexpr vector4char vectorShuffle5 = 712 __builtin_shufflevector(vector8intConst, vector8intConst, 0, 2, 4, 6); 713 static_assert(__builtin_bit_cast(unsigned, vectorShuffle5) == 714 (LITTLE_END ? 0x0E0C0A08 : 0x080A0C0E)); 715 constexpr vector8char vectorShuffle6 = __builtin_shufflevector( 716 vector4charConst1, vector4charConst2, 0, 2, 4, 6, 1, 3, 5, 7); 717 static_assert(__builtin_bit_cast(unsigned long long, vectorShuffle6) == 718 (LITTLE_END ? 0x0705030106040200 : 0x0002040601030507)); 719 720 constexpr vector4char 721 vectorShuffleFail1 = // expected-error {{constexpr variable 'vectorShuffleFail1'\ 722 must be initialized by a constant expression}} 723 __builtin_shufflevector( // expected-error {{index for __builtin_shufflevector \ 724 not within the bounds of the input vectors; index of -1 found at position 0 is not \ 725 permitted in a constexpr context}} 726 vector4charConst1, 727 vector4charConst2, -1, -1, -1, -1); 728 729 static_assert(__builtin_reduce_add((vector4char){}) == 0); 730 static_assert(__builtin_reduce_add((vector4char){1, 2, 3, 4}) == 10); 731 static_assert(__builtin_reduce_add((vector4short){10, 20, 30, 40}) == 100); 732 static_assert(__builtin_reduce_add((vector4int){100, 200, 300, 400}) == 1000); 733 static_assert(__builtin_reduce_add((vector4long){1000, 2000, 3000, 4000}) == 10000); 734 constexpr int reduceAddInt1 = __builtin_reduce_add((vector4int){~(1 << 31), 0, 0, 1}); 735 // expected-error@-1 {{must be initialized by a constant expression}} \ 736 // expected-note@-1 {{outside the range of representable values of type 'int'}} 737 constexpr long long reduceAddLong1 = __builtin_reduce_add((vector4long){~(1LL << 63), 0, 0, 1}); 738 // expected-error@-1 {{must be initialized by a constant expression}} \ 739 // expected-note@-1 {{outside the range of representable values of type 'long long'}} 740 constexpr int reduceAddInt2 = __builtin_reduce_add((vector4int){(1 << 31), 0, 0, -1}); 741 // expected-error@-1 {{must be initialized by a constant expression}} \ 742 // expected-note@-1 {{outside the range of representable values of type 'int'}} 743 constexpr long long reduceAddLong2 = __builtin_reduce_add((vector4long){(1LL << 63), 0, 0, -1}); 744 // expected-error@-1 {{must be initialized by a constant expression}} \ 745 // expected-note@-1 {{outside the range of representable values of type 'long long'}} 746 static_assert(__builtin_reduce_add((vector4uint){~0U, 0, 0, 1}) == 0); 747 static_assert(__builtin_reduce_add((vector4ulong){~0ULL, 0, 0, 1}) == 0); 748 749 static_assert(__builtin_reduce_mul((vector4char){}) == 0); 750 static_assert(__builtin_reduce_mul((vector4char){1, 2, 3, 4}) == 24); 751 static_assert(__builtin_reduce_mul((vector4short){1, 2, 30, 40}) == 2400); 752 static_assert(__builtin_reduce_mul((vector4int){10, 20, 300, 400}) == 24000000); 753 static_assert(__builtin_reduce_mul((vector4long){1000L, 2000L, 3000L, 4000L}) == 24000000000000L); 754 constexpr int reduceMulInt1 = __builtin_reduce_mul((vector4int){~(1 << 31), 1, 1, 2}); 755 // expected-error@-1 {{must be initialized by a constant expression}} \ 756 // expected-note@-1 {{outside the range of representable values of type 'int'}} 757 constexpr long long reduceMulLong1 = __builtin_reduce_mul((vector4long){~(1LL << 63), 1, 1, 2}); 758 // expected-error@-1 {{must be initialized by a constant expression}} \ 759 // expected-note@-1 {{outside the range of representable values of type 'long long'}} 760 constexpr int reduceMulInt2 = __builtin_reduce_mul((vector4int){(1 << 31), 1, 1, 2}); 761 // expected-error@-1 {{must be initialized by a constant expression}} \ 762 // expected-note@-1 {{outside the range of representable values of type 'int'}} 763 constexpr long long reduceMulLong2 = __builtin_reduce_mul((vector4long){(1LL << 63), 1, 1, 2}); 764 // expected-error@-1 {{must be initialized by a constant expression}} \ 765 // expected-note@-1 {{outside the range of representable values of type 'long long'}} 766 static_assert(__builtin_reduce_mul((vector4uint){~0U, 1, 1, 2}) == ~0U - 1); 767 static_assert(__builtin_reduce_mul((vector4ulong){~0ULL, 1, 1, 2}) == ~0ULL - 1); 768 769 static_assert(__builtin_reduce_and((vector4char){}) == 0); 770 static_assert(__builtin_reduce_and((vector4char){(char)0x11, (char)0x22, (char)0x44, (char)0x88}) == 0); 771 static_assert(__builtin_reduce_and((vector4short){(short)0x1111, (short)0x2222, (short)0x4444, (short)0x8888}) == 0); 772 static_assert(__builtin_reduce_and((vector4int){(int)0x11111111, (int)0x22222222, (int)0x44444444, (int)0x88888888}) == 0); 773 static_assert(__builtin_reduce_and((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0x8888888888888888L}) == 0L); 774 static_assert(__builtin_reduce_and((vector4char){(char)-1, (char)~0x22, (char)~0x44, (char)~0x88}) == 0x11); 775 static_assert(__builtin_reduce_and((vector4short){(short)~0x1111, (short)-1, (short)~0x4444, (short)~0x8888}) == 0x2222); 776 static_assert(__builtin_reduce_and((vector4int){(int)~0x11111111, (int)~0x22222222, (int)-1, (int)~0x88888888}) == 0x44444444); 777 static_assert(__builtin_reduce_and((vector4long){(long long)~0x1111111111111111L, (long long)~0x2222222222222222L, (long long)~0x4444444444444444L, (long long)-1}) == 0x8888888888888888L); 778 static_assert(__builtin_reduce_and((vector4uint){0x11111111U, 0x22222222U, 0x44444444U, 0x88888888U}) == 0U); 779 static_assert(__builtin_reduce_and((vector4ulong){0x1111111111111111UL, 0x2222222222222222UL, 0x4444444444444444UL, 0x8888888888888888UL}) == 0L); 780 781 static_assert(__builtin_reduce_or((vector4char){}) == 0); 782 static_assert(__builtin_reduce_or((vector4char){(char)0x11, (char)0x22, (char)0x44, (char)0x88}) == (char)0xFF); 783 static_assert(__builtin_reduce_or((vector4short){(short)0x1111, (short)0x2222, (short)0x4444, (short)0x8888}) == (short)0xFFFF); 784 static_assert(__builtin_reduce_or((vector4int){(int)0x11111111, (int)0x22222222, (int)0x44444444, (int)0x88888888}) == (int)0xFFFFFFFF); 785 static_assert(__builtin_reduce_or((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0x8888888888888888L}) == (long long)0xFFFFFFFFFFFFFFFFL); 786 static_assert(__builtin_reduce_or((vector4char){(char)0, (char)0x22, (char)0x44, (char)0x88}) == ~0x11); 787 static_assert(__builtin_reduce_or((vector4short){(short)0x1111, (short)0, (short)0x4444, (short)0x8888}) == ~0x2222); 788 static_assert(__builtin_reduce_or((vector4int){(int)0x11111111, (int)0x22222222, (int)0, (int)0x88888888}) == ~0x44444444); 789 static_assert(__builtin_reduce_or((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0}) == ~0x8888888888888888L); 790 static_assert(__builtin_reduce_or((vector4uint){0x11111111U, 0x22222222U, 0x44444444U, 0x88888888U}) == 0xFFFFFFFFU); 791 static_assert(__builtin_reduce_or((vector4ulong){0x1111111111111111UL, 0x2222222222222222UL, 0x4444444444444444UL, 0x8888888888888888UL}) == 0xFFFFFFFFFFFFFFFFL); 792 793 static_assert(__builtin_reduce_xor((vector4char){}) == 0); 794 static_assert(__builtin_reduce_xor((vector4char){(char)0x11, (char)0x22, (char)0x44, (char)0x88}) == (char)0xFF); 795 static_assert(__builtin_reduce_xor((vector4short){(short)0x1111, (short)0x2222, (short)0x4444, (short)0x8888}) == (short)0xFFFF); 796 static_assert(__builtin_reduce_xor((vector4int){(int)0x11111111, (int)0x22222222, (int)0x44444444, (int)0x88888888}) == (int)0xFFFFFFFF); 797 static_assert(__builtin_reduce_xor((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0x8888888888888888L}) == (long long)0xFFFFFFFFFFFFFFFFL); 798 static_assert(__builtin_reduce_xor((vector4uint){0x11111111U, 0x22222222U, 0x44444444U, 0x88888888U}) == 0xFFFFFFFFU); 799 static_assert(__builtin_reduce_xor((vector4ulong){0x1111111111111111UL, 0x2222222222222222UL, 0x4444444444444444UL, 0x8888888888888888UL}) == 0xFFFFFFFFFFFFFFFFUL); 800 801 static_assert(__builtin_reduce_min((vector4char){}) == 0); 802 static_assert(__builtin_reduce_min((vector4char){(char)0x11, (char)0x22, (char)0x44, (char)0x88}) == (char)0x88); 803 static_assert(__builtin_reduce_min((vector4short){(short)0x1111, (short)0x2222, (short)0x4444, (short)0x8888}) == (short)0x8888); 804 static_assert(__builtin_reduce_min((vector4int){(int)0x11111111, (int)0x22222222, (int)0x44444444, (int)0x88888888}) == (int)0x88888888); 805 static_assert(__builtin_reduce_min((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0x8888888888888888L}) == (long long)0x8888888888888888L); 806 static_assert(__builtin_reduce_min((vector4uint){0x11111111U, 0x22222222U, 0x44444444U, 0x88888888U}) == 0x11111111U); 807 static_assert(__builtin_reduce_min((vector4ulong){0x1111111111111111UL, 0x2222222222222222UL, 0x4444444444444444UL, 0x8888888888888888UL}) == 0x1111111111111111UL); 808 static_assert(__builtin_reduce_max((vector4char){}) == 0); 809 static_assert(__builtin_reduce_max((vector4char){(char)0x11, (char)0x22, (char)0x44, (char)0x88}) == (char)0x44); 810 static_assert(__builtin_reduce_max((vector4short){(short)0x1111, (short)0x2222, (short)0x4444, (short)0x8888}) == (short)0x4444); 811 static_assert(__builtin_reduce_max((vector4int){(int)0x11111111, (int)0x22222222, (int)0x44444444, (int)0x88888888}) == (int)0x44444444); 812 static_assert(__builtin_reduce_max((vector4long){(long long)0x1111111111111111L, (long long)0x2222222222222222L, (long long)0x4444444444444444L, (long long)0x8888888888888888L}) == (long long)0x4444444444444444L); 813 static_assert(__builtin_reduce_max((vector4uint){0x11111111U, 0x22222222U, 0x44444444U, 0x88888888U}) == 0x88888888U); 814 static_assert(__builtin_reduce_max((vector4ulong){0x1111111111111111UL, 0x2222222222222222UL, 0x4444444444444444UL, 0x8888888888888888UL}) == 0x8888888888888888UL); 815 816 static_assert(__builtin_bit_cast(unsigned, __builtin_elementwise_popcount((vector4char){1, 2, 3, 4})) == (LITTLE_END ? 0x01020101 : 0x01010201)); 817 static_assert(__builtin_bit_cast(unsigned long long, __builtin_elementwise_popcount((vector4short){0, 0x0F0F, ~0, ~0x0F0F})) == (LITTLE_END ? 0x0008001000080000 : 0x0000000800100008)); 818 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4int){1, 2, 3, 4})) == 5); 819 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4int){0, 0xF0F0, ~0, ~0xF0F0})) == 16 * sizeof(int)); 820 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4long){1L, 2L, 3L, 4L})) == 5L); 821 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4long){0L, 0xF0F0L, ~0L, ~0xF0F0L})) == 16 * sizeof(long long)); 822 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4uint){1U, 2U, 3U, 4U})) == 5U); 823 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4uint){0U, 0xF0F0U, ~0U, ~0xF0F0U})) == 16 * sizeof(int)); 824 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4ulong){1UL, 2UL, 3UL, 4UL})) == 5UL); 825 static_assert(__builtin_reduce_add(__builtin_elementwise_popcount((vector4ulong){0ULL, 0xF0F0ULL, ~0ULL, ~0xF0F0ULL})) == 16 * sizeof(unsigned long long)); 826 static_assert(__builtin_elementwise_popcount(0) == 0); 827 static_assert(__builtin_elementwise_popcount(0xF0F0) == 8); 828 static_assert(__builtin_elementwise_popcount(~0) == 8 * sizeof(int)); 829 static_assert(__builtin_elementwise_popcount(0U) == 0); 830 static_assert(__builtin_elementwise_popcount(0xF0F0U) == 8); 831 static_assert(__builtin_elementwise_popcount(~0U) == 8 * sizeof(int)); 832 static_assert(__builtin_elementwise_popcount(0L) == 0); 833 static_assert(__builtin_elementwise_popcount(0xF0F0L) == 8); 834 static_assert(__builtin_elementwise_popcount(~0LL) == 8 * sizeof(long long)); 835 836 static_assert(__builtin_elementwise_bitreverse(0x12345678) == 0x1E6A2C48); 837 static_assert(__builtin_elementwise_bitreverse(0x0123456789ABCDEFULL) == 0xF7B3D591E6A2C480); 838 static_assert(__builtin_bit_cast(unsigned, __builtin_elementwise_bitreverse((vector4char){1, 2, 4, 8})) == (LITTLE_END ? 0x10204080 : 0x80402010)); 839 static_assert(__builtin_bit_cast(unsigned long long, __builtin_elementwise_bitreverse((vector4short){1, 2, 4, 8})) == (LITTLE_END ? 0x1000200040008000 : 0x8000400020001000)); 840 841 static_assert(__builtin_elementwise_add_sat(1, 2) == 3); 842 static_assert(__builtin_elementwise_add_sat(1U, 2U) == 3U); 843 static_assert(__builtin_elementwise_add_sat(~(1 << 31), 42) == ~(1 << 31)); 844 static_assert(__builtin_elementwise_add_sat((1 << 31), -42) == (1 << 31)); 845 static_assert(__builtin_elementwise_add_sat(~0U, 1U) == ~0U); 846 static_assert(__builtin_bit_cast(unsigned, __builtin_elementwise_add_sat((vector4char){1, 2, 3, 4}, (vector4char){1, 2, 3, 4})) == (LITTLE_END ? 0x08060402 : 0x02040608)); 847 static_assert(__builtin_bit_cast(unsigned long long, __builtin_elementwise_add_sat((vector4short){(short)0x8000, (short)0x8001, (short)0x8002, (short)0x8003}, (vector4short){-7, -8, -9, -10}) == (LITTLE_END ? 0x8000800080008000 : 0x8000800080008000))); 848 849 static_assert(__builtin_elementwise_sub_sat(1, 2) == -1); 850 static_assert(__builtin_elementwise_sub_sat(2U, 1U) == 1U); 851 static_assert(__builtin_elementwise_sub_sat(~(1 << 31), -42) == ~(1 << 31)); 852 static_assert(__builtin_elementwise_sub_sat((1 << 31), 42) == (1 << 31)); 853 static_assert(__builtin_elementwise_sub_sat(0U, 1U) == 0U); 854 static_assert(__builtin_bit_cast(unsigned, __builtin_elementwise_sub_sat((vector4char){5, 4, 3, 2}, (vector4char){1, 1, 1, 1})) == (LITTLE_END ? 0x01020304 : 0x04030201)); 855 static_assert(__builtin_bit_cast(unsigned long long, __builtin_elementwise_sub_sat((vector4short){(short)0x8000, (short)0x8001, (short)0x8002, (short)0x8003}, (vector4short){7, 8, 9, 10}) == (LITTLE_END ? 0x8000800080008000 : 0x8000800080008000))); 856