1 // RUN: %clang_cc1 -triple thumbv7s-apple-darwin -target-abi apcs-gnu\ 2 // RUN: -target-cpu swift -ffreestanding -Os -S -o - %s\ 3 // RUN: | FileCheck %s 4 5 // REQUIRES: long_tests 6 7 #include <arm_neon.h> 8 9 // CHECK: test_vaba_s8 10 // CHECK: vaba.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11 int8x8_t test_vaba_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 12 return vaba_s8(a, b, c); 13 } 14 15 // CHECK: test_vaba_s16 16 // CHECK: vaba.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 17 int16x4_t test_vaba_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 18 return vaba_s16(a, b, c); 19 } 20 21 // CHECK: test_vaba_s32 22 // CHECK: vaba.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 23 int32x2_t test_vaba_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 24 return vaba_s32(a, b, c); 25 } 26 27 // CHECK: test_vaba_u8 28 // CHECK: vaba.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 29 uint8x8_t test_vaba_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 30 return vaba_u8(a, b, c); 31 } 32 33 // CHECK: test_vaba_u16 34 // CHECK: vaba.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 35 uint16x4_t test_vaba_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 36 return vaba_u16(a, b, c); 37 } 38 39 // CHECK: test_vaba_u32 40 // CHECK: vaba.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 41 uint32x2_t test_vaba_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 42 return vaba_u32(a, b, c); 43 } 44 45 // CHECK: test_vabaq_s8 46 // CHECK: vaba.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 47 int8x16_t test_vabaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 48 return vabaq_s8(a, b, c); 49 } 50 51 // CHECK: test_vabaq_s16 52 // CHECK: vaba.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 53 int16x8_t test_vabaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 54 return vabaq_s16(a, b, c); 55 } 56 57 // CHECK: test_vabaq_s32 58 // CHECK: vaba.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 59 int32x4_t test_vabaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 60 return vabaq_s32(a, b, c); 61 } 62 63 // CHECK: test_vabaq_u8 64 // CHECK: vaba.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 65 uint8x16_t test_vabaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 66 return vabaq_u8(a, b, c); 67 } 68 69 // CHECK: test_vabaq_u16 70 // CHECK: vaba.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 71 uint16x8_t test_vabaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 72 return vabaq_u16(a, b, c); 73 } 74 75 // CHECK: test_vabaq_u32 76 // CHECK: vaba.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 77 uint32x4_t test_vabaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 78 return vabaq_u32(a, b, c); 79 } 80 81 82 // CHECK: test_vabal_s8 83 // CHECK: vabal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 84 int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 85 return vabal_s8(a, b, c); 86 } 87 88 // CHECK: test_vabal_s16 89 // CHECK: vabal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 90 int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 91 return vabal_s16(a, b, c); 92 } 93 94 // CHECK: test_vabal_s32 95 // CHECK: vabal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 96 int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 97 return vabal_s32(a, b, c); 98 } 99 100 // CHECK: test_vabal_u8 101 // CHECK: vabal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 102 uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 103 return vabal_u8(a, b, c); 104 } 105 106 // CHECK: test_vabal_u16 107 // CHECK: vabal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 108 uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 109 return vabal_u16(a, b, c); 110 } 111 112 // CHECK: test_vabal_u32 113 // CHECK: vabal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 114 uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 115 return vabal_u32(a, b, c); 116 } 117 118 119 // CHECK: test_vabd_s8 120 // CHECK: vabd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 121 int8x8_t test_vabd_s8(int8x8_t a, int8x8_t b) { 122 return vabd_s8(a, b); 123 } 124 125 // CHECK: test_vabd_s16 126 // CHECK: vabd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 127 int16x4_t test_vabd_s16(int16x4_t a, int16x4_t b) { 128 return vabd_s16(a, b); 129 } 130 131 // CHECK: test_vabd_s32 132 // CHECK: vabd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 133 int32x2_t test_vabd_s32(int32x2_t a, int32x2_t b) { 134 return vabd_s32(a, b); 135 } 136 137 // CHECK: test_vabd_u8 138 // CHECK: vabd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 139 uint8x8_t test_vabd_u8(uint8x8_t a, uint8x8_t b) { 140 return vabd_u8(a, b); 141 } 142 143 // CHECK: test_vabd_u16 144 // CHECK: vabd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 145 uint16x4_t test_vabd_u16(uint16x4_t a, uint16x4_t b) { 146 return vabd_u16(a, b); 147 } 148 149 // CHECK: test_vabd_u32 150 // CHECK: vabd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 151 uint32x2_t test_vabd_u32(uint32x2_t a, uint32x2_t b) { 152 return vabd_u32(a, b); 153 } 154 155 // CHECK: test_vabd_f32 156 // CHECK: vabd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 157 float32x2_t test_vabd_f32(float32x2_t a, float32x2_t b) { 158 return vabd_f32(a, b); 159 } 160 161 // CHECK: test_vabdq_s8 162 // CHECK: vabd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 163 int8x16_t test_vabdq_s8(int8x16_t a, int8x16_t b) { 164 return vabdq_s8(a, b); 165 } 166 167 // CHECK: test_vabdq_s16 168 // CHECK: vabd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 169 int16x8_t test_vabdq_s16(int16x8_t a, int16x8_t b) { 170 return vabdq_s16(a, b); 171 } 172 173 // CHECK: test_vabdq_s32 174 // CHECK: vabd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 175 int32x4_t test_vabdq_s32(int32x4_t a, int32x4_t b) { 176 return vabdq_s32(a, b); 177 } 178 179 // CHECK: test_vabdq_u8 180 // CHECK: vabd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 181 uint8x16_t test_vabdq_u8(uint8x16_t a, uint8x16_t b) { 182 return vabdq_u8(a, b); 183 } 184 185 // CHECK: test_vabdq_u16 186 // CHECK: vabd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 187 uint16x8_t test_vabdq_u16(uint16x8_t a, uint16x8_t b) { 188 return vabdq_u16(a, b); 189 } 190 191 // CHECK: test_vabdq_u32 192 // CHECK: vabd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 193 uint32x4_t test_vabdq_u32(uint32x4_t a, uint32x4_t b) { 194 return vabdq_u32(a, b); 195 } 196 197 // CHECK: test_vabdq_f32 198 // CHECK: vabd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 199 float32x4_t test_vabdq_f32(float32x4_t a, float32x4_t b) { 200 return vabdq_f32(a, b); 201 } 202 203 204 // CHECK: test_vabdl_s8 205 // CHECK: vabdl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 206 int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) { 207 return vabdl_s8(a, b); 208 } 209 210 // CHECK: test_vabdl_s16 211 // CHECK: vabdl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 212 int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) { 213 return vabdl_s16(a, b); 214 } 215 216 // CHECK: test_vabdl_s32 217 // CHECK: vabdl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 218 int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) { 219 return vabdl_s32(a, b); 220 } 221 222 // CHECK: test_vabdl_u8 223 // CHECK: vabdl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 224 uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) { 225 return vabdl_u8(a, b); 226 } 227 228 // CHECK: test_vabdl_u16 229 // CHECK: vabdl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 230 uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) { 231 return vabdl_u16(a, b); 232 } 233 234 // CHECK: test_vabdl_u32 235 // CHECK: vabdl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 236 uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) { 237 return vabdl_u32(a, b); 238 } 239 240 241 // CHECK: test_vabs_s8 242 // CHECK: vabs.s8 d{{[0-9]+}}, d{{[0-9]+}} 243 int8x8_t test_vabs_s8(int8x8_t a) { 244 return vabs_s8(a); 245 } 246 247 // CHECK: test_vabs_s16 248 // CHECK: vabs.s16 d{{[0-9]+}}, d{{[0-9]+}} 249 int16x4_t test_vabs_s16(int16x4_t a) { 250 return vabs_s16(a); 251 } 252 253 // CHECK: test_vabs_s32 254 // CHECK: vabs.s32 d{{[0-9]+}}, d{{[0-9]+}} 255 int32x2_t test_vabs_s32(int32x2_t a) { 256 return vabs_s32(a); 257 } 258 259 // CHECK: test_vabs_f32 260 // CHECK: vabs.f32 d{{[0-9]+}}, d{{[0-9]+}} 261 float32x2_t test_vabs_f32(float32x2_t a) { 262 return vabs_f32(a); 263 } 264 265 // CHECK: test_vabsq_s8 266 // CHECK: vabs.s8 q{{[0-9]+}}, q{{[0-9]+}} 267 int8x16_t test_vabsq_s8(int8x16_t a) { 268 return vabsq_s8(a); 269 } 270 271 // CHECK: test_vabsq_s16 272 // CHECK: vabs.s16 q{{[0-9]+}}, q{{[0-9]+}} 273 int16x8_t test_vabsq_s16(int16x8_t a) { 274 return vabsq_s16(a); 275 } 276 277 // CHECK: test_vabsq_s32 278 // CHECK: vabs.s32 q{{[0-9]+}}, q{{[0-9]+}} 279 int32x4_t test_vabsq_s32(int32x4_t a) { 280 return vabsq_s32(a); 281 } 282 283 // CHECK: test_vabsq_f32 284 // CHECK: vabs.f32 q{{[0-9]+}}, q{{[0-9]+}} 285 float32x4_t test_vabsq_f32(float32x4_t a) { 286 return vabsq_f32(a); 287 } 288 289 290 // CHECK: test_vadd_s8 291 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 292 int8x8_t test_vadd_s8(int8x8_t a, int8x8_t b) { 293 return vadd_s8(a, b); 294 } 295 296 // CHECK: test_vadd_s16 297 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 298 int16x4_t test_vadd_s16(int16x4_t a, int16x4_t b) { 299 return vadd_s16(a, b); 300 } 301 302 // CHECK: test_vadd_s32 303 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 304 int32x2_t test_vadd_s32(int32x2_t a, int32x2_t b) { 305 return vadd_s32(a, b); 306 } 307 308 // CHECK: test_vadd_s64 309 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 310 int64x1_t test_vadd_s64(int64x1_t a, int64x1_t b) { 311 return vadd_s64(a, b); 312 } 313 314 // CHECK: test_vadd_f32 315 // CHECK: vadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 316 float32x2_t test_vadd_f32(float32x2_t a, float32x2_t b) { 317 return vadd_f32(a, b); 318 } 319 320 // CHECK: test_vadd_u8 321 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 322 uint8x8_t test_vadd_u8(uint8x8_t a, uint8x8_t b) { 323 return vadd_u8(a, b); 324 } 325 326 // CHECK: test_vadd_u16 327 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 328 uint16x4_t test_vadd_u16(uint16x4_t a, uint16x4_t b) { 329 return vadd_u16(a, b); 330 } 331 332 // CHECK: test_vadd_u32 333 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 334 uint32x2_t test_vadd_u32(uint32x2_t a, uint32x2_t b) { 335 return vadd_u32(a, b); 336 } 337 338 // CHECK: test_vadd_u64 339 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 340 uint64x1_t test_vadd_u64(uint64x1_t a, uint64x1_t b) { 341 return vadd_u64(a, b); 342 } 343 344 // CHECK: test_vaddq_s8 345 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 346 int8x16_t test_vaddq_s8(int8x16_t a, int8x16_t b) { 347 return vaddq_s8(a, b); 348 } 349 350 // CHECK: test_vaddq_s16 351 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 352 int16x8_t test_vaddq_s16(int16x8_t a, int16x8_t b) { 353 return vaddq_s16(a, b); 354 } 355 356 // CHECK: test_vaddq_s32 357 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 358 int32x4_t test_vaddq_s32(int32x4_t a, int32x4_t b) { 359 return vaddq_s32(a, b); 360 } 361 362 // CHECK: test_vaddq_s64 363 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 364 int64x2_t test_vaddq_s64(int64x2_t a, int64x2_t b) { 365 return vaddq_s64(a, b); 366 } 367 368 // CHECK: test_vaddq_f32 369 // CHECK: vadd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 370 float32x4_t test_vaddq_f32(float32x4_t a, float32x4_t b) { 371 return vaddq_f32(a, b); 372 } 373 374 // CHECK: test_vaddq_u8 375 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 376 uint8x16_t test_vaddq_u8(uint8x16_t a, uint8x16_t b) { 377 return vaddq_u8(a, b); 378 } 379 380 // CHECK: test_vaddq_u16 381 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 382 uint16x8_t test_vaddq_u16(uint16x8_t a, uint16x8_t b) { 383 return vaddq_u16(a, b); 384 } 385 386 // CHECK: test_vaddq_u32 387 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 388 uint32x4_t test_vaddq_u32(uint32x4_t a, uint32x4_t b) { 389 return vaddq_u32(a, b); 390 } 391 392 // CHECK: test_vaddq_u64 393 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 394 uint64x2_t test_vaddq_u64(uint64x2_t a, uint64x2_t b) { 395 return vaddq_u64(a, b); 396 } 397 398 399 // CHECK: test_vaddhn_s16 400 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 401 int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) { 402 return vaddhn_s16(a, b); 403 } 404 405 // CHECK: test_vaddhn_s32 406 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 407 int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) { 408 return vaddhn_s32(a, b); 409 } 410 411 // CHECK: test_vaddhn_s64 412 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 413 int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) { 414 return vaddhn_s64(a, b); 415 } 416 417 // CHECK: test_vaddhn_u16 418 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 419 uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) { 420 return vaddhn_u16(a, b); 421 } 422 423 // CHECK: test_vaddhn_u32 424 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 425 uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) { 426 return vaddhn_u32(a, b); 427 } 428 429 // CHECK: test_vaddhn_u64 430 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 431 uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) { 432 return vaddhn_u64(a, b); 433 } 434 435 436 // CHECK: test_vaddl_s8 437 // CHECK: vaddl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 438 int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) { 439 return vaddl_s8(a, b); 440 } 441 442 // CHECK: test_vaddl_s16 443 // CHECK: vaddl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 444 int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) { 445 return vaddl_s16(a, b); 446 } 447 448 // CHECK: test_vaddl_s32 449 // CHECK: vaddl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 450 int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) { 451 return vaddl_s32(a, b); 452 } 453 454 // CHECK: test_vaddl_u8 455 // CHECK: vaddl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 456 uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) { 457 return vaddl_u8(a, b); 458 } 459 460 // CHECK: test_vaddl_u16 461 // CHECK: vaddl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 462 uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) { 463 return vaddl_u16(a, b); 464 } 465 466 // CHECK: test_vaddl_u32 467 // CHECK: vaddl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 468 uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) { 469 return vaddl_u32(a, b); 470 } 471 472 473 // CHECK: test_vaddw_s8 474 // CHECK: vaddw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 475 int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) { 476 return vaddw_s8(a, b); 477 } 478 479 // CHECK: test_vaddw_s16 480 // CHECK: vaddw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 481 int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) { 482 return vaddw_s16(a, b); 483 } 484 485 // CHECK: test_vaddw_s32 486 // CHECK: vaddw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 487 int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) { 488 return vaddw_s32(a, b); 489 } 490 491 // CHECK: test_vaddw_u8 492 // CHECK: vaddw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 493 uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) { 494 return vaddw_u8(a, b); 495 } 496 497 // CHECK: test_vaddw_u16 498 // CHECK: vaddw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 499 uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) { 500 return vaddw_u16(a, b); 501 } 502 503 // CHECK: test_vaddw_u32 504 // CHECK: vaddw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 505 uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) { 506 return vaddw_u32(a, b); 507 } 508 509 510 // CHECK: test_vand_s8 511 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 512 int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) { 513 return vand_s8(a, b); 514 } 515 516 // CHECK: test_vand_s16 517 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 518 int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) { 519 return vand_s16(a, b); 520 } 521 522 // CHECK: test_vand_s32 523 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 524 int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) { 525 return vand_s32(a, b); 526 } 527 528 // CHECK: test_vand_s64 529 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 530 int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) { 531 return vand_s64(a, b); 532 } 533 534 // CHECK: test_vand_u8 535 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 536 uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) { 537 return vand_u8(a, b); 538 } 539 540 // CHECK: test_vand_u16 541 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 542 uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) { 543 return vand_u16(a, b); 544 } 545 546 // CHECK: test_vand_u32 547 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 548 uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) { 549 return vand_u32(a, b); 550 } 551 552 // CHECK: test_vand_u64 553 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 554 uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) { 555 return vand_u64(a, b); 556 } 557 558 // CHECK: test_vandq_s8 559 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 560 int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) { 561 return vandq_s8(a, b); 562 } 563 564 // CHECK: test_vandq_s16 565 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 566 int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) { 567 return vandq_s16(a, b); 568 } 569 570 // CHECK: test_vandq_s32 571 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 572 int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) { 573 return vandq_s32(a, b); 574 } 575 576 // CHECK: test_vandq_s64 577 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 578 int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) { 579 return vandq_s64(a, b); 580 } 581 582 // CHECK: test_vandq_u8 583 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 584 uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) { 585 return vandq_u8(a, b); 586 } 587 588 // CHECK: test_vandq_u16 589 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 590 uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) { 591 return vandq_u16(a, b); 592 } 593 594 // CHECK: test_vandq_u32 595 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 596 uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) { 597 return vandq_u32(a, b); 598 } 599 600 // CHECK: test_vandq_u64 601 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 602 uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) { 603 return vandq_u64(a, b); 604 } 605 606 607 // CHECK: test_vbic_s8 608 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 609 int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) { 610 return vbic_s8(a, b); 611 } 612 613 // CHECK: test_vbic_s16 614 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 615 int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) { 616 return vbic_s16(a, b); 617 } 618 619 // CHECK: test_vbic_s32 620 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 621 int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) { 622 return vbic_s32(a, b); 623 } 624 625 // CHECK: test_vbic_s64 626 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 627 int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) { 628 return vbic_s64(a, b); 629 } 630 631 // CHECK: test_vbic_u8 632 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 633 uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) { 634 return vbic_u8(a, b); 635 } 636 637 // CHECK: test_vbic_u16 638 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 639 uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) { 640 return vbic_u16(a, b); 641 } 642 643 // CHECK: test_vbic_u32 644 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 645 uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) { 646 return vbic_u32(a, b); 647 } 648 649 // CHECK: test_vbic_u64 650 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 651 uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) { 652 return vbic_u64(a, b); 653 } 654 655 // CHECK: test_vbicq_s8 656 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 657 int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) { 658 return vbicq_s8(a, b); 659 } 660 661 // CHECK: test_vbicq_s16 662 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 663 int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) { 664 return vbicq_s16(a, b); 665 } 666 667 // CHECK: test_vbicq_s32 668 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 669 int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) { 670 return vbicq_s32(a, b); 671 } 672 673 // CHECK: test_vbicq_s64 674 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 675 int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) { 676 return vbicq_s64(a, b); 677 } 678 679 // CHECK: test_vbicq_u8 680 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 681 uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) { 682 return vbicq_u8(a, b); 683 } 684 685 // CHECK: test_vbicq_u16 686 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 687 uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) { 688 return vbicq_u16(a, b); 689 } 690 691 // CHECK: test_vbicq_u32 692 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 693 uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) { 694 return vbicq_u32(a, b); 695 } 696 697 // CHECK: test_vbicq_u64 698 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 699 uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) { 700 return vbicq_u64(a, b); 701 } 702 703 704 // CHECK: test_vbsl_s8 705 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 706 int8x8_t test_vbsl_s8(uint8x8_t a, int8x8_t b, int8x8_t c) { 707 return vbsl_s8(a, b, c); 708 } 709 710 // CHECK: test_vbsl_s16 711 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 712 int16x4_t test_vbsl_s16(uint16x4_t a, int16x4_t b, int16x4_t c) { 713 return vbsl_s16(a, b, c); 714 } 715 716 // CHECK: test_vbsl_s32 717 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 718 int32x2_t test_vbsl_s32(uint32x2_t a, int32x2_t b, int32x2_t c) { 719 return vbsl_s32(a, b, c); 720 } 721 722 // CHECK: test_vbsl_s64 723 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 724 int64x1_t test_vbsl_s64(uint64x1_t a, int64x1_t b, int64x1_t c) { 725 return vbsl_s64(a, b, c); 726 } 727 728 // CHECK: test_vbsl_u8 729 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 730 uint8x8_t test_vbsl_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 731 return vbsl_u8(a, b, c); 732 } 733 734 // CHECK: test_vbsl_u16 735 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 736 uint16x4_t test_vbsl_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 737 return vbsl_u16(a, b, c); 738 } 739 740 // CHECK: test_vbsl_u32 741 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 742 uint32x2_t test_vbsl_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 743 return vbsl_u32(a, b, c); 744 } 745 746 // CHECK: test_vbsl_u64 747 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 748 uint64x1_t test_vbsl_u64(uint64x1_t a, uint64x1_t b, uint64x1_t c) { 749 return vbsl_u64(a, b, c); 750 } 751 752 // CHECK: test_vbsl_f32 753 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 754 float32x2_t test_vbsl_f32(uint32x2_t a, float32x2_t b, float32x2_t c) { 755 return vbsl_f32(a, b, c); 756 } 757 758 // CHECK: test_vbsl_p8 759 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 760 poly8x8_t test_vbsl_p8(uint8x8_t a, poly8x8_t b, poly8x8_t c) { 761 return vbsl_p8(a, b, c); 762 } 763 764 // CHECK: test_vbsl_p16 765 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 766 poly16x4_t test_vbsl_p16(uint16x4_t a, poly16x4_t b, poly16x4_t c) { 767 return vbsl_p16(a, b, c); 768 } 769 770 // CHECK: test_vbslq_s8 771 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 772 int8x16_t test_vbslq_s8(uint8x16_t a, int8x16_t b, int8x16_t c) { 773 return vbslq_s8(a, b, c); 774 } 775 776 // CHECK: test_vbslq_s16 777 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 778 int16x8_t test_vbslq_s16(uint16x8_t a, int16x8_t b, int16x8_t c) { 779 return vbslq_s16(a, b, c); 780 } 781 782 // CHECK: test_vbslq_s32 783 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 784 int32x4_t test_vbslq_s32(uint32x4_t a, int32x4_t b, int32x4_t c) { 785 return vbslq_s32(a, b, c); 786 } 787 788 // CHECK: test_vbslq_s64 789 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 790 int64x2_t test_vbslq_s64(uint64x2_t a, int64x2_t b, int64x2_t c) { 791 return vbslq_s64(a, b, c); 792 } 793 794 // CHECK: test_vbslq_u8 795 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 796 uint8x16_t test_vbslq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 797 return vbslq_u8(a, b, c); 798 } 799 800 // CHECK: test_vbslq_u16 801 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 802 uint16x8_t test_vbslq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 803 return vbslq_u16(a, b, c); 804 } 805 806 // CHECK: test_vbslq_u32 807 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 808 uint32x4_t test_vbslq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 809 return vbslq_u32(a, b, c); 810 } 811 812 // CHECK: test_vbslq_u64 813 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 814 uint64x2_t test_vbslq_u64(uint64x2_t a, uint64x2_t b, uint64x2_t c) { 815 return vbslq_u64(a, b, c); 816 } 817 818 // CHECK: test_vbslq_f32 819 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 820 float32x4_t test_vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) { 821 return vbslq_f32(a, b, c); 822 } 823 824 // CHECK: test_vbslq_p8 825 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 826 poly8x16_t test_vbslq_p8(uint8x16_t a, poly8x16_t b, poly8x16_t c) { 827 return vbslq_p8(a, b, c); 828 } 829 830 // CHECK: test_vbslq_p16 831 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 832 poly16x8_t test_vbslq_p16(uint16x8_t a, poly16x8_t b, poly16x8_t c) { 833 return vbslq_p16(a, b, c); 834 } 835 836 837 // CHECK: test_vcage_f32 838 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 839 uint32x2_t test_vcage_f32(float32x2_t a, float32x2_t b) { 840 return vcage_f32(a, b); 841 } 842 843 // CHECK: test_vcageq_f32 844 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 845 uint32x4_t test_vcageq_f32(float32x4_t a, float32x4_t b) { 846 return vcageq_f32(a, b); 847 } 848 849 850 // CHECK: test_vcagt_f32 851 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 852 uint32x2_t test_vcagt_f32(float32x2_t a, float32x2_t b) { 853 return vcagt_f32(a, b); 854 } 855 856 // CHECK: test_vcagtq_f32 857 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 858 uint32x4_t test_vcagtq_f32(float32x4_t a, float32x4_t b) { 859 return vcagtq_f32(a, b); 860 } 861 862 863 // CHECK: test_vcale_f32 864 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 865 uint32x2_t test_vcale_f32(float32x2_t a, float32x2_t b) { 866 return vcale_f32(a, b); 867 } 868 869 // CHECK: test_vcaleq_f32 870 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 871 uint32x4_t test_vcaleq_f32(float32x4_t a, float32x4_t b) { 872 return vcaleq_f32(a, b); 873 } 874 875 876 // CHECK: test_vcalt_f32 877 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 878 uint32x2_t test_vcalt_f32(float32x2_t a, float32x2_t b) { 879 return vcalt_f32(a, b); 880 } 881 882 // CHECK: test_vcaltq_f32 883 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 884 uint32x4_t test_vcaltq_f32(float32x4_t a, float32x4_t b) { 885 return vcaltq_f32(a, b); 886 } 887 888 889 // CHECK: test_vceq_s8 890 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 891 uint8x8_t test_vceq_s8(int8x8_t a, int8x8_t b) { 892 return vceq_s8(a, b); 893 } 894 895 // CHECK: test_vceq_s16 896 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 897 uint16x4_t test_vceq_s16(int16x4_t a, int16x4_t b) { 898 return vceq_s16(a, b); 899 } 900 901 // CHECK: test_vceq_s32 902 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 903 uint32x2_t test_vceq_s32(int32x2_t a, int32x2_t b) { 904 return vceq_s32(a, b); 905 } 906 907 // CHECK: test_vceq_f32 908 // CHECK: vceq.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 909 uint32x2_t test_vceq_f32(float32x2_t a, float32x2_t b) { 910 return vceq_f32(a, b); 911 } 912 913 // CHECK: test_vceq_u8 914 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 915 uint8x8_t test_vceq_u8(uint8x8_t a, uint8x8_t b) { 916 return vceq_u8(a, b); 917 } 918 919 // CHECK: test_vceq_u16 920 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 921 uint16x4_t test_vceq_u16(uint16x4_t a, uint16x4_t b) { 922 return vceq_u16(a, b); 923 } 924 925 // CHECK: test_vceq_u32 926 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 927 uint32x2_t test_vceq_u32(uint32x2_t a, uint32x2_t b) { 928 return vceq_u32(a, b); 929 } 930 931 // CHECK: test_vceq_p8 932 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 933 uint8x8_t test_vceq_p8(poly8x8_t a, poly8x8_t b) { 934 return vceq_p8(a, b); 935 } 936 937 // CHECK: test_vceqq_s8 938 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 939 uint8x16_t test_vceqq_s8(int8x16_t a, int8x16_t b) { 940 return vceqq_s8(a, b); 941 } 942 943 // CHECK: test_vceqq_s16 944 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 945 uint16x8_t test_vceqq_s16(int16x8_t a, int16x8_t b) { 946 return vceqq_s16(a, b); 947 } 948 949 // CHECK: test_vceqq_s32 950 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 951 uint32x4_t test_vceqq_s32(int32x4_t a, int32x4_t b) { 952 return vceqq_s32(a, b); 953 } 954 955 // CHECK: test_vceqq_f32 956 // CHECK: vceq.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 957 uint32x4_t test_vceqq_f32(float32x4_t a, float32x4_t b) { 958 return vceqq_f32(a, b); 959 } 960 961 // CHECK: test_vceqq_u8 962 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 963 uint8x16_t test_vceqq_u8(uint8x16_t a, uint8x16_t b) { 964 return vceqq_u8(a, b); 965 } 966 967 // CHECK: test_vceqq_u16 968 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 969 uint16x8_t test_vceqq_u16(uint16x8_t a, uint16x8_t b) { 970 return vceqq_u16(a, b); 971 } 972 973 // CHECK: test_vceqq_u32 974 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 975 uint32x4_t test_vceqq_u32(uint32x4_t a, uint32x4_t b) { 976 return vceqq_u32(a, b); 977 } 978 979 // CHECK: test_vceqq_p8 980 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 981 uint8x16_t test_vceqq_p8(poly8x16_t a, poly8x16_t b) { 982 return vceqq_p8(a, b); 983 } 984 985 986 // CHECK: test_vcge_s8 987 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 988 uint8x8_t test_vcge_s8(int8x8_t a, int8x8_t b) { 989 return vcge_s8(a, b); 990 } 991 992 // CHECK: test_vcge_s16 993 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 994 uint16x4_t test_vcge_s16(int16x4_t a, int16x4_t b) { 995 return vcge_s16(a, b); 996 } 997 998 // CHECK: test_vcge_s32 999 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1000 uint32x2_t test_vcge_s32(int32x2_t a, int32x2_t b) { 1001 return vcge_s32(a, b); 1002 } 1003 1004 // CHECK: test_vcge_f32 1005 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1006 uint32x2_t test_vcge_f32(float32x2_t a, float32x2_t b) { 1007 return vcge_f32(a, b); 1008 } 1009 1010 // CHECK: test_vcge_u8 1011 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1012 uint8x8_t test_vcge_u8(uint8x8_t a, uint8x8_t b) { 1013 return vcge_u8(a, b); 1014 } 1015 1016 // CHECK: test_vcge_u16 1017 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1018 uint16x4_t test_vcge_u16(uint16x4_t a, uint16x4_t b) { 1019 return vcge_u16(a, b); 1020 } 1021 1022 // CHECK: test_vcge_u32 1023 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1024 uint32x2_t test_vcge_u32(uint32x2_t a, uint32x2_t b) { 1025 return vcge_u32(a, b); 1026 } 1027 1028 // CHECK: test_vcgeq_s8 1029 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1030 uint8x16_t test_vcgeq_s8(int8x16_t a, int8x16_t b) { 1031 return vcgeq_s8(a, b); 1032 } 1033 1034 // CHECK: test_vcgeq_s16 1035 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1036 uint16x8_t test_vcgeq_s16(int16x8_t a, int16x8_t b) { 1037 return vcgeq_s16(a, b); 1038 } 1039 1040 // CHECK: test_vcgeq_s32 1041 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1042 uint32x4_t test_vcgeq_s32(int32x4_t a, int32x4_t b) { 1043 return vcgeq_s32(a, b); 1044 } 1045 1046 // CHECK: test_vcgeq_f32 1047 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1048 uint32x4_t test_vcgeq_f32(float32x4_t a, float32x4_t b) { 1049 return vcgeq_f32(a, b); 1050 } 1051 1052 // CHECK: test_vcgeq_u8 1053 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1054 uint8x16_t test_vcgeq_u8(uint8x16_t a, uint8x16_t b) { 1055 return vcgeq_u8(a, b); 1056 } 1057 1058 // CHECK: test_vcgeq_u16 1059 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1060 uint16x8_t test_vcgeq_u16(uint16x8_t a, uint16x8_t b) { 1061 return vcgeq_u16(a, b); 1062 } 1063 1064 // CHECK: test_vcgeq_u32 1065 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1066 uint32x4_t test_vcgeq_u32(uint32x4_t a, uint32x4_t b) { 1067 return vcgeq_u32(a, b); 1068 } 1069 1070 1071 // CHECK: test_vcgt_s8 1072 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1073 uint8x8_t test_vcgt_s8(int8x8_t a, int8x8_t b) { 1074 return vcgt_s8(a, b); 1075 } 1076 1077 // CHECK: test_vcgt_s16 1078 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1079 uint16x4_t test_vcgt_s16(int16x4_t a, int16x4_t b) { 1080 return vcgt_s16(a, b); 1081 } 1082 1083 // CHECK: test_vcgt_s32 1084 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1085 uint32x2_t test_vcgt_s32(int32x2_t a, int32x2_t b) { 1086 return vcgt_s32(a, b); 1087 } 1088 1089 // CHECK: test_vcgt_f32 1090 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1091 uint32x2_t test_vcgt_f32(float32x2_t a, float32x2_t b) { 1092 return vcgt_f32(a, b); 1093 } 1094 1095 // CHECK: test_vcgt_u8 1096 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1097 uint8x8_t test_vcgt_u8(uint8x8_t a, uint8x8_t b) { 1098 return vcgt_u8(a, b); 1099 } 1100 1101 // CHECK: test_vcgt_u16 1102 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1103 uint16x4_t test_vcgt_u16(uint16x4_t a, uint16x4_t b) { 1104 return vcgt_u16(a, b); 1105 } 1106 1107 // CHECK: test_vcgt_u32 1108 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1109 uint32x2_t test_vcgt_u32(uint32x2_t a, uint32x2_t b) { 1110 return vcgt_u32(a, b); 1111 } 1112 1113 // CHECK: test_vcgtq_s8 1114 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1115 uint8x16_t test_vcgtq_s8(int8x16_t a, int8x16_t b) { 1116 return vcgtq_s8(a, b); 1117 } 1118 1119 // CHECK: test_vcgtq_s16 1120 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1121 uint16x8_t test_vcgtq_s16(int16x8_t a, int16x8_t b) { 1122 return vcgtq_s16(a, b); 1123 } 1124 1125 // CHECK: test_vcgtq_s32 1126 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1127 uint32x4_t test_vcgtq_s32(int32x4_t a, int32x4_t b) { 1128 return vcgtq_s32(a, b); 1129 } 1130 1131 // CHECK: test_vcgtq_f32 1132 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1133 uint32x4_t test_vcgtq_f32(float32x4_t a, float32x4_t b) { 1134 return vcgtq_f32(a, b); 1135 } 1136 1137 // CHECK: test_vcgtq_u8 1138 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1139 uint8x16_t test_vcgtq_u8(uint8x16_t a, uint8x16_t b) { 1140 return vcgtq_u8(a, b); 1141 } 1142 1143 // CHECK: test_vcgtq_u16 1144 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1145 uint16x8_t test_vcgtq_u16(uint16x8_t a, uint16x8_t b) { 1146 return vcgtq_u16(a, b); 1147 } 1148 1149 // CHECK: test_vcgtq_u32 1150 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1151 uint32x4_t test_vcgtq_u32(uint32x4_t a, uint32x4_t b) { 1152 return vcgtq_u32(a, b); 1153 } 1154 1155 1156 // CHECK: test_vcle_s8 1157 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1158 uint8x8_t test_vcle_s8(int8x8_t a, int8x8_t b) { 1159 return vcle_s8(a, b); 1160 } 1161 1162 // CHECK: test_vcle_s16 1163 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1164 uint16x4_t test_vcle_s16(int16x4_t a, int16x4_t b) { 1165 return vcle_s16(a, b); 1166 } 1167 1168 // CHECK: test_vcle_s32 1169 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1170 uint32x2_t test_vcle_s32(int32x2_t a, int32x2_t b) { 1171 return vcle_s32(a, b); 1172 } 1173 1174 // CHECK: test_vcle_f32 1175 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1176 uint32x2_t test_vcle_f32(float32x2_t a, float32x2_t b) { 1177 return vcle_f32(a, b); 1178 } 1179 1180 // CHECK: test_vcle_u8 1181 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1182 uint8x8_t test_vcle_u8(uint8x8_t a, uint8x8_t b) { 1183 return vcle_u8(a, b); 1184 } 1185 1186 // CHECK: test_vcle_u16 1187 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1188 uint16x4_t test_vcle_u16(uint16x4_t a, uint16x4_t b) { 1189 return vcle_u16(a, b); 1190 } 1191 1192 // CHECK: test_vcle_u32 1193 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1194 uint32x2_t test_vcle_u32(uint32x2_t a, uint32x2_t b) { 1195 return vcle_u32(a, b); 1196 } 1197 1198 // CHECK: test_vcleq_s8 1199 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1200 uint8x16_t test_vcleq_s8(int8x16_t a, int8x16_t b) { 1201 return vcleq_s8(a, b); 1202 } 1203 1204 // CHECK: test_vcleq_s16 1205 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1206 uint16x8_t test_vcleq_s16(int16x8_t a, int16x8_t b) { 1207 return vcleq_s16(a, b); 1208 } 1209 1210 // CHECK: test_vcleq_s32 1211 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1212 uint32x4_t test_vcleq_s32(int32x4_t a, int32x4_t b) { 1213 return vcleq_s32(a, b); 1214 } 1215 1216 // CHECK: test_vcleq_f32 1217 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1218 uint32x4_t test_vcleq_f32(float32x4_t a, float32x4_t b) { 1219 return vcleq_f32(a, b); 1220 } 1221 1222 // CHECK: test_vcleq_u8 1223 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1224 uint8x16_t test_vcleq_u8(uint8x16_t a, uint8x16_t b) { 1225 return vcleq_u8(a, b); 1226 } 1227 1228 // CHECK: test_vcleq_u16 1229 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1230 uint16x8_t test_vcleq_u16(uint16x8_t a, uint16x8_t b) { 1231 return vcleq_u16(a, b); 1232 } 1233 1234 // CHECK: test_vcleq_u32 1235 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1236 uint32x4_t test_vcleq_u32(uint32x4_t a, uint32x4_t b) { 1237 return vcleq_u32(a, b); 1238 } 1239 1240 1241 // CHECK: test_vcls_s8 1242 // CHECK: vcls.s8 d{{[0-9]+}}, d{{[0-9]+}} 1243 int8x8_t test_vcls_s8(int8x8_t a) { 1244 return vcls_s8(a); 1245 } 1246 1247 // CHECK: test_vcls_s16 1248 // CHECK: vcls.s16 d{{[0-9]+}}, d{{[0-9]+}} 1249 int16x4_t test_vcls_s16(int16x4_t a) { 1250 return vcls_s16(a); 1251 } 1252 1253 // CHECK: test_vcls_s32 1254 // CHECK: vcls.s32 d{{[0-9]+}}, d{{[0-9]+}} 1255 int32x2_t test_vcls_s32(int32x2_t a) { 1256 return vcls_s32(a); 1257 } 1258 1259 // CHECK: test_vclsq_s8 1260 // CHECK: vcls.s8 q{{[0-9]+}}, q{{[0-9]+}} 1261 int8x16_t test_vclsq_s8(int8x16_t a) { 1262 return vclsq_s8(a); 1263 } 1264 1265 // CHECK: test_vclsq_s16 1266 // CHECK: vcls.s16 q{{[0-9]+}}, q{{[0-9]+}} 1267 int16x8_t test_vclsq_s16(int16x8_t a) { 1268 return vclsq_s16(a); 1269 } 1270 1271 // CHECK: test_vclsq_s32 1272 // CHECK: vcls.s32 q{{[0-9]+}}, q{{[0-9]+}} 1273 int32x4_t test_vclsq_s32(int32x4_t a) { 1274 return vclsq_s32(a); 1275 } 1276 1277 1278 // CHECK: test_vclt_s8 1279 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1280 uint8x8_t test_vclt_s8(int8x8_t a, int8x8_t b) { 1281 return vclt_s8(a, b); 1282 } 1283 1284 // CHECK: test_vclt_s16 1285 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1286 uint16x4_t test_vclt_s16(int16x4_t a, int16x4_t b) { 1287 return vclt_s16(a, b); 1288 } 1289 1290 // CHECK: test_vclt_s32 1291 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1292 uint32x2_t test_vclt_s32(int32x2_t a, int32x2_t b) { 1293 return vclt_s32(a, b); 1294 } 1295 1296 // CHECK: test_vclt_f32 1297 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1298 uint32x2_t test_vclt_f32(float32x2_t a, float32x2_t b) { 1299 return vclt_f32(a, b); 1300 } 1301 1302 // CHECK: test_vclt_u8 1303 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1304 uint8x8_t test_vclt_u8(uint8x8_t a, uint8x8_t b) { 1305 return vclt_u8(a, b); 1306 } 1307 1308 // CHECK: test_vclt_u16 1309 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1310 uint16x4_t test_vclt_u16(uint16x4_t a, uint16x4_t b) { 1311 return vclt_u16(a, b); 1312 } 1313 1314 // CHECK: test_vclt_u32 1315 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1316 uint32x2_t test_vclt_u32(uint32x2_t a, uint32x2_t b) { 1317 return vclt_u32(a, b); 1318 } 1319 1320 // CHECK: test_vcltq_s8 1321 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1322 uint8x16_t test_vcltq_s8(int8x16_t a, int8x16_t b) { 1323 return vcltq_s8(a, b); 1324 } 1325 1326 // CHECK: test_vcltq_s16 1327 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1328 uint16x8_t test_vcltq_s16(int16x8_t a, int16x8_t b) { 1329 return vcltq_s16(a, b); 1330 } 1331 1332 // CHECK: test_vcltq_s32 1333 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1334 uint32x4_t test_vcltq_s32(int32x4_t a, int32x4_t b) { 1335 return vcltq_s32(a, b); 1336 } 1337 1338 // CHECK: test_vcltq_f32 1339 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1340 uint32x4_t test_vcltq_f32(float32x4_t a, float32x4_t b) { 1341 return vcltq_f32(a, b); 1342 } 1343 1344 // CHECK: test_vcltq_u8 1345 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1346 uint8x16_t test_vcltq_u8(uint8x16_t a, uint8x16_t b) { 1347 return vcltq_u8(a, b); 1348 } 1349 1350 // CHECK: test_vcltq_u16 1351 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1352 uint16x8_t test_vcltq_u16(uint16x8_t a, uint16x8_t b) { 1353 return vcltq_u16(a, b); 1354 } 1355 1356 // CHECK: test_vcltq_u32 1357 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1358 uint32x4_t test_vcltq_u32(uint32x4_t a, uint32x4_t b) { 1359 return vcltq_u32(a, b); 1360 } 1361 1362 1363 // CHECK: test_vclz_s8 1364 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} 1365 int8x8_t test_vclz_s8(int8x8_t a) { 1366 return vclz_s8(a); 1367 } 1368 1369 // CHECK: test_vclz_s16 1370 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} 1371 int16x4_t test_vclz_s16(int16x4_t a) { 1372 return vclz_s16(a); 1373 } 1374 1375 // CHECK: test_vclz_s32 1376 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} 1377 int32x2_t test_vclz_s32(int32x2_t a) { 1378 return vclz_s32(a); 1379 } 1380 1381 // CHECK: test_vclz_u8 1382 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} 1383 uint8x8_t test_vclz_u8(uint8x8_t a) { 1384 return vclz_u8(a); 1385 } 1386 1387 // CHECK: test_vclz_u16 1388 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} 1389 uint16x4_t test_vclz_u16(uint16x4_t a) { 1390 return vclz_u16(a); 1391 } 1392 1393 // CHECK: test_vclz_u32 1394 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} 1395 uint32x2_t test_vclz_u32(uint32x2_t a) { 1396 return vclz_u32(a); 1397 } 1398 1399 // CHECK: test_vclzq_s8 1400 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} 1401 int8x16_t test_vclzq_s8(int8x16_t a) { 1402 return vclzq_s8(a); 1403 } 1404 1405 // CHECK: test_vclzq_s16 1406 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} 1407 int16x8_t test_vclzq_s16(int16x8_t a) { 1408 return vclzq_s16(a); 1409 } 1410 1411 // CHECK: test_vclzq_s32 1412 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} 1413 int32x4_t test_vclzq_s32(int32x4_t a) { 1414 return vclzq_s32(a); 1415 } 1416 1417 // CHECK: test_vclzq_u8 1418 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} 1419 uint8x16_t test_vclzq_u8(uint8x16_t a) { 1420 return vclzq_u8(a); 1421 } 1422 1423 // CHECK: test_vclzq_u16 1424 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} 1425 uint16x8_t test_vclzq_u16(uint16x8_t a) { 1426 return vclzq_u16(a); 1427 } 1428 1429 // CHECK: test_vclzq_u32 1430 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} 1431 uint32x4_t test_vclzq_u32(uint32x4_t a) { 1432 return vclzq_u32(a); 1433 } 1434 1435 1436 // CHECK: test_vcnt_u8 1437 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1438 uint8x8_t test_vcnt_u8(uint8x8_t a) { 1439 return vcnt_u8(a); 1440 } 1441 1442 // CHECK: test_vcnt_s8 1443 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1444 int8x8_t test_vcnt_s8(int8x8_t a) { 1445 return vcnt_s8(a); 1446 } 1447 1448 // CHECK: test_vcnt_p8 1449 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1450 poly8x8_t test_vcnt_p8(poly8x8_t a) { 1451 return vcnt_p8(a); 1452 } 1453 1454 // CHECK: test_vcntq_u8 1455 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1456 uint8x16_t test_vcntq_u8(uint8x16_t a) { 1457 return vcntq_u8(a); 1458 } 1459 1460 // CHECK: test_vcntq_s8 1461 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1462 int8x16_t test_vcntq_s8(int8x16_t a) { 1463 return vcntq_s8(a); 1464 } 1465 1466 // CHECK: test_vcntq_p8 1467 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1468 poly8x16_t test_vcntq_p8(poly8x16_t a) { 1469 return vcntq_p8(a); 1470 } 1471 1472 1473 // CHECK: test_vcombine_s8 1474 int8x16_t test_vcombine_s8(int8x8_t a, int8x8_t b) { 1475 return vcombine_s8(a, b); 1476 } 1477 1478 // CHECK: test_vcombine_s16 1479 int16x8_t test_vcombine_s16(int16x4_t a, int16x4_t b) { 1480 return vcombine_s16(a, b); 1481 } 1482 1483 // CHECK: test_vcombine_s32 1484 int32x4_t test_vcombine_s32(int32x2_t a, int32x2_t b) { 1485 return vcombine_s32(a, b); 1486 } 1487 1488 // CHECK: test_vcombine_s64 1489 int64x2_t test_vcombine_s64(int64x1_t a, int64x1_t b) { 1490 return vcombine_s64(a, b); 1491 } 1492 1493 // CHECK: test_vcombine_f16 1494 float16x8_t test_vcombine_f16(float16x4_t a, float16x4_t b) { 1495 return vcombine_f16(a, b); 1496 } 1497 1498 // CHECK: test_vcombine_f32 1499 float32x4_t test_vcombine_f32(float32x2_t a, float32x2_t b) { 1500 return vcombine_f32(a, b); 1501 } 1502 1503 // CHECK: test_vcombine_u8 1504 uint8x16_t test_vcombine_u8(uint8x8_t a, uint8x8_t b) { 1505 return vcombine_u8(a, b); 1506 } 1507 1508 // CHECK: test_vcombine_u16 1509 uint16x8_t test_vcombine_u16(uint16x4_t a, uint16x4_t b) { 1510 return vcombine_u16(a, b); 1511 } 1512 1513 // CHECK: test_vcombine_u32 1514 uint32x4_t test_vcombine_u32(uint32x2_t a, uint32x2_t b) { 1515 return vcombine_u32(a, b); 1516 } 1517 1518 // CHECK: test_vcombine_u64 1519 uint64x2_t test_vcombine_u64(uint64x1_t a, uint64x1_t b) { 1520 return vcombine_u64(a, b); 1521 } 1522 1523 // CHECK: test_vcombine_p8 1524 poly8x16_t test_vcombine_p8(poly8x8_t a, poly8x8_t b) { 1525 return vcombine_p8(a, b); 1526 } 1527 1528 // CHECK: test_vcombine_p16 1529 poly16x8_t test_vcombine_p16(poly16x4_t a, poly16x4_t b) { 1530 return vcombine_p16(a, b); 1531 } 1532 1533 1534 // CHECK: test_vcreate_s8 1535 int8x8_t test_vcreate_s8(uint64_t a) { 1536 return vcreate_s8(a); 1537 } 1538 1539 // CHECK: test_vcreate_s16 1540 int16x4_t test_vcreate_s16(uint64_t a) { 1541 return vcreate_s16(a); 1542 } 1543 1544 // CHECK: test_vcreate_s32 1545 int32x2_t test_vcreate_s32(uint64_t a) { 1546 return vcreate_s32(a); 1547 } 1548 1549 // CHECK: test_vcreate_f16 1550 float16x4_t test_vcreate_f16(uint64_t a) { 1551 return vcreate_f16(a); 1552 } 1553 1554 // CHECK: test_vcreate_f32 1555 float32x2_t test_vcreate_f32(uint64_t a) { 1556 return vcreate_f32(a); 1557 } 1558 1559 // CHECK: test_vcreate_u8 1560 uint8x8_t test_vcreate_u8(uint64_t a) { 1561 return vcreate_u8(a); 1562 } 1563 1564 // CHECK: test_vcreate_u16 1565 uint16x4_t test_vcreate_u16(uint64_t a) { 1566 return vcreate_u16(a); 1567 } 1568 1569 // CHECK: test_vcreate_u32 1570 uint32x2_t test_vcreate_u32(uint64_t a) { 1571 return vcreate_u32(a); 1572 } 1573 1574 // CHECK: test_vcreate_u64 1575 uint64x1_t test_vcreate_u64(uint64_t a) { 1576 return vcreate_u64(a); 1577 } 1578 1579 // CHECK: test_vcreate_p8 1580 poly8x8_t test_vcreate_p8(uint64_t a) { 1581 return vcreate_p8(a); 1582 } 1583 1584 // CHECK: test_vcreate_p16 1585 poly16x4_t test_vcreate_p16(uint64_t a) { 1586 return vcreate_p16(a); 1587 } 1588 1589 // CHECK: test_vcreate_s64 1590 int64x1_t test_vcreate_s64(uint64_t a) { 1591 return vcreate_s64(a); 1592 } 1593 1594 1595 // CHECK: test_vcvt_f16_f32 1596 // CHECK: vcvt.f16.f32 d{{[0-9]+}}, q{{[0-9]+}} 1597 float16x4_t test_vcvt_f16_f32(float32x4_t a) { 1598 return vcvt_f16_f32(a); 1599 } 1600 1601 1602 // CHECK: test_vcvt_f32_s32 1603 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}} 1604 float32x2_t test_vcvt_f32_s32(int32x2_t a) { 1605 return vcvt_f32_s32(a); 1606 } 1607 1608 // CHECK: test_vcvt_f32_u32 1609 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}} 1610 float32x2_t test_vcvt_f32_u32(uint32x2_t a) { 1611 return vcvt_f32_u32(a); 1612 } 1613 1614 // CHECK: test_vcvtq_f32_s32 1615 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}} 1616 float32x4_t test_vcvtq_f32_s32(int32x4_t a) { 1617 return vcvtq_f32_s32(a); 1618 } 1619 1620 // CHECK: test_vcvtq_f32_u32 1621 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}} 1622 float32x4_t test_vcvtq_f32_u32(uint32x4_t a) { 1623 return vcvtq_f32_u32(a); 1624 } 1625 1626 1627 // CHECK: test_vcvt_f32_f16 1628 // CHECK: vcvt.f32.f16 1629 float32x4_t test_vcvt_f32_f16(float16x4_t a) { 1630 return vcvt_f32_f16(a); 1631 } 1632 1633 1634 // CHECK: test_vcvt_n_f32_s32 1635 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1636 float32x2_t test_vcvt_n_f32_s32(int32x2_t a) { 1637 return vcvt_n_f32_s32(a, 1); 1638 } 1639 1640 // CHECK: test_vcvt_n_f32_u32 1641 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1642 float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) { 1643 return vcvt_n_f32_u32(a, 1); 1644 } 1645 1646 // CHECK: test_vcvtq_n_f32_s32 1647 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1648 float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) { 1649 return vcvtq_n_f32_s32(a, 3); 1650 } 1651 1652 // CHECK: test_vcvtq_n_f32_u32 1653 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1654 float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) { 1655 return vcvtq_n_f32_u32(a, 3); 1656 } 1657 1658 1659 // CHECK: test_vcvt_n_s32_f32 1660 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1661 int32x2_t test_vcvt_n_s32_f32(float32x2_t a) { 1662 return vcvt_n_s32_f32(a, 1); 1663 } 1664 1665 // CHECK: test_vcvtq_n_s32_f32 1666 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1667 int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) { 1668 return vcvtq_n_s32_f32(a, 3); 1669 } 1670 1671 1672 // CHECK: test_vcvt_n_u32_f32 1673 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1674 uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) { 1675 return vcvt_n_u32_f32(a, 1); 1676 } 1677 1678 // CHECK: test_vcvtq_n_u32_f32 1679 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1680 uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) { 1681 return vcvtq_n_u32_f32(a, 3); 1682 } 1683 1684 1685 // CHECK: test_vcvt_s32_f32 1686 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}} 1687 int32x2_t test_vcvt_s32_f32(float32x2_t a) { 1688 return vcvt_s32_f32(a); 1689 } 1690 1691 // CHECK: test_vcvtq_s32_f32 1692 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}} 1693 int32x4_t test_vcvtq_s32_f32(float32x4_t a) { 1694 return vcvtq_s32_f32(a); 1695 } 1696 1697 1698 // CHECK: test_vcvt_u32_f32 1699 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}} 1700 uint32x2_t test_vcvt_u32_f32(float32x2_t a) { 1701 return vcvt_u32_f32(a); 1702 } 1703 1704 // CHECK: test_vcvtq_u32_f32 1705 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}} 1706 uint32x4_t test_vcvtq_u32_f32(float32x4_t a) { 1707 return vcvtq_u32_f32(a); 1708 } 1709 1710 1711 // CHECK: test_vdup_lane_u8 1712 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1713 uint8x8_t test_vdup_lane_u8(uint8x8_t a) { 1714 return vdup_lane_u8(a, 7); 1715 } 1716 1717 // CHECK: test_vdup_lane_u16 1718 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1719 uint16x4_t test_vdup_lane_u16(uint16x4_t a) { 1720 return vdup_lane_u16(a, 3); 1721 } 1722 1723 // CHECK: test_vdup_lane_u32 1724 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1725 uint32x2_t test_vdup_lane_u32(uint32x2_t a) { 1726 return vdup_lane_u32(a, 1); 1727 } 1728 1729 // CHECK: test_vdup_lane_s8 1730 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1731 int8x8_t test_vdup_lane_s8(int8x8_t a) { 1732 return vdup_lane_s8(a, 7); 1733 } 1734 1735 // CHECK: test_vdup_lane_s16 1736 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1737 int16x4_t test_vdup_lane_s16(int16x4_t a) { 1738 return vdup_lane_s16(a, 3); 1739 } 1740 1741 // CHECK: test_vdup_lane_s32 1742 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1743 int32x2_t test_vdup_lane_s32(int32x2_t a) { 1744 return vdup_lane_s32(a, 1); 1745 } 1746 1747 // CHECK: test_vdup_lane_p8 1748 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1749 poly8x8_t test_vdup_lane_p8(poly8x8_t a) { 1750 return vdup_lane_p8(a, 7); 1751 } 1752 1753 // CHECK: test_vdup_lane_p16 1754 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1755 poly16x4_t test_vdup_lane_p16(poly16x4_t a) { 1756 return vdup_lane_p16(a, 3); 1757 } 1758 1759 // CHECK: test_vdup_lane_f32 1760 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1761 float32x2_t test_vdup_lane_f32(float32x2_t a) { 1762 return vdup_lane_f32(a, 1); 1763 } 1764 1765 // CHECK: test_vdupq_lane_u8 1766 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1767 uint8x16_t test_vdupq_lane_u8(uint8x8_t a) { 1768 return vdupq_lane_u8(a, 7); 1769 } 1770 1771 // CHECK: test_vdupq_lane_u16 1772 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1773 uint16x8_t test_vdupq_lane_u16(uint16x4_t a) { 1774 return vdupq_lane_u16(a, 3); 1775 } 1776 1777 // CHECK: test_vdupq_lane_u32 1778 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1779 uint32x4_t test_vdupq_lane_u32(uint32x2_t a) { 1780 return vdupq_lane_u32(a, 1); 1781 } 1782 1783 // CHECK: test_vdupq_lane_s8 1784 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1785 int8x16_t test_vdupq_lane_s8(int8x8_t a) { 1786 return vdupq_lane_s8(a, 7); 1787 } 1788 1789 // CHECK: test_vdupq_lane_s16 1790 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1791 int16x8_t test_vdupq_lane_s16(int16x4_t a) { 1792 return vdupq_lane_s16(a, 3); 1793 } 1794 1795 // CHECK: test_vdupq_lane_s32 1796 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1797 int32x4_t test_vdupq_lane_s32(int32x2_t a) { 1798 return vdupq_lane_s32(a, 1); 1799 } 1800 1801 // CHECK: test_vdupq_lane_p8 1802 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1803 poly8x16_t test_vdupq_lane_p8(poly8x8_t a) { 1804 return vdupq_lane_p8(a, 7); 1805 } 1806 1807 // CHECK: test_vdupq_lane_p16 1808 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1809 poly16x8_t test_vdupq_lane_p16(poly16x4_t a) { 1810 return vdupq_lane_p16(a, 3); 1811 } 1812 1813 // CHECK: test_vdupq_lane_f32 1814 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1815 float32x4_t test_vdupq_lane_f32(float32x2_t a) { 1816 return vdupq_lane_f32(a, 1); 1817 } 1818 1819 // CHECK: test_vdup_lane_s64 1820 int64x1_t test_vdup_lane_s64(int64x1_t a) { 1821 return vdup_lane_s64(a, 0); 1822 } 1823 1824 // CHECK: test_vdup_lane_u64 1825 uint64x1_t test_vdup_lane_u64(uint64x1_t a) { 1826 return vdup_lane_u64(a, 0); 1827 } 1828 1829 // CHECK: test_vdupq_lane_s64 1830 // CHECK: {{vmov|vdup}} 1831 int64x2_t test_vdupq_lane_s64(int64x1_t a) { 1832 return vdupq_lane_s64(a, 0); 1833 } 1834 1835 // CHECK: test_vdupq_lane_u64 1836 // CHECK: {{vmov|vdup}} 1837 uint64x2_t test_vdupq_lane_u64(uint64x1_t a) { 1838 return vdupq_lane_u64(a, 0); 1839 } 1840 1841 1842 // CHECK: test_vdup_n_u8 1843 // CHECK: vmov 1844 uint8x8_t test_vdup_n_u8(uint8_t a) { 1845 return vdup_n_u8(a); 1846 } 1847 1848 // CHECK: test_vdup_n_u16 1849 // CHECK: vmov 1850 uint16x4_t test_vdup_n_u16(uint16_t a) { 1851 return vdup_n_u16(a); 1852 } 1853 1854 // CHECK: test_vdup_n_u32 1855 // CHECK: vmov 1856 uint32x2_t test_vdup_n_u32(uint32_t a) { 1857 return vdup_n_u32(a); 1858 } 1859 1860 // CHECK: test_vdup_n_s8 1861 // CHECK: vmov 1862 int8x8_t test_vdup_n_s8(int8_t a) { 1863 return vdup_n_s8(a); 1864 } 1865 1866 // CHECK: test_vdup_n_s16 1867 // CHECK: vmov 1868 int16x4_t test_vdup_n_s16(int16_t a) { 1869 return vdup_n_s16(a); 1870 } 1871 1872 // CHECK: test_vdup_n_s32 1873 // CHECK: vmov 1874 int32x2_t test_vdup_n_s32(int32_t a) { 1875 return vdup_n_s32(a); 1876 } 1877 1878 // CHECK: test_vdup_n_p8 1879 // CHECK: vmov 1880 poly8x8_t test_vdup_n_p8(poly8_t a) { 1881 return vdup_n_p8(a); 1882 } 1883 1884 // CHECK: test_vdup_n_p16 1885 // CHECK: vmov 1886 poly16x4_t test_vdup_n_p16(poly16_t a) { 1887 return vdup_n_p16(a); 1888 } 1889 1890 // CHECK: test_vdup_n_f32 1891 // CHECK: vmov 1892 float32x2_t test_vdup_n_f32(float32_t a) { 1893 return vdup_n_f32(a); 1894 } 1895 1896 // CHECK: test_vdupq_n_u8 1897 // CHECK: vmov 1898 uint8x16_t test_vdupq_n_u8(uint8_t a) { 1899 return vdupq_n_u8(a); 1900 } 1901 1902 // CHECK: test_vdupq_n_u16 1903 // CHECK: vmov 1904 uint16x8_t test_vdupq_n_u16(uint16_t a) { 1905 return vdupq_n_u16(a); 1906 } 1907 1908 // CHECK: test_vdupq_n_u32 1909 // CHECK: vmov 1910 uint32x4_t test_vdupq_n_u32(uint32_t a) { 1911 return vdupq_n_u32(a); 1912 } 1913 1914 // CHECK: test_vdupq_n_s8 1915 // CHECK: vmov 1916 int8x16_t test_vdupq_n_s8(int8_t a) { 1917 return vdupq_n_s8(a); 1918 } 1919 1920 // CHECK: test_vdupq_n_s16 1921 // CHECK: vmov 1922 int16x8_t test_vdupq_n_s16(int16_t a) { 1923 return vdupq_n_s16(a); 1924 } 1925 1926 // CHECK: test_vdupq_n_s32 1927 // CHECK: vmov 1928 int32x4_t test_vdupq_n_s32(int32_t a) { 1929 return vdupq_n_s32(a); 1930 } 1931 1932 // CHECK: test_vdupq_n_p8 1933 // CHECK: vmov 1934 poly8x16_t test_vdupq_n_p8(poly8_t a) { 1935 return vdupq_n_p8(a); 1936 } 1937 1938 // CHECK: test_vdupq_n_p16 1939 // CHECK: vmov 1940 poly16x8_t test_vdupq_n_p16(poly16_t a) { 1941 return vdupq_n_p16(a); 1942 } 1943 1944 // CHECK: test_vdupq_n_f32 1945 // CHECK: vmov 1946 float32x4_t test_vdupq_n_f32(float32_t a) { 1947 return vdupq_n_f32(a); 1948 } 1949 1950 // CHECK: test_vdup_n_s64 1951 // CHECK: vmov 1952 int64x1_t test_vdup_n_s64(int64_t a) { 1953 return vdup_n_s64(a); 1954 } 1955 1956 // CHECK: test_vdup_n_u64 1957 // CHECK: vmov 1958 uint64x1_t test_vdup_n_u64(uint64_t a) { 1959 return vdup_n_u64(a); 1960 } 1961 1962 // CHECK: test_vdupq_n_s64 1963 // CHECK: vmov 1964 int64x2_t test_vdupq_n_s64(int64_t a) { 1965 return vdupq_n_s64(a); 1966 } 1967 1968 // CHECK: test_vdupq_n_u64 1969 // CHECK: vmov 1970 uint64x2_t test_vdupq_n_u64(uint64_t a) { 1971 return vdupq_n_u64(a); 1972 } 1973 1974 1975 // CHECK: test_veor_s8 1976 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1977 int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) { 1978 return veor_s8(a, b); 1979 } 1980 1981 // CHECK: test_veor_s16 1982 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1983 int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) { 1984 return veor_s16(a, b); 1985 } 1986 1987 // CHECK: test_veor_s32 1988 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1989 int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) { 1990 return veor_s32(a, b); 1991 } 1992 1993 // CHECK: test_veor_s64 1994 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1995 int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) { 1996 return veor_s64(a, b); 1997 } 1998 1999 // CHECK: test_veor_u8 2000 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2001 uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) { 2002 return veor_u8(a, b); 2003 } 2004 2005 // CHECK: test_veor_u16 2006 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2007 uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) { 2008 return veor_u16(a, b); 2009 } 2010 2011 // CHECK: test_veor_u32 2012 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2013 uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) { 2014 return veor_u32(a, b); 2015 } 2016 2017 // CHECK: test_veor_u64 2018 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2019 uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) { 2020 return veor_u64(a, b); 2021 } 2022 2023 // CHECK: test_veorq_s8 2024 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2025 int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) { 2026 return veorq_s8(a, b); 2027 } 2028 2029 // CHECK: test_veorq_s16 2030 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2031 int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) { 2032 return veorq_s16(a, b); 2033 } 2034 2035 // CHECK: test_veorq_s32 2036 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2037 int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) { 2038 return veorq_s32(a, b); 2039 } 2040 2041 // CHECK: test_veorq_s64 2042 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2043 int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) { 2044 return veorq_s64(a, b); 2045 } 2046 2047 // CHECK: test_veorq_u8 2048 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2049 uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) { 2050 return veorq_u8(a, b); 2051 } 2052 2053 // CHECK: test_veorq_u16 2054 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2055 uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) { 2056 return veorq_u16(a, b); 2057 } 2058 2059 // CHECK: test_veorq_u32 2060 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2061 uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) { 2062 return veorq_u32(a, b); 2063 } 2064 2065 // CHECK: test_veorq_u64 2066 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2067 uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) { 2068 return veorq_u64(a, b); 2069 } 2070 2071 2072 // CHECK: test_vext_s8 2073 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2074 int8x8_t test_vext_s8(int8x8_t a, int8x8_t b) { 2075 return vext_s8(a, b, 7); 2076 } 2077 2078 // CHECK: test_vext_u8 2079 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2080 uint8x8_t test_vext_u8(uint8x8_t a, uint8x8_t b) { 2081 return vext_u8(a, b, 7); 2082 } 2083 2084 // CHECK: test_vext_p8 2085 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2086 poly8x8_t test_vext_p8(poly8x8_t a, poly8x8_t b) { 2087 return vext_p8(a, b, 7); 2088 } 2089 2090 // CHECK: test_vext_s16 2091 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2092 int16x4_t test_vext_s16(int16x4_t a, int16x4_t b) { 2093 return vext_s16(a, b, 3); 2094 } 2095 2096 // CHECK: test_vext_u16 2097 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2098 uint16x4_t test_vext_u16(uint16x4_t a, uint16x4_t b) { 2099 return vext_u16(a, b, 3); 2100 } 2101 2102 // CHECK: test_vext_p16 2103 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2104 poly16x4_t test_vext_p16(poly16x4_t a, poly16x4_t b) { 2105 return vext_p16(a, b, 3); 2106 } 2107 2108 // CHECK: test_vext_s32 2109 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2110 int32x2_t test_vext_s32(int32x2_t a, int32x2_t b) { 2111 return vext_s32(a, b, 1); 2112 } 2113 2114 // CHECK: test_vext_u32 2115 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2116 uint32x2_t test_vext_u32(uint32x2_t a, uint32x2_t b) { 2117 return vext_u32(a, b, 1); 2118 } 2119 2120 // CHECK: test_vext_s64 2121 int64x1_t test_vext_s64(int64x1_t a, int64x1_t b) { 2122 return vext_s64(a, b, 0); 2123 } 2124 2125 // CHECK: test_vext_u64 2126 uint64x1_t test_vext_u64(uint64x1_t a, uint64x1_t b) { 2127 return vext_u64(a, b, 0); 2128 } 2129 2130 // CHECK: test_vext_f32 2131 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2132 float32x2_t test_vext_f32(float32x2_t a, float32x2_t b) { 2133 return vext_f32(a, b, 1); 2134 } 2135 2136 // CHECK: test_vextq_s8 2137 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2138 int8x16_t test_vextq_s8(int8x16_t a, int8x16_t b) { 2139 return vextq_s8(a, b, 15); 2140 } 2141 2142 // CHECK: test_vextq_u8 2143 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2144 uint8x16_t test_vextq_u8(uint8x16_t a, uint8x16_t b) { 2145 return vextq_u8(a, b, 15); 2146 } 2147 2148 // CHECK: test_vextq_p8 2149 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2150 poly8x16_t test_vextq_p8(poly8x16_t a, poly8x16_t b) { 2151 return vextq_p8(a, b, 15); 2152 } 2153 2154 // CHECK: test_vextq_s16 2155 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2156 int16x8_t test_vextq_s16(int16x8_t a, int16x8_t b) { 2157 return vextq_s16(a, b, 7); 2158 } 2159 2160 // CHECK: test_vextq_u16 2161 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2162 uint16x8_t test_vextq_u16(uint16x8_t a, uint16x8_t b) { 2163 return vextq_u16(a, b, 7); 2164 } 2165 2166 // CHECK: test_vextq_p16 2167 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2168 poly16x8_t test_vextq_p16(poly16x8_t a, poly16x8_t b) { 2169 return vextq_p16(a, b, 7); 2170 } 2171 2172 // CHECK: test_vextq_s32 2173 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2174 int32x4_t test_vextq_s32(int32x4_t a, int32x4_t b) { 2175 return vextq_s32(a, b, 3); 2176 } 2177 2178 // CHECK: test_vextq_u32 2179 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2180 uint32x4_t test_vextq_u32(uint32x4_t a, uint32x4_t b) { 2181 return vextq_u32(a, b, 3); 2182 } 2183 2184 // CHECK: test_vextq_s64 2185 // CHECK: {{vmov|vdup}} 2186 int64x2_t test_vextq_s64(int64x2_t a, int64x2_t b) { 2187 return vextq_s64(a, b, 1); 2188 } 2189 2190 // CHECK: test_vextq_u64 2191 // CHECK: {{vmov|vdup}} 2192 uint64x2_t test_vextq_u64(uint64x2_t a, uint64x2_t b) { 2193 return vextq_u64(a, b, 1); 2194 } 2195 2196 // CHECK: test_vextq_f32 2197 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2198 float32x4_t test_vextq_f32(float32x4_t a, float32x4_t b) { 2199 return vextq_f32(a, b, 3); 2200 } 2201 2202 2203 // CHECK: test_vfma_f32 2204 // CHECK: vfma.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2205 float32x2_t test_vfma_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 2206 return vfma_f32(a, b, c); 2207 } 2208 2209 // CHECK: test_vfmaq_f32 2210 // CHECK: vfma.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2211 float32x4_t test_vfmaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 2212 return vfmaq_f32(a, b, c); 2213 } 2214 2215 2216 // CHECK: test_vget_high_s8 2217 int8x8_t test_vget_high_s8(int8x16_t a) { 2218 return vget_high_s8(a); 2219 } 2220 2221 // CHECK: test_vget_high_s16 2222 int16x4_t test_vget_high_s16(int16x8_t a) { 2223 return vget_high_s16(a); 2224 } 2225 2226 // CHECK: test_vget_high_s32 2227 int32x2_t test_vget_high_s32(int32x4_t a) { 2228 return vget_high_s32(a); 2229 } 2230 2231 // CHECK: test_vget_high_s64 2232 int64x1_t test_vget_high_s64(int64x2_t a) { 2233 return vget_high_s64(a); 2234 } 2235 2236 // CHECK: test_vget_high_f16 2237 float16x4_t test_vget_high_f16(float16x8_t a) { 2238 return vget_high_f16(a); 2239 } 2240 2241 // CHECK: test_vget_high_f32 2242 float32x2_t test_vget_high_f32(float32x4_t a) { 2243 return vget_high_f32(a); 2244 } 2245 2246 // CHECK: test_vget_high_u8 2247 uint8x8_t test_vget_high_u8(uint8x16_t a) { 2248 return vget_high_u8(a); 2249 } 2250 2251 // CHECK: test_vget_high_u16 2252 uint16x4_t test_vget_high_u16(uint16x8_t a) { 2253 return vget_high_u16(a); 2254 } 2255 2256 // CHECK: test_vget_high_u32 2257 uint32x2_t test_vget_high_u32(uint32x4_t a) { 2258 return vget_high_u32(a); 2259 } 2260 2261 // CHECK: test_vget_high_u64 2262 uint64x1_t test_vget_high_u64(uint64x2_t a) { 2263 return vget_high_u64(a); 2264 } 2265 2266 // CHECK: test_vget_high_p8 2267 poly8x8_t test_vget_high_p8(poly8x16_t a) { 2268 return vget_high_p8(a); 2269 } 2270 2271 // CHECK: test_vget_high_p16 2272 poly16x4_t test_vget_high_p16(poly16x8_t a) { 2273 return vget_high_p16(a); 2274 } 2275 2276 2277 // CHECK: test_vget_lane_u8 2278 // CHECK: vmov 2279 uint8_t test_vget_lane_u8(uint8x8_t a) { 2280 return vget_lane_u8(a, 7); 2281 } 2282 2283 // CHECK: test_vget_lane_u16 2284 // CHECK: vmov 2285 uint16_t test_vget_lane_u16(uint16x4_t a) { 2286 return vget_lane_u16(a, 3); 2287 } 2288 2289 // CHECK: test_vget_lane_u32 2290 // CHECK: vmov 2291 uint32_t test_vget_lane_u32(uint32x2_t a) { 2292 return vget_lane_u32(a, 1); 2293 } 2294 2295 // CHECK: test_vget_lane_s8 2296 // CHECK: vmov 2297 int8_t test_vget_lane_s8(int8x8_t a) { 2298 return vget_lane_s8(a, 7); 2299 } 2300 2301 // CHECK: test_vget_lane_s16 2302 // CHECK: vmov 2303 int16_t test_vget_lane_s16(int16x4_t a) { 2304 return vget_lane_s16(a, 3); 2305 } 2306 2307 // CHECK: test_vget_lane_s32 2308 // CHECK: vmov 2309 int32_t test_vget_lane_s32(int32x2_t a) { 2310 return vget_lane_s32(a, 1); 2311 } 2312 2313 // CHECK: test_vget_lane_p8 2314 // CHECK: vmov 2315 poly8_t test_vget_lane_p8(poly8x8_t a) { 2316 return vget_lane_p8(a, 7); 2317 } 2318 2319 // CHECK: test_vget_lane_p16 2320 // CHECK: vmov 2321 poly16_t test_vget_lane_p16(poly16x4_t a) { 2322 return vget_lane_p16(a, 3); 2323 } 2324 2325 // CHECK: test_vget_lane_f32 2326 // CHECK: vmov 2327 float32_t test_vget_lane_f32(float32x2_t a) { 2328 return vget_lane_f32(a, 1); 2329 } 2330 2331 // CHECK: test_vgetq_lane_u8 2332 // CHECK: vmov 2333 uint8_t test_vgetq_lane_u8(uint8x16_t a) { 2334 return vgetq_lane_u8(a, 15); 2335 } 2336 2337 // CHECK: test_vgetq_lane_u16 2338 // CHECK: vmov 2339 uint16_t test_vgetq_lane_u16(uint16x8_t a) { 2340 return vgetq_lane_u16(a, 7); 2341 } 2342 2343 // CHECK: test_vgetq_lane_u32 2344 // CHECK: vmov 2345 uint32_t test_vgetq_lane_u32(uint32x4_t a) { 2346 return vgetq_lane_u32(a, 3); 2347 } 2348 2349 // CHECK: test_vgetq_lane_s8 2350 // CHECK: vmov 2351 int8_t test_vgetq_lane_s8(int8x16_t a) { 2352 return vgetq_lane_s8(a, 15); 2353 } 2354 2355 // CHECK: test_vgetq_lane_s16 2356 // CHECK: vmov 2357 int16_t test_vgetq_lane_s16(int16x8_t a) { 2358 return vgetq_lane_s16(a, 7); 2359 } 2360 2361 // CHECK: test_vgetq_lane_s32 2362 // CHECK: vmov 2363 int32_t test_vgetq_lane_s32(int32x4_t a) { 2364 return vgetq_lane_s32(a, 3); 2365 } 2366 2367 // CHECK: test_vgetq_lane_p8 2368 // CHECK: vmov 2369 poly8_t test_vgetq_lane_p8(poly8x16_t a) { 2370 return vgetq_lane_p8(a, 15); 2371 } 2372 2373 // CHECK: test_vgetq_lane_p16 2374 // CHECK: vmov 2375 poly16_t test_vgetq_lane_p16(poly16x8_t a) { 2376 return vgetq_lane_p16(a, 7); 2377 } 2378 2379 // CHECK: test_vgetq_lane_f32 2380 // CHECK: vmov 2381 float32_t test_vgetq_lane_f32(float32x4_t a) { 2382 return vgetq_lane_f32(a, 3); 2383 } 2384 2385 // CHECK: test_vget_lane_s64 2386 // CHECK: vmov 2387 int64_t test_vget_lane_s64(int64x1_t a) { 2388 return vget_lane_s64(a, 0); 2389 } 2390 2391 // CHECK: test_vget_lane_u64 2392 // CHECK: vmov 2393 uint64_t test_vget_lane_u64(uint64x1_t a) { 2394 return vget_lane_u64(a, 0); 2395 } 2396 2397 // CHECK: test_vgetq_lane_s64 2398 // CHECK: vmov 2399 int64_t test_vgetq_lane_s64(int64x2_t a) { 2400 return vgetq_lane_s64(a, 1); 2401 } 2402 2403 // CHECK: test_vgetq_lane_u64 2404 // CHECK: vmov 2405 uint64_t test_vgetq_lane_u64(uint64x2_t a) { 2406 return vgetq_lane_u64(a, 1); 2407 } 2408 2409 2410 // CHECK: test_vget_low_s8 2411 int8x8_t test_vget_low_s8(int8x16_t a) { 2412 return vget_low_s8(a); 2413 } 2414 2415 // CHECK: test_vget_low_s16 2416 int16x4_t test_vget_low_s16(int16x8_t a) { 2417 return vget_low_s16(a); 2418 } 2419 2420 // CHECK: test_vget_low_s32 2421 int32x2_t test_vget_low_s32(int32x4_t a) { 2422 return vget_low_s32(a); 2423 } 2424 2425 // CHECK: test_vget_low_s64 2426 int64x1_t test_vget_low_s64(int64x2_t a) { 2427 return vget_low_s64(a); 2428 } 2429 2430 // CHECK: test_vget_low_f16 2431 float16x4_t test_vget_low_f16(float16x8_t a) { 2432 return vget_low_f16(a); 2433 } 2434 2435 // CHECK: test_vget_low_f32 2436 float32x2_t test_vget_low_f32(float32x4_t a) { 2437 return vget_low_f32(a); 2438 } 2439 2440 // CHECK: test_vget_low_u8 2441 uint8x8_t test_vget_low_u8(uint8x16_t a) { 2442 return vget_low_u8(a); 2443 } 2444 2445 // CHECK: test_vget_low_u16 2446 uint16x4_t test_vget_low_u16(uint16x8_t a) { 2447 return vget_low_u16(a); 2448 } 2449 2450 // CHECK: test_vget_low_u32 2451 uint32x2_t test_vget_low_u32(uint32x4_t a) { 2452 return vget_low_u32(a); 2453 } 2454 2455 // CHECK: test_vget_low_u64 2456 uint64x1_t test_vget_low_u64(uint64x2_t a) { 2457 return vget_low_u64(a); 2458 } 2459 2460 // CHECK: test_vget_low_p8 2461 poly8x8_t test_vget_low_p8(poly8x16_t a) { 2462 return vget_low_p8(a); 2463 } 2464 2465 // CHECK: test_vget_low_p16 2466 poly16x4_t test_vget_low_p16(poly16x8_t a) { 2467 return vget_low_p16(a); 2468 } 2469 2470 2471 // CHECK: test_vhadd_s8 2472 // CHECK: vhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2473 int8x8_t test_vhadd_s8(int8x8_t a, int8x8_t b) { 2474 return vhadd_s8(a, b); 2475 } 2476 2477 // CHECK: test_vhadd_s16 2478 // CHECK: vhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2479 int16x4_t test_vhadd_s16(int16x4_t a, int16x4_t b) { 2480 return vhadd_s16(a, b); 2481 } 2482 2483 // CHECK: test_vhadd_s32 2484 // CHECK: vhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2485 int32x2_t test_vhadd_s32(int32x2_t a, int32x2_t b) { 2486 return vhadd_s32(a, b); 2487 } 2488 2489 // CHECK: test_vhadd_u8 2490 // CHECK: vhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2491 uint8x8_t test_vhadd_u8(uint8x8_t a, uint8x8_t b) { 2492 return vhadd_u8(a, b); 2493 } 2494 2495 // CHECK: test_vhadd_u16 2496 // CHECK: vhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2497 uint16x4_t test_vhadd_u16(uint16x4_t a, uint16x4_t b) { 2498 return vhadd_u16(a, b); 2499 } 2500 2501 // CHECK: test_vhadd_u32 2502 // CHECK: vhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2503 uint32x2_t test_vhadd_u32(uint32x2_t a, uint32x2_t b) { 2504 return vhadd_u32(a, b); 2505 } 2506 2507 // CHECK: test_vhaddq_s8 2508 // CHECK: vhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2509 int8x16_t test_vhaddq_s8(int8x16_t a, int8x16_t b) { 2510 return vhaddq_s8(a, b); 2511 } 2512 2513 // CHECK: test_vhaddq_s16 2514 // CHECK: vhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2515 int16x8_t test_vhaddq_s16(int16x8_t a, int16x8_t b) { 2516 return vhaddq_s16(a, b); 2517 } 2518 2519 // CHECK: test_vhaddq_s32 2520 // CHECK: vhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2521 int32x4_t test_vhaddq_s32(int32x4_t a, int32x4_t b) { 2522 return vhaddq_s32(a, b); 2523 } 2524 2525 // CHECK: test_vhaddq_u8 2526 // CHECK: vhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2527 uint8x16_t test_vhaddq_u8(uint8x16_t a, uint8x16_t b) { 2528 return vhaddq_u8(a, b); 2529 } 2530 2531 // CHECK: test_vhaddq_u16 2532 // CHECK: vhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2533 uint16x8_t test_vhaddq_u16(uint16x8_t a, uint16x8_t b) { 2534 return vhaddq_u16(a, b); 2535 } 2536 2537 // CHECK: test_vhaddq_u32 2538 // CHECK: vhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2539 uint32x4_t test_vhaddq_u32(uint32x4_t a, uint32x4_t b) { 2540 return vhaddq_u32(a, b); 2541 } 2542 2543 2544 // CHECK: test_vhsub_s8 2545 // CHECK: vhsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2546 int8x8_t test_vhsub_s8(int8x8_t a, int8x8_t b) { 2547 return vhsub_s8(a, b); 2548 } 2549 2550 // CHECK: test_vhsub_s16 2551 // CHECK: vhsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2552 int16x4_t test_vhsub_s16(int16x4_t a, int16x4_t b) { 2553 return vhsub_s16(a, b); 2554 } 2555 2556 // CHECK: test_vhsub_s32 2557 // CHECK: vhsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2558 int32x2_t test_vhsub_s32(int32x2_t a, int32x2_t b) { 2559 return vhsub_s32(a, b); 2560 } 2561 2562 // CHECK: test_vhsub_u8 2563 // CHECK: vhsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2564 uint8x8_t test_vhsub_u8(uint8x8_t a, uint8x8_t b) { 2565 return vhsub_u8(a, b); 2566 } 2567 2568 // CHECK: test_vhsub_u16 2569 // CHECK: vhsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2570 uint16x4_t test_vhsub_u16(uint16x4_t a, uint16x4_t b) { 2571 return vhsub_u16(a, b); 2572 } 2573 2574 // CHECK: test_vhsub_u32 2575 // CHECK: vhsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2576 uint32x2_t test_vhsub_u32(uint32x2_t a, uint32x2_t b) { 2577 return vhsub_u32(a, b); 2578 } 2579 2580 // CHECK: test_vhsubq_s8 2581 // CHECK: vhsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2582 int8x16_t test_vhsubq_s8(int8x16_t a, int8x16_t b) { 2583 return vhsubq_s8(a, b); 2584 } 2585 2586 // CHECK: test_vhsubq_s16 2587 // CHECK: vhsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2588 int16x8_t test_vhsubq_s16(int16x8_t a, int16x8_t b) { 2589 return vhsubq_s16(a, b); 2590 } 2591 2592 // CHECK: test_vhsubq_s32 2593 // CHECK: vhsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2594 int32x4_t test_vhsubq_s32(int32x4_t a, int32x4_t b) { 2595 return vhsubq_s32(a, b); 2596 } 2597 2598 // CHECK: test_vhsubq_u8 2599 // CHECK: vhsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2600 uint8x16_t test_vhsubq_u8(uint8x16_t a, uint8x16_t b) { 2601 return vhsubq_u8(a, b); 2602 } 2603 2604 // CHECK: test_vhsubq_u16 2605 // CHECK: vhsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2606 uint16x8_t test_vhsubq_u16(uint16x8_t a, uint16x8_t b) { 2607 return vhsubq_u16(a, b); 2608 } 2609 2610 // CHECK: test_vhsubq_u32 2611 // CHECK: vhsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2612 uint32x4_t test_vhsubq_u32(uint32x4_t a, uint32x4_t b) { 2613 return vhsubq_u32(a, b); 2614 } 2615 2616 2617 // CHECK: test_vld1q_u8 2618 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2619 uint8x16_t test_vld1q_u8(uint8_t const * a) { 2620 return vld1q_u8(a); 2621 } 2622 2623 // CHECK: test_vld1q_u16 2624 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2625 uint16x8_t test_vld1q_u16(uint16_t const * a) { 2626 return vld1q_u16(a); 2627 } 2628 2629 // CHECK: test_vld1q_u32 2630 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2631 uint32x4_t test_vld1q_u32(uint32_t const * a) { 2632 return vld1q_u32(a); 2633 } 2634 2635 // CHECK: test_vld1q_u64 2636 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2637 uint64x2_t test_vld1q_u64(uint64_t const * a) { 2638 return vld1q_u64(a); 2639 } 2640 2641 // CHECK: test_vld1q_s8 2642 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2643 int8x16_t test_vld1q_s8(int8_t const * a) { 2644 return vld1q_s8(a); 2645 } 2646 2647 // CHECK: test_vld1q_s16 2648 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2649 int16x8_t test_vld1q_s16(int16_t const * a) { 2650 return vld1q_s16(a); 2651 } 2652 2653 // CHECK: test_vld1q_s32 2654 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2655 int32x4_t test_vld1q_s32(int32_t const * a) { 2656 return vld1q_s32(a); 2657 } 2658 2659 // CHECK: test_vld1q_s64 2660 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2661 int64x2_t test_vld1q_s64(int64_t const * a) { 2662 return vld1q_s64(a); 2663 } 2664 2665 // CHECK: test_vld1q_f16 2666 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2667 float16x8_t test_vld1q_f16(float16_t const * a) { 2668 return vld1q_f16(a); 2669 } 2670 2671 // CHECK: test_vld1q_f32 2672 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2673 float32x4_t test_vld1q_f32(float32_t const * a) { 2674 return vld1q_f32(a); 2675 } 2676 2677 // CHECK: test_vld1q_p8 2678 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2679 poly8x16_t test_vld1q_p8(poly8_t const * a) { 2680 return vld1q_p8(a); 2681 } 2682 2683 // CHECK: test_vld1q_p16 2684 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2685 poly16x8_t test_vld1q_p16(poly16_t const * a) { 2686 return vld1q_p16(a); 2687 } 2688 2689 // CHECK: test_vld1_u8 2690 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2691 uint8x8_t test_vld1_u8(uint8_t const * a) { 2692 return vld1_u8(a); 2693 } 2694 2695 // CHECK: test_vld1_u16 2696 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2697 uint16x4_t test_vld1_u16(uint16_t const * a) { 2698 return vld1_u16(a); 2699 } 2700 2701 // CHECK: test_vld1_u32 2702 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2703 uint32x2_t test_vld1_u32(uint32_t const * a) { 2704 return vld1_u32(a); 2705 } 2706 2707 // CHECK: test_vld1_u64 2708 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2709 uint64x1_t test_vld1_u64(uint64_t const * a) { 2710 return vld1_u64(a); 2711 } 2712 2713 // CHECK: test_vld1_s8 2714 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2715 int8x8_t test_vld1_s8(int8_t const * a) { 2716 return vld1_s8(a); 2717 } 2718 2719 // CHECK: test_vld1_s16 2720 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2721 int16x4_t test_vld1_s16(int16_t const * a) { 2722 return vld1_s16(a); 2723 } 2724 2725 // CHECK: test_vld1_s32 2726 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2727 int32x2_t test_vld1_s32(int32_t const * a) { 2728 return vld1_s32(a); 2729 } 2730 2731 // CHECK: test_vld1_s64 2732 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2733 int64x1_t test_vld1_s64(int64_t const * a) { 2734 return vld1_s64(a); 2735 } 2736 2737 // CHECK: test_vld1_f16 2738 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2739 float16x4_t test_vld1_f16(float16_t const * a) { 2740 return vld1_f16(a); 2741 } 2742 2743 // CHECK: test_vld1_f32 2744 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2745 float32x2_t test_vld1_f32(float32_t const * a) { 2746 return vld1_f32(a); 2747 } 2748 2749 // CHECK: test_vld1_p8 2750 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2751 poly8x8_t test_vld1_p8(poly8_t const * a) { 2752 return vld1_p8(a); 2753 } 2754 2755 // CHECK: test_vld1_p16 2756 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2757 poly16x4_t test_vld1_p16(poly16_t const * a) { 2758 return vld1_p16(a); 2759 } 2760 2761 2762 // CHECK: test_vld1q_dup_u8 2763 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2764 uint8x16_t test_vld1q_dup_u8(uint8_t const * a) { 2765 return vld1q_dup_u8(a); 2766 } 2767 2768 // CHECK: test_vld1q_dup_u16 2769 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2770 uint16x8_t test_vld1q_dup_u16(uint16_t const * a) { 2771 return vld1q_dup_u16(a); 2772 } 2773 2774 // CHECK: test_vld1q_dup_u32 2775 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2776 uint32x4_t test_vld1q_dup_u32(uint32_t const * a) { 2777 return vld1q_dup_u32(a); 2778 } 2779 2780 // CHECK: test_vld1q_dup_u64 2781 // CHECK: {{ldr|vldr|vmov}} 2782 uint64x2_t test_vld1q_dup_u64(uint64_t const * a) { 2783 return vld1q_dup_u64(a); 2784 } 2785 2786 // CHECK: test_vld1q_dup_s8 2787 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2788 int8x16_t test_vld1q_dup_s8(int8_t const * a) { 2789 return vld1q_dup_s8(a); 2790 } 2791 2792 // CHECK: test_vld1q_dup_s16 2793 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2794 int16x8_t test_vld1q_dup_s16(int16_t const * a) { 2795 return vld1q_dup_s16(a); 2796 } 2797 2798 // CHECK: test_vld1q_dup_s32 2799 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2800 int32x4_t test_vld1q_dup_s32(int32_t const * a) { 2801 return vld1q_dup_s32(a); 2802 } 2803 2804 // CHECK: test_vld1q_dup_s64 2805 // CHECK: {{ldr|vldr|vmov}} 2806 int64x2_t test_vld1q_dup_s64(int64_t const * a) { 2807 return vld1q_dup_s64(a); 2808 } 2809 2810 // CHECK: test_vld1q_dup_f16 2811 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2812 float16x8_t test_vld1q_dup_f16(float16_t const * a) { 2813 return vld1q_dup_f16(a); 2814 } 2815 2816 // CHECK: test_vld1q_dup_f32 2817 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2818 float32x4_t test_vld1q_dup_f32(float32_t const * a) { 2819 return vld1q_dup_f32(a); 2820 } 2821 2822 // CHECK: test_vld1q_dup_p8 2823 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2824 poly8x16_t test_vld1q_dup_p8(poly8_t const * a) { 2825 return vld1q_dup_p8(a); 2826 } 2827 2828 // CHECK: test_vld1q_dup_p16 2829 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2830 poly16x8_t test_vld1q_dup_p16(poly16_t const * a) { 2831 return vld1q_dup_p16(a); 2832 } 2833 2834 // CHECK: test_vld1_dup_u8 2835 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2836 uint8x8_t test_vld1_dup_u8(uint8_t const * a) { 2837 return vld1_dup_u8(a); 2838 } 2839 2840 // CHECK: test_vld1_dup_u16 2841 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2842 uint16x4_t test_vld1_dup_u16(uint16_t const * a) { 2843 return vld1_dup_u16(a); 2844 } 2845 2846 // CHECK: test_vld1_dup_u32 2847 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2848 uint32x2_t test_vld1_dup_u32(uint32_t const * a) { 2849 return vld1_dup_u32(a); 2850 } 2851 2852 // CHECK: test_vld1_dup_u64 2853 // CHECK: {{ldr|vldr|vmov}} 2854 uint64x1_t test_vld1_dup_u64(uint64_t const * a) { 2855 return vld1_dup_u64(a); 2856 } 2857 2858 // CHECK: test_vld1_dup_s8 2859 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2860 int8x8_t test_vld1_dup_s8(int8_t const * a) { 2861 return vld1_dup_s8(a); 2862 } 2863 2864 // CHECK: test_vld1_dup_s16 2865 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2866 int16x4_t test_vld1_dup_s16(int16_t const * a) { 2867 return vld1_dup_s16(a); 2868 } 2869 2870 // CHECK: test_vld1_dup_s32 2871 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2872 int32x2_t test_vld1_dup_s32(int32_t const * a) { 2873 return vld1_dup_s32(a); 2874 } 2875 2876 // CHECK: test_vld1_dup_s64 2877 // CHECK: {{ldr|vldr|vmov}} 2878 int64x1_t test_vld1_dup_s64(int64_t const * a) { 2879 return vld1_dup_s64(a); 2880 } 2881 2882 // CHECK: test_vld1_dup_f16 2883 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2884 float16x4_t test_vld1_dup_f16(float16_t const * a) { 2885 return vld1_dup_f16(a); 2886 } 2887 2888 // CHECK: test_vld1_dup_f32 2889 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2890 float32x2_t test_vld1_dup_f32(float32_t const * a) { 2891 return vld1_dup_f32(a); 2892 } 2893 2894 // CHECK: test_vld1_dup_p8 2895 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2896 poly8x8_t test_vld1_dup_p8(poly8_t const * a) { 2897 return vld1_dup_p8(a); 2898 } 2899 2900 // CHECK: test_vld1_dup_p16 2901 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2902 poly16x4_t test_vld1_dup_p16(poly16_t const * a) { 2903 return vld1_dup_p16(a); 2904 } 2905 2906 2907 // CHECK: test_vld1q_lane_u8 2908 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2909 uint8x16_t test_vld1q_lane_u8(uint8_t const * a, uint8x16_t b) { 2910 return vld1q_lane_u8(a, b, 15); 2911 } 2912 2913 // CHECK: test_vld1q_lane_u16 2914 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2915 uint16x8_t test_vld1q_lane_u16(uint16_t const * a, uint16x8_t b) { 2916 return vld1q_lane_u16(a, b, 7); 2917 } 2918 2919 // CHECK: test_vld1q_lane_u32 2920 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2921 uint32x4_t test_vld1q_lane_u32(uint32_t const * a, uint32x4_t b) { 2922 return vld1q_lane_u32(a, b, 3); 2923 } 2924 2925 // CHECK: test_vld1q_lane_u64 2926 // CHECK: {{ldr|vldr|vmov}} 2927 uint64x2_t test_vld1q_lane_u64(uint64_t const * a, uint64x2_t b) { 2928 return vld1q_lane_u64(a, b, 1); 2929 } 2930 2931 // CHECK: test_vld1q_lane_s8 2932 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2933 int8x16_t test_vld1q_lane_s8(int8_t const * a, int8x16_t b) { 2934 return vld1q_lane_s8(a, b, 15); 2935 } 2936 2937 // CHECK: test_vld1q_lane_s16 2938 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2939 int16x8_t test_vld1q_lane_s16(int16_t const * a, int16x8_t b) { 2940 return vld1q_lane_s16(a, b, 7); 2941 } 2942 2943 // CHECK: test_vld1q_lane_s32 2944 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2945 int32x4_t test_vld1q_lane_s32(int32_t const * a, int32x4_t b) { 2946 return vld1q_lane_s32(a, b, 3); 2947 } 2948 2949 // CHECK: test_vld1q_lane_s64 2950 // CHECK: {{ldr|vldr|vmov}} 2951 int64x2_t test_vld1q_lane_s64(int64_t const * a, int64x2_t b) { 2952 return vld1q_lane_s64(a, b, 1); 2953 } 2954 2955 // CHECK: test_vld1q_lane_f16 2956 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2957 float16x8_t test_vld1q_lane_f16(float16_t const * a, float16x8_t b) { 2958 return vld1q_lane_f16(a, b, 7); 2959 } 2960 2961 // CHECK: test_vld1q_lane_f32 2962 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2963 float32x4_t test_vld1q_lane_f32(float32_t const * a, float32x4_t b) { 2964 return vld1q_lane_f32(a, b, 3); 2965 } 2966 2967 // CHECK: test_vld1q_lane_p8 2968 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2969 poly8x16_t test_vld1q_lane_p8(poly8_t const * a, poly8x16_t b) { 2970 return vld1q_lane_p8(a, b, 15); 2971 } 2972 2973 // CHECK: test_vld1q_lane_p16 2974 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2975 poly16x8_t test_vld1q_lane_p16(poly16_t const * a, poly16x8_t b) { 2976 return vld1q_lane_p16(a, b, 7); 2977 } 2978 2979 // CHECK: test_vld1_lane_u8 2980 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2981 uint8x8_t test_vld1_lane_u8(uint8_t const * a, uint8x8_t b) { 2982 return vld1_lane_u8(a, b, 7); 2983 } 2984 2985 // CHECK: test_vld1_lane_u16 2986 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2987 uint16x4_t test_vld1_lane_u16(uint16_t const * a, uint16x4_t b) { 2988 return vld1_lane_u16(a, b, 3); 2989 } 2990 2991 // CHECK: test_vld1_lane_u32 2992 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2993 uint32x2_t test_vld1_lane_u32(uint32_t const * a, uint32x2_t b) { 2994 return vld1_lane_u32(a, b, 1); 2995 } 2996 2997 // CHECK: test_vld1_lane_u64 2998 // CHECK: {{ldr|vldr|vmov}} 2999 uint64x1_t test_vld1_lane_u64(uint64_t const * a, uint64x1_t b) { 3000 return vld1_lane_u64(a, b, 0); 3001 } 3002 3003 // CHECK: test_vld1_lane_s8 3004 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3005 int8x8_t test_vld1_lane_s8(int8_t const * a, int8x8_t b) { 3006 return vld1_lane_s8(a, b, 7); 3007 } 3008 3009 // CHECK: test_vld1_lane_s16 3010 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3011 int16x4_t test_vld1_lane_s16(int16_t const * a, int16x4_t b) { 3012 return vld1_lane_s16(a, b, 3); 3013 } 3014 3015 // CHECK: test_vld1_lane_s32 3016 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 3017 int32x2_t test_vld1_lane_s32(int32_t const * a, int32x2_t b) { 3018 return vld1_lane_s32(a, b, 1); 3019 } 3020 3021 // CHECK: test_vld1_lane_s64 3022 // CHECK: {{ldr|vldr|vmov}} 3023 int64x1_t test_vld1_lane_s64(int64_t const * a, int64x1_t b) { 3024 return vld1_lane_s64(a, b, 0); 3025 } 3026 3027 // CHECK: test_vld1_lane_f16 3028 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3029 float16x4_t test_vld1_lane_f16(float16_t const * a, float16x4_t b) { 3030 return vld1_lane_f16(a, b, 3); 3031 } 3032 3033 // CHECK: test_vld1_lane_f32 3034 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 3035 float32x2_t test_vld1_lane_f32(float32_t const * a, float32x2_t b) { 3036 return vld1_lane_f32(a, b, 1); 3037 } 3038 3039 // CHECK: test_vld1_lane_p8 3040 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3041 poly8x8_t test_vld1_lane_p8(poly8_t const * a, poly8x8_t b) { 3042 return vld1_lane_p8(a, b, 7); 3043 } 3044 3045 // CHECK: test_vld1_lane_p16 3046 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3047 poly16x4_t test_vld1_lane_p16(poly16_t const * a, poly16x4_t b) { 3048 return vld1_lane_p16(a, b, 3); 3049 } 3050 3051 3052 // CHECK: test_vld2q_u8 3053 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3054 uint8x16x2_t test_vld2q_u8(uint8_t const * a) { 3055 return vld2q_u8(a); 3056 } 3057 3058 // CHECK: test_vld2q_u16 3059 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3060 uint16x8x2_t test_vld2q_u16(uint16_t const * a) { 3061 return vld2q_u16(a); 3062 } 3063 3064 // CHECK: test_vld2q_u32 3065 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3066 uint32x4x2_t test_vld2q_u32(uint32_t const * a) { 3067 return vld2q_u32(a); 3068 } 3069 3070 // CHECK: test_vld2q_s8 3071 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3072 int8x16x2_t test_vld2q_s8(int8_t const * a) { 3073 return vld2q_s8(a); 3074 } 3075 3076 // CHECK: test_vld2q_s16 3077 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3078 int16x8x2_t test_vld2q_s16(int16_t const * a) { 3079 return vld2q_s16(a); 3080 } 3081 3082 // CHECK: test_vld2q_s32 3083 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3084 int32x4x2_t test_vld2q_s32(int32_t const * a) { 3085 return vld2q_s32(a); 3086 } 3087 3088 // CHECK: test_vld2q_f16 3089 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3090 float16x8x2_t test_vld2q_f16(float16_t const * a) { 3091 return vld2q_f16(a); 3092 } 3093 3094 // CHECK: test_vld2q_f32 3095 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3096 float32x4x2_t test_vld2q_f32(float32_t const * a) { 3097 return vld2q_f32(a); 3098 } 3099 3100 // CHECK: test_vld2q_p8 3101 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3102 poly8x16x2_t test_vld2q_p8(poly8_t const * a) { 3103 return vld2q_p8(a); 3104 } 3105 3106 // CHECK: test_vld2q_p16 3107 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3108 poly16x8x2_t test_vld2q_p16(poly16_t const * a) { 3109 return vld2q_p16(a); 3110 } 3111 3112 // CHECK: test_vld2_u8 3113 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3114 uint8x8x2_t test_vld2_u8(uint8_t const * a) { 3115 return vld2_u8(a); 3116 } 3117 3118 // CHECK: test_vld2_u16 3119 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3120 uint16x4x2_t test_vld2_u16(uint16_t const * a) { 3121 return vld2_u16(a); 3122 } 3123 3124 // CHECK: test_vld2_u32 3125 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3126 uint32x2x2_t test_vld2_u32(uint32_t const * a) { 3127 return vld2_u32(a); 3128 } 3129 3130 // CHECK: test_vld2_u64 3131 // CHECK: vld1.64 3132 uint64x1x2_t test_vld2_u64(uint64_t const * a) { 3133 return vld2_u64(a); 3134 } 3135 3136 // CHECK: test_vld2_s8 3137 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3138 int8x8x2_t test_vld2_s8(int8_t const * a) { 3139 return vld2_s8(a); 3140 } 3141 3142 // CHECK: test_vld2_s16 3143 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3144 int16x4x2_t test_vld2_s16(int16_t const * a) { 3145 return vld2_s16(a); 3146 } 3147 3148 // CHECK: test_vld2_s32 3149 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3150 int32x2x2_t test_vld2_s32(int32_t const * a) { 3151 return vld2_s32(a); 3152 } 3153 3154 // CHECK: test_vld2_s64 3155 // CHECK: vld1.64 3156 int64x1x2_t test_vld2_s64(int64_t const * a) { 3157 return vld2_s64(a); 3158 } 3159 3160 // CHECK: test_vld2_f16 3161 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3162 float16x4x2_t test_vld2_f16(float16_t const * a) { 3163 return vld2_f16(a); 3164 } 3165 3166 // CHECK: test_vld2_f32 3167 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3168 float32x2x2_t test_vld2_f32(float32_t const * a) { 3169 return vld2_f32(a); 3170 } 3171 3172 // CHECK: test_vld2_p8 3173 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3174 poly8x8x2_t test_vld2_p8(poly8_t const * a) { 3175 return vld2_p8(a); 3176 } 3177 3178 // CHECK: test_vld2_p16 3179 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3180 poly16x4x2_t test_vld2_p16(poly16_t const * a) { 3181 return vld2_p16(a); 3182 } 3183 3184 3185 // CHECK: test_vld2_dup_u8 3186 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3187 uint8x8x2_t test_vld2_dup_u8(uint8_t const * a) { 3188 return vld2_dup_u8(a); 3189 } 3190 3191 // CHECK: test_vld2_dup_u16 3192 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3193 uint16x4x2_t test_vld2_dup_u16(uint16_t const * a) { 3194 return vld2_dup_u16(a); 3195 } 3196 3197 // CHECK: test_vld2_dup_u32 3198 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3199 uint32x2x2_t test_vld2_dup_u32(uint32_t const * a) { 3200 return vld2_dup_u32(a); 3201 } 3202 3203 // CHECK: test_vld2_dup_u64 3204 // CHECK: vld1.64 3205 uint64x1x2_t test_vld2_dup_u64(uint64_t const * a) { 3206 return vld2_dup_u64(a); 3207 } 3208 3209 // CHECK: test_vld2_dup_s8 3210 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3211 int8x8x2_t test_vld2_dup_s8(int8_t const * a) { 3212 return vld2_dup_s8(a); 3213 } 3214 3215 // CHECK: test_vld2_dup_s16 3216 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3217 int16x4x2_t test_vld2_dup_s16(int16_t const * a) { 3218 return vld2_dup_s16(a); 3219 } 3220 3221 // CHECK: test_vld2_dup_s32 3222 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3223 int32x2x2_t test_vld2_dup_s32(int32_t const * a) { 3224 return vld2_dup_s32(a); 3225 } 3226 3227 // CHECK: test_vld2_dup_s64 3228 // CHECK: vld1.64 3229 int64x1x2_t test_vld2_dup_s64(int64_t const * a) { 3230 return vld2_dup_s64(a); 3231 } 3232 3233 // CHECK: test_vld2_dup_f16 3234 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3235 float16x4x2_t test_vld2_dup_f16(float16_t const * a) { 3236 return vld2_dup_f16(a); 3237 } 3238 3239 // CHECK: test_vld2_dup_f32 3240 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3241 float32x2x2_t test_vld2_dup_f32(float32_t const * a) { 3242 return vld2_dup_f32(a); 3243 } 3244 3245 // CHECK: test_vld2_dup_p8 3246 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3247 poly8x8x2_t test_vld2_dup_p8(poly8_t const * a) { 3248 return vld2_dup_p8(a); 3249 } 3250 3251 // CHECK: test_vld2_dup_p16 3252 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3253 poly16x4x2_t test_vld2_dup_p16(poly16_t const * a) { 3254 return vld2_dup_p16(a); 3255 } 3256 3257 3258 // CHECK: test_vld2q_lane_u16 3259 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3260 uint16x8x2_t test_vld2q_lane_u16(uint16_t const * a, uint16x8x2_t b) { 3261 return vld2q_lane_u16(a, b, 7); 3262 } 3263 3264 // CHECK: test_vld2q_lane_u32 3265 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3266 uint32x4x2_t test_vld2q_lane_u32(uint32_t const * a, uint32x4x2_t b) { 3267 return vld2q_lane_u32(a, b, 3); 3268 } 3269 3270 // CHECK: test_vld2q_lane_s16 3271 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3272 int16x8x2_t test_vld2q_lane_s16(int16_t const * a, int16x8x2_t b) { 3273 return vld2q_lane_s16(a, b, 7); 3274 } 3275 3276 // CHECK: test_vld2q_lane_s32 3277 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3278 int32x4x2_t test_vld2q_lane_s32(int32_t const * a, int32x4x2_t b) { 3279 return vld2q_lane_s32(a, b, 3); 3280 } 3281 3282 // CHECK: test_vld2q_lane_f16 3283 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3284 float16x8x2_t test_vld2q_lane_f16(float16_t const * a, float16x8x2_t b) { 3285 return vld2q_lane_f16(a, b, 7); 3286 } 3287 3288 // CHECK: test_vld2q_lane_f32 3289 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3290 float32x4x2_t test_vld2q_lane_f32(float32_t const * a, float32x4x2_t b) { 3291 return vld2q_lane_f32(a, b, 3); 3292 } 3293 3294 // CHECK: test_vld2q_lane_p16 3295 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3296 poly16x8x2_t test_vld2q_lane_p16(poly16_t const * a, poly16x8x2_t b) { 3297 return vld2q_lane_p16(a, b, 7); 3298 } 3299 3300 // CHECK: test_vld2_lane_u8 3301 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3302 uint8x8x2_t test_vld2_lane_u8(uint8_t const * a, uint8x8x2_t b) { 3303 return vld2_lane_u8(a, b, 7); 3304 } 3305 3306 // CHECK: test_vld2_lane_u16 3307 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3308 uint16x4x2_t test_vld2_lane_u16(uint16_t const * a, uint16x4x2_t b) { 3309 return vld2_lane_u16(a, b, 3); 3310 } 3311 3312 // CHECK: test_vld2_lane_u32 3313 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3314 uint32x2x2_t test_vld2_lane_u32(uint32_t const * a, uint32x2x2_t b) { 3315 return vld2_lane_u32(a, b, 1); 3316 } 3317 3318 // CHECK: test_vld2_lane_s8 3319 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3320 int8x8x2_t test_vld2_lane_s8(int8_t const * a, int8x8x2_t b) { 3321 return vld2_lane_s8(a, b, 7); 3322 } 3323 3324 // CHECK: test_vld2_lane_s16 3325 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3326 int16x4x2_t test_vld2_lane_s16(int16_t const * a, int16x4x2_t b) { 3327 return vld2_lane_s16(a, b, 3); 3328 } 3329 3330 // CHECK: test_vld2_lane_s32 3331 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3332 int32x2x2_t test_vld2_lane_s32(int32_t const * a, int32x2x2_t b) { 3333 return vld2_lane_s32(a, b, 1); 3334 } 3335 3336 // CHECK: test_vld2_lane_f16 3337 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3338 float16x4x2_t test_vld2_lane_f16(float16_t const * a, float16x4x2_t b) { 3339 return vld2_lane_f16(a, b, 3); 3340 } 3341 3342 // CHECK: test_vld2_lane_f32 3343 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3344 float32x2x2_t test_vld2_lane_f32(float32_t const * a, float32x2x2_t b) { 3345 return vld2_lane_f32(a, b, 1); 3346 } 3347 3348 // CHECK: test_vld2_lane_p8 3349 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3350 poly8x8x2_t test_vld2_lane_p8(poly8_t const * a, poly8x8x2_t b) { 3351 return vld2_lane_p8(a, b, 7); 3352 } 3353 3354 // CHECK: test_vld2_lane_p16 3355 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3356 poly16x4x2_t test_vld2_lane_p16(poly16_t const * a, poly16x4x2_t b) { 3357 return vld2_lane_p16(a, b, 3); 3358 } 3359 3360 3361 // CHECK: test_vld3q_u8 3362 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3363 uint8x16x3_t test_vld3q_u8(uint8_t const * a) { 3364 return vld3q_u8(a); 3365 } 3366 3367 // CHECK: test_vld3q_u16 3368 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3369 uint16x8x3_t test_vld3q_u16(uint16_t const * a) { 3370 return vld3q_u16(a); 3371 } 3372 3373 // CHECK: test_vld3q_u32 3374 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3375 uint32x4x3_t test_vld3q_u32(uint32_t const * a) { 3376 return vld3q_u32(a); 3377 } 3378 3379 // CHECK: test_vld3q_s8 3380 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3381 int8x16x3_t test_vld3q_s8(int8_t const * a) { 3382 return vld3q_s8(a); 3383 } 3384 3385 // CHECK: test_vld3q_s16 3386 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3387 int16x8x3_t test_vld3q_s16(int16_t const * a) { 3388 return vld3q_s16(a); 3389 } 3390 3391 // CHECK: test_vld3q_s32 3392 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3393 int32x4x3_t test_vld3q_s32(int32_t const * a) { 3394 return vld3q_s32(a); 3395 } 3396 3397 // CHECK: test_vld3q_f16 3398 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3399 float16x8x3_t test_vld3q_f16(float16_t const * a) { 3400 return vld3q_f16(a); 3401 } 3402 3403 // CHECK: test_vld3q_f32 3404 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3405 float32x4x3_t test_vld3q_f32(float32_t const * a) { 3406 return vld3q_f32(a); 3407 } 3408 3409 // CHECK: test_vld3q_p8 3410 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3411 poly8x16x3_t test_vld3q_p8(poly8_t const * a) { 3412 return vld3q_p8(a); 3413 } 3414 3415 // CHECK: test_vld3q_p16 3416 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3417 poly16x8x3_t test_vld3q_p16(poly16_t const * a) { 3418 return vld3q_p16(a); 3419 } 3420 3421 // CHECK: test_vld3_u8 3422 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3423 uint8x8x3_t test_vld3_u8(uint8_t const * a) { 3424 return vld3_u8(a); 3425 } 3426 3427 // CHECK: test_vld3_u16 3428 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3429 uint16x4x3_t test_vld3_u16(uint16_t const * a) { 3430 return vld3_u16(a); 3431 } 3432 3433 // CHECK: test_vld3_u32 3434 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3435 uint32x2x3_t test_vld3_u32(uint32_t const * a) { 3436 return vld3_u32(a); 3437 } 3438 3439 // CHECK: test_vld3_u64 3440 // CHECK: vld1.64 3441 uint64x1x3_t test_vld3_u64(uint64_t const * a) { 3442 return vld3_u64(a); 3443 } 3444 3445 // CHECK: test_vld3_s8 3446 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3447 int8x8x3_t test_vld3_s8(int8_t const * a) { 3448 return vld3_s8(a); 3449 } 3450 3451 // CHECK: test_vld3_s16 3452 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3453 int16x4x3_t test_vld3_s16(int16_t const * a) { 3454 return vld3_s16(a); 3455 } 3456 3457 // CHECK: test_vld3_s32 3458 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3459 int32x2x3_t test_vld3_s32(int32_t const * a) { 3460 return vld3_s32(a); 3461 } 3462 3463 // CHECK: test_vld3_s64 3464 // CHECK: vld1.64 3465 int64x1x3_t test_vld3_s64(int64_t const * a) { 3466 return vld3_s64(a); 3467 } 3468 3469 // CHECK: test_vld3_f16 3470 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3471 float16x4x3_t test_vld3_f16(float16_t const * a) { 3472 return vld3_f16(a); 3473 } 3474 3475 // CHECK: test_vld3_f32 3476 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3477 float32x2x3_t test_vld3_f32(float32_t const * a) { 3478 return vld3_f32(a); 3479 } 3480 3481 // CHECK: test_vld3_p8 3482 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3483 poly8x8x3_t test_vld3_p8(poly8_t const * a) { 3484 return vld3_p8(a); 3485 } 3486 3487 // CHECK: test_vld3_p16 3488 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3489 poly16x4x3_t test_vld3_p16(poly16_t const * a) { 3490 return vld3_p16(a); 3491 } 3492 3493 3494 // CHECK: test_vld3_dup_u8 3495 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3496 uint8x8x3_t test_vld3_dup_u8(uint8_t const * a) { 3497 return vld3_dup_u8(a); 3498 } 3499 3500 // CHECK: test_vld3_dup_u16 3501 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3502 uint16x4x3_t test_vld3_dup_u16(uint16_t const * a) { 3503 return vld3_dup_u16(a); 3504 } 3505 3506 // CHECK: test_vld3_dup_u32 3507 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3508 uint32x2x3_t test_vld3_dup_u32(uint32_t const * a) { 3509 return vld3_dup_u32(a); 3510 } 3511 3512 // CHECK: test_vld3_dup_u64 3513 // CHECK: vld1.64 3514 uint64x1x3_t test_vld3_dup_u64(uint64_t const * a) { 3515 return vld3_dup_u64(a); 3516 } 3517 3518 // CHECK: test_vld3_dup_s8 3519 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3520 int8x8x3_t test_vld3_dup_s8(int8_t const * a) { 3521 return vld3_dup_s8(a); 3522 } 3523 3524 // CHECK: test_vld3_dup_s16 3525 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3526 int16x4x3_t test_vld3_dup_s16(int16_t const * a) { 3527 return vld3_dup_s16(a); 3528 } 3529 3530 // CHECK: test_vld3_dup_s32 3531 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3532 int32x2x3_t test_vld3_dup_s32(int32_t const * a) { 3533 return vld3_dup_s32(a); 3534 } 3535 3536 // CHECK: test_vld3_dup_s64 3537 // CHECK: vld1.64 3538 int64x1x3_t test_vld3_dup_s64(int64_t const * a) { 3539 return vld3_dup_s64(a); 3540 } 3541 3542 // CHECK: test_vld3_dup_f16 3543 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3544 float16x4x3_t test_vld3_dup_f16(float16_t const * a) { 3545 return vld3_dup_f16(a); 3546 } 3547 3548 // CHECK: test_vld3_dup_f32 3549 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3550 float32x2x3_t test_vld3_dup_f32(float32_t const * a) { 3551 return vld3_dup_f32(a); 3552 } 3553 3554 // CHECK: test_vld3_dup_p8 3555 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3556 poly8x8x3_t test_vld3_dup_p8(poly8_t const * a) { 3557 return vld3_dup_p8(a); 3558 } 3559 3560 // CHECK: test_vld3_dup_p16 3561 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3562 poly16x4x3_t test_vld3_dup_p16(poly16_t const * a) { 3563 return vld3_dup_p16(a); 3564 } 3565 3566 3567 // CHECK: test_vld3q_lane_u16 3568 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3569 uint16x8x3_t test_vld3q_lane_u16(uint16_t const * a, uint16x8x3_t b) { 3570 return vld3q_lane_u16(a, b, 7); 3571 } 3572 3573 // CHECK: test_vld3q_lane_u32 3574 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3575 uint32x4x3_t test_vld3q_lane_u32(uint32_t const * a, uint32x4x3_t b) { 3576 return vld3q_lane_u32(a, b, 3); 3577 } 3578 3579 // CHECK: test_vld3q_lane_s16 3580 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3581 int16x8x3_t test_vld3q_lane_s16(int16_t const * a, int16x8x3_t b) { 3582 return vld3q_lane_s16(a, b, 7); 3583 } 3584 3585 // CHECK: test_vld3q_lane_s32 3586 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3587 int32x4x3_t test_vld3q_lane_s32(int32_t const * a, int32x4x3_t b) { 3588 return vld3q_lane_s32(a, b, 3); 3589 } 3590 3591 // CHECK: test_vld3q_lane_f16 3592 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3593 float16x8x3_t test_vld3q_lane_f16(float16_t const * a, float16x8x3_t b) { 3594 return vld3q_lane_f16(a, b, 7); 3595 } 3596 3597 // CHECK: test_vld3q_lane_f32 3598 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3599 float32x4x3_t test_vld3q_lane_f32(float32_t const * a, float32x4x3_t b) { 3600 return vld3q_lane_f32(a, b, 3); 3601 } 3602 3603 // CHECK: test_vld3q_lane_p16 3604 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3605 poly16x8x3_t test_vld3q_lane_p16(poly16_t const * a, poly16x8x3_t b) { 3606 return vld3q_lane_p16(a, b, 7); 3607 } 3608 3609 // CHECK: test_vld3_lane_u8 3610 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3611 uint8x8x3_t test_vld3_lane_u8(uint8_t const * a, uint8x8x3_t b) { 3612 return vld3_lane_u8(a, b, 7); 3613 } 3614 3615 // CHECK: test_vld3_lane_u16 3616 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3617 uint16x4x3_t test_vld3_lane_u16(uint16_t const * a, uint16x4x3_t b) { 3618 return vld3_lane_u16(a, b, 3); 3619 } 3620 3621 // CHECK: test_vld3_lane_u32 3622 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3623 uint32x2x3_t test_vld3_lane_u32(uint32_t const * a, uint32x2x3_t b) { 3624 return vld3_lane_u32(a, b, 1); 3625 } 3626 3627 // CHECK: test_vld3_lane_s8 3628 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3629 int8x8x3_t test_vld3_lane_s8(int8_t const * a, int8x8x3_t b) { 3630 return vld3_lane_s8(a, b, 7); 3631 } 3632 3633 // CHECK: test_vld3_lane_s16 3634 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3635 int16x4x3_t test_vld3_lane_s16(int16_t const * a, int16x4x3_t b) { 3636 return vld3_lane_s16(a, b, 3); 3637 } 3638 3639 // CHECK: test_vld3_lane_s32 3640 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3641 int32x2x3_t test_vld3_lane_s32(int32_t const * a, int32x2x3_t b) { 3642 return vld3_lane_s32(a, b, 1); 3643 } 3644 3645 // CHECK: test_vld3_lane_f16 3646 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3647 float16x4x3_t test_vld3_lane_f16(float16_t const * a, float16x4x3_t b) { 3648 return vld3_lane_f16(a, b, 3); 3649 } 3650 3651 // CHECK: test_vld3_lane_f32 3652 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3653 float32x2x3_t test_vld3_lane_f32(float32_t const * a, float32x2x3_t b) { 3654 return vld3_lane_f32(a, b, 1); 3655 } 3656 3657 // CHECK: test_vld3_lane_p8 3658 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3659 poly8x8x3_t test_vld3_lane_p8(poly8_t const * a, poly8x8x3_t b) { 3660 return vld3_lane_p8(a, b, 7); 3661 } 3662 3663 // CHECK: test_vld3_lane_p16 3664 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3665 poly16x4x3_t test_vld3_lane_p16(poly16_t const * a, poly16x4x3_t b) { 3666 return vld3_lane_p16(a, b, 3); 3667 } 3668 3669 3670 // CHECK: test_vld4q_u8 3671 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3672 uint8x16x4_t test_vld4q_u8(uint8_t const * a) { 3673 return vld4q_u8(a); 3674 } 3675 3676 // CHECK: test_vld4q_u16 3677 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3678 uint16x8x4_t test_vld4q_u16(uint16_t const * a) { 3679 return vld4q_u16(a); 3680 } 3681 3682 // CHECK: test_vld4q_u32 3683 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3684 uint32x4x4_t test_vld4q_u32(uint32_t const * a) { 3685 return vld4q_u32(a); 3686 } 3687 3688 // CHECK: test_vld4q_s8 3689 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3690 int8x16x4_t test_vld4q_s8(int8_t const * a) { 3691 return vld4q_s8(a); 3692 } 3693 3694 // CHECK: test_vld4q_s16 3695 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3696 int16x8x4_t test_vld4q_s16(int16_t const * a) { 3697 return vld4q_s16(a); 3698 } 3699 3700 // CHECK: test_vld4q_s32 3701 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3702 int32x4x4_t test_vld4q_s32(int32_t const * a) { 3703 return vld4q_s32(a); 3704 } 3705 3706 // CHECK: test_vld4q_f16 3707 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3708 float16x8x4_t test_vld4q_f16(float16_t const * a) { 3709 return vld4q_f16(a); 3710 } 3711 3712 // CHECK: test_vld4q_f32 3713 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3714 float32x4x4_t test_vld4q_f32(float32_t const * a) { 3715 return vld4q_f32(a); 3716 } 3717 3718 // CHECK: test_vld4q_p8 3719 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3720 poly8x16x4_t test_vld4q_p8(poly8_t const * a) { 3721 return vld4q_p8(a); 3722 } 3723 3724 // CHECK: test_vld4q_p16 3725 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3726 poly16x8x4_t test_vld4q_p16(poly16_t const * a) { 3727 return vld4q_p16(a); 3728 } 3729 3730 // CHECK: test_vld4_u8 3731 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3732 uint8x8x4_t test_vld4_u8(uint8_t const * a) { 3733 return vld4_u8(a); 3734 } 3735 3736 // CHECK: test_vld4_u16 3737 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3738 uint16x4x4_t test_vld4_u16(uint16_t const * a) { 3739 return vld4_u16(a); 3740 } 3741 3742 // CHECK: test_vld4_u32 3743 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3744 uint32x2x4_t test_vld4_u32(uint32_t const * a) { 3745 return vld4_u32(a); 3746 } 3747 3748 // CHECK: test_vld4_u64 3749 // CHECK: vld1.64 3750 uint64x1x4_t test_vld4_u64(uint64_t const * a) { 3751 return vld4_u64(a); 3752 } 3753 3754 // CHECK: test_vld4_s8 3755 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3756 int8x8x4_t test_vld4_s8(int8_t const * a) { 3757 return vld4_s8(a); 3758 } 3759 3760 // CHECK: test_vld4_s16 3761 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3762 int16x4x4_t test_vld4_s16(int16_t const * a) { 3763 return vld4_s16(a); 3764 } 3765 3766 // CHECK: test_vld4_s32 3767 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3768 int32x2x4_t test_vld4_s32(int32_t const * a) { 3769 return vld4_s32(a); 3770 } 3771 3772 // CHECK: test_vld4_s64 3773 // CHECK: vld1.64 3774 int64x1x4_t test_vld4_s64(int64_t const * a) { 3775 return vld4_s64(a); 3776 } 3777 3778 // CHECK: test_vld4_f16 3779 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3780 float16x4x4_t test_vld4_f16(float16_t const * a) { 3781 return vld4_f16(a); 3782 } 3783 3784 // CHECK: test_vld4_f32 3785 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3786 float32x2x4_t test_vld4_f32(float32_t const * a) { 3787 return vld4_f32(a); 3788 } 3789 3790 // CHECK: test_vld4_p8 3791 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3792 poly8x8x4_t test_vld4_p8(poly8_t const * a) { 3793 return vld4_p8(a); 3794 } 3795 3796 // CHECK: test_vld4_p16 3797 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3798 poly16x4x4_t test_vld4_p16(poly16_t const * a) { 3799 return vld4_p16(a); 3800 } 3801 3802 3803 // CHECK: test_vld4_dup_u8 3804 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3805 uint8x8x4_t test_vld4_dup_u8(uint8_t const * a) { 3806 return vld4_dup_u8(a); 3807 } 3808 3809 // CHECK: test_vld4_dup_u16 3810 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3811 uint16x4x4_t test_vld4_dup_u16(uint16_t const * a) { 3812 return vld4_dup_u16(a); 3813 } 3814 3815 // CHECK: test_vld4_dup_u32 3816 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3817 uint32x2x4_t test_vld4_dup_u32(uint32_t const * a) { 3818 return vld4_dup_u32(a); 3819 } 3820 3821 // CHECK: test_vld4_dup_u64 3822 // CHECK: vld1.64 3823 uint64x1x4_t test_vld4_dup_u64(uint64_t const * a) { 3824 return vld4_dup_u64(a); 3825 } 3826 3827 // CHECK: test_vld4_dup_s8 3828 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3829 int8x8x4_t test_vld4_dup_s8(int8_t const * a) { 3830 return vld4_dup_s8(a); 3831 } 3832 3833 // CHECK: test_vld4_dup_s16 3834 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3835 int16x4x4_t test_vld4_dup_s16(int16_t const * a) { 3836 return vld4_dup_s16(a); 3837 } 3838 3839 // CHECK: test_vld4_dup_s32 3840 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3841 int32x2x4_t test_vld4_dup_s32(int32_t const * a) { 3842 return vld4_dup_s32(a); 3843 } 3844 3845 // CHECK: test_vld4_dup_s64 3846 // CHECK: vld1.64 3847 int64x1x4_t test_vld4_dup_s64(int64_t const * a) { 3848 return vld4_dup_s64(a); 3849 } 3850 3851 // CHECK: test_vld4_dup_f16 3852 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3853 float16x4x4_t test_vld4_dup_f16(float16_t const * a) { 3854 return vld4_dup_f16(a); 3855 } 3856 3857 // CHECK: test_vld4_dup_f32 3858 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3859 float32x2x4_t test_vld4_dup_f32(float32_t const * a) { 3860 return vld4_dup_f32(a); 3861 } 3862 3863 // CHECK: test_vld4_dup_p8 3864 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3865 poly8x8x4_t test_vld4_dup_p8(poly8_t const * a) { 3866 return vld4_dup_p8(a); 3867 } 3868 3869 // CHECK: test_vld4_dup_p16 3870 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3871 poly16x4x4_t test_vld4_dup_p16(poly16_t const * a) { 3872 return vld4_dup_p16(a); 3873 } 3874 3875 3876 // CHECK: test_vld4q_lane_u16 3877 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3878 uint16x8x4_t test_vld4q_lane_u16(uint16_t const * a, uint16x8x4_t b) { 3879 return vld4q_lane_u16(a, b, 7); 3880 } 3881 3882 // CHECK: test_vld4q_lane_u32 3883 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3884 uint32x4x4_t test_vld4q_lane_u32(uint32_t const * a, uint32x4x4_t b) { 3885 return vld4q_lane_u32(a, b, 3); 3886 } 3887 3888 // CHECK: test_vld4q_lane_s16 3889 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3890 int16x8x4_t test_vld4q_lane_s16(int16_t const * a, int16x8x4_t b) { 3891 return vld4q_lane_s16(a, b, 7); 3892 } 3893 3894 // CHECK: test_vld4q_lane_s32 3895 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3896 int32x4x4_t test_vld4q_lane_s32(int32_t const * a, int32x4x4_t b) { 3897 return vld4q_lane_s32(a, b, 3); 3898 } 3899 3900 // CHECK: test_vld4q_lane_f16 3901 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3902 float16x8x4_t test_vld4q_lane_f16(float16_t const * a, float16x8x4_t b) { 3903 return vld4q_lane_f16(a, b, 7); 3904 } 3905 3906 // CHECK: test_vld4q_lane_f32 3907 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3908 float32x4x4_t test_vld4q_lane_f32(float32_t const * a, float32x4x4_t b) { 3909 return vld4q_lane_f32(a, b, 3); 3910 } 3911 3912 // CHECK: test_vld4q_lane_p16 3913 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3914 poly16x8x4_t test_vld4q_lane_p16(poly16_t const * a, poly16x8x4_t b) { 3915 return vld4q_lane_p16(a, b, 7); 3916 } 3917 3918 // CHECK: test_vld4_lane_u8 3919 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3920 uint8x8x4_t test_vld4_lane_u8(uint8_t const * a, uint8x8x4_t b) { 3921 return vld4_lane_u8(a, b, 7); 3922 } 3923 3924 // CHECK: test_vld4_lane_u16 3925 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3926 uint16x4x4_t test_vld4_lane_u16(uint16_t const * a, uint16x4x4_t b) { 3927 return vld4_lane_u16(a, b, 3); 3928 } 3929 3930 // CHECK: test_vld4_lane_u32 3931 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3932 uint32x2x4_t test_vld4_lane_u32(uint32_t const * a, uint32x2x4_t b) { 3933 return vld4_lane_u32(a, b, 1); 3934 } 3935 3936 // CHECK: test_vld4_lane_s8 3937 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3938 int8x8x4_t test_vld4_lane_s8(int8_t const * a, int8x8x4_t b) { 3939 return vld4_lane_s8(a, b, 7); 3940 } 3941 3942 // CHECK: test_vld4_lane_s16 3943 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3944 int16x4x4_t test_vld4_lane_s16(int16_t const * a, int16x4x4_t b) { 3945 return vld4_lane_s16(a, b, 3); 3946 } 3947 3948 // CHECK: test_vld4_lane_s32 3949 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3950 int32x2x4_t test_vld4_lane_s32(int32_t const * a, int32x2x4_t b) { 3951 return vld4_lane_s32(a, b, 1); 3952 } 3953 3954 // CHECK: test_vld4_lane_f16 3955 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3956 float16x4x4_t test_vld4_lane_f16(float16_t const * a, float16x4x4_t b) { 3957 return vld4_lane_f16(a, b, 3); 3958 } 3959 3960 // CHECK: test_vld4_lane_f32 3961 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3962 float32x2x4_t test_vld4_lane_f32(float32_t const * a, float32x2x4_t b) { 3963 return vld4_lane_f32(a, b, 1); 3964 } 3965 3966 // CHECK: test_vld4_lane_p8 3967 // CHECK: vld4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3968 poly8x8x4_t test_vld4_lane_p8(poly8_t const * a, poly8x8x4_t b) { 3969 return vld4_lane_p8(a, b, 7); 3970 } 3971 3972 // CHECK: test_vld4_lane_p16 3973 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3974 poly16x4x4_t test_vld4_lane_p16(poly16_t const * a, poly16x4x4_t b) { 3975 return vld4_lane_p16(a, b, 3); 3976 } 3977 3978 3979 // CHECK: test_vmax_s8 3980 // CHECK: vmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 3981 int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) { 3982 return vmax_s8(a, b); 3983 } 3984 3985 // CHECK: test_vmax_s16 3986 // CHECK: vmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 3987 int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) { 3988 return vmax_s16(a, b); 3989 } 3990 3991 // CHECK: test_vmax_s32 3992 // CHECK: vmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 3993 int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) { 3994 return vmax_s32(a, b); 3995 } 3996 3997 // CHECK: test_vmax_u8 3998 // CHECK: vmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 3999 uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) { 4000 return vmax_u8(a, b); 4001 } 4002 4003 // CHECK: test_vmax_u16 4004 // CHECK: vmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4005 uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) { 4006 return vmax_u16(a, b); 4007 } 4008 4009 // CHECK: test_vmax_u32 4010 // CHECK: vmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4011 uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) { 4012 return vmax_u32(a, b); 4013 } 4014 4015 // CHECK: test_vmax_f32 4016 // CHECK: vmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4017 float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) { 4018 return vmax_f32(a, b); 4019 } 4020 4021 // CHECK: test_vmaxq_s8 4022 // CHECK: vmax.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4023 int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) { 4024 return vmaxq_s8(a, b); 4025 } 4026 4027 // CHECK: test_vmaxq_s16 4028 // CHECK: vmax.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4029 int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) { 4030 return vmaxq_s16(a, b); 4031 } 4032 4033 // CHECK: test_vmaxq_s32 4034 // CHECK: vmax.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4035 int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) { 4036 return vmaxq_s32(a, b); 4037 } 4038 4039 // CHECK: test_vmaxq_u8 4040 // CHECK: vmax.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4041 uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) { 4042 return vmaxq_u8(a, b); 4043 } 4044 4045 // CHECK: test_vmaxq_u16 4046 // CHECK: vmax.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4047 uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) { 4048 return vmaxq_u16(a, b); 4049 } 4050 4051 // CHECK: test_vmaxq_u32 4052 // CHECK: vmax.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4053 uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) { 4054 return vmaxq_u32(a, b); 4055 } 4056 4057 // CHECK: test_vmaxq_f32 4058 // CHECK: vmax.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4059 float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) { 4060 return vmaxq_f32(a, b); 4061 } 4062 4063 4064 // CHECK: test_vmin_s8 4065 // CHECK: vmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4066 int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) { 4067 return vmin_s8(a, b); 4068 } 4069 4070 // CHECK: test_vmin_s16 4071 // CHECK: vmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4072 int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) { 4073 return vmin_s16(a, b); 4074 } 4075 4076 // CHECK: test_vmin_s32 4077 // CHECK: vmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4078 int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) { 4079 return vmin_s32(a, b); 4080 } 4081 4082 // CHECK: test_vmin_u8 4083 // CHECK: vmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4084 uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) { 4085 return vmin_u8(a, b); 4086 } 4087 4088 // CHECK: test_vmin_u16 4089 // CHECK: vmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4090 uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) { 4091 return vmin_u16(a, b); 4092 } 4093 4094 // CHECK: test_vmin_u32 4095 // CHECK: vmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4096 uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) { 4097 return vmin_u32(a, b); 4098 } 4099 4100 // CHECK: test_vmin_f32 4101 // CHECK: vmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4102 float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) { 4103 return vmin_f32(a, b); 4104 } 4105 4106 // CHECK: test_vminq_s8 4107 // CHECK: vmin.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4108 int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) { 4109 return vminq_s8(a, b); 4110 } 4111 4112 // CHECK: test_vminq_s16 4113 // CHECK: vmin.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4114 int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) { 4115 return vminq_s16(a, b); 4116 } 4117 4118 // CHECK: test_vminq_s32 4119 // CHECK: vmin.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4120 int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) { 4121 return vminq_s32(a, b); 4122 } 4123 4124 // CHECK: test_vminq_u8 4125 // CHECK: vmin.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4126 uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) { 4127 return vminq_u8(a, b); 4128 } 4129 4130 // CHECK: test_vminq_u16 4131 // CHECK: vmin.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4132 uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) { 4133 return vminq_u16(a, b); 4134 } 4135 4136 // CHECK: test_vminq_u32 4137 // CHECK: vmin.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4138 uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) { 4139 return vminq_u32(a, b); 4140 } 4141 4142 // CHECK: test_vminq_f32 4143 // CHECK: vmin.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4144 float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) { 4145 return vminq_f32(a, b); 4146 } 4147 4148 4149 // CHECK: test_vmla_s8 4150 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4151 int8x8_t test_vmla_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 4152 return vmla_s8(a, b, c); 4153 } 4154 4155 // CHECK: test_vmla_s16 4156 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4157 int16x4_t test_vmla_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4158 return vmla_s16(a, b, c); 4159 } 4160 4161 // CHECK: test_vmla_s32 4162 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4163 int32x2_t test_vmla_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4164 return vmla_s32(a, b, c); 4165 } 4166 4167 // CHECK: test_vmla_f32 4168 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4169 // CHECK: vadd.f32 4170 float32x2_t test_vmla_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4171 return vmla_f32(a, b, c); 4172 } 4173 4174 // CHECK: test_vmla_u8 4175 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4176 uint8x8_t test_vmla_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 4177 return vmla_u8(a, b, c); 4178 } 4179 4180 // CHECK: test_vmla_u16 4181 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4182 uint16x4_t test_vmla_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4183 return vmla_u16(a, b, c); 4184 } 4185 4186 // CHECK: test_vmla_u32 4187 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4188 uint32x2_t test_vmla_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4189 return vmla_u32(a, b, c); 4190 } 4191 4192 // CHECK: test_vmlaq_s8 4193 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4194 int8x16_t test_vmlaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 4195 return vmlaq_s8(a, b, c); 4196 } 4197 4198 // CHECK: test_vmlaq_s16 4199 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4200 int16x8_t test_vmlaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 4201 return vmlaq_s16(a, b, c); 4202 } 4203 4204 // CHECK: test_vmlaq_s32 4205 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4206 int32x4_t test_vmlaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 4207 return vmlaq_s32(a, b, c); 4208 } 4209 4210 // CHECK: test_vmlaq_f32 4211 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4212 // CHECK: vadd.f32 4213 float32x4_t test_vmlaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 4214 return vmlaq_f32(a, b, c); 4215 } 4216 4217 // CHECK: test_vmlaq_u8 4218 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4219 uint8x16_t test_vmlaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 4220 return vmlaq_u8(a, b, c); 4221 } 4222 4223 // CHECK: test_vmlaq_u16 4224 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4225 uint16x8_t test_vmlaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 4226 return vmlaq_u16(a, b, c); 4227 } 4228 4229 // CHECK: test_vmlaq_u32 4230 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4231 uint32x4_t test_vmlaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 4232 return vmlaq_u32(a, b, c); 4233 } 4234 4235 4236 // CHECK: test_vmlal_s8 4237 // CHECK: vmlal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4238 int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 4239 return vmlal_s8(a, b, c); 4240 } 4241 4242 // CHECK: test_vmlal_s16 4243 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4244 int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4245 return vmlal_s16(a, b, c); 4246 } 4247 4248 // CHECK: test_vmlal_s32 4249 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4250 int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4251 return vmlal_s32(a, b, c); 4252 } 4253 4254 // CHECK: test_vmlal_u8 4255 // CHECK: vmlal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4256 uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 4257 return vmlal_u8(a, b, c); 4258 } 4259 4260 // CHECK: test_vmlal_u16 4261 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4262 uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4263 return vmlal_u16(a, b, c); 4264 } 4265 4266 // CHECK: test_vmlal_u32 4267 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4268 uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4269 return vmlal_u32(a, b, c); 4270 } 4271 4272 4273 // CHECK: test_vmlal_lane_s16 4274 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4275 int32x4_t test_vmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4276 return vmlal_lane_s16(a, b, c, 3); 4277 } 4278 4279 // CHECK: test_vmlal_lane_s32 4280 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4281 int64x2_t test_vmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4282 return vmlal_lane_s32(a, b, c, 1); 4283 } 4284 4285 // CHECK: test_vmlal_lane_u16 4286 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4287 uint32x4_t test_vmlal_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4288 return vmlal_lane_u16(a, b, c, 3); 4289 } 4290 4291 // CHECK: test_vmlal_lane_u32 4292 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4293 uint64x2_t test_vmlal_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4294 return vmlal_lane_u32(a, b, c, 1); 4295 } 4296 4297 4298 // CHECK: test_vmlal_n_s16 4299 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4300 int32x4_t test_vmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 4301 return vmlal_n_s16(a, b, c); 4302 } 4303 4304 // CHECK: test_vmlal_n_s32 4305 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4306 int64x2_t test_vmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 4307 return vmlal_n_s32(a, b, c); 4308 } 4309 4310 // CHECK: test_vmlal_n_u16 4311 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4312 uint32x4_t test_vmlal_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) { 4313 return vmlal_n_u16(a, b, c); 4314 } 4315 4316 // CHECK: test_vmlal_n_u32 4317 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4318 uint64x2_t test_vmlal_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) { 4319 return vmlal_n_u32(a, b, c); 4320 } 4321 4322 4323 // CHECK: test_vmla_lane_s16 4324 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4325 int16x4_t test_vmla_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4326 return vmla_lane_s16(a, b, c, 3); 4327 } 4328 4329 // CHECK: test_vmla_lane_s32 4330 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4331 int32x2_t test_vmla_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4332 return vmla_lane_s32(a, b, c, 1); 4333 } 4334 4335 // CHECK: test_vmla_lane_u16 4336 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4337 uint16x4_t test_vmla_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4338 return vmla_lane_u16(a, b, c, 3); 4339 } 4340 4341 // CHECK: test_vmla_lane_u32 4342 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4343 uint32x2_t test_vmla_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4344 return vmla_lane_u32(a, b, c, 1); 4345 } 4346 4347 // CHECK: test_vmla_lane_f32 4348 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4349 // CHECK: vadd.f32 4350 float32x2_t test_vmla_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4351 return vmla_lane_f32(a, b, c, 1); 4352 } 4353 4354 // CHECK: test_vmlaq_lane_s16 4355 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4356 int16x8_t test_vmlaq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) { 4357 return vmlaq_lane_s16(a, b, c, 3); 4358 } 4359 4360 // CHECK: test_vmlaq_lane_s32 4361 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4362 int32x4_t test_vmlaq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) { 4363 return vmlaq_lane_s32(a, b, c, 1); 4364 } 4365 4366 // CHECK: test_vmlaq_lane_u16 4367 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4368 uint16x8_t test_vmlaq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) { 4369 return vmlaq_lane_u16(a, b, c, 3); 4370 } 4371 4372 // CHECK: test_vmlaq_lane_u32 4373 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4374 uint32x4_t test_vmlaq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) { 4375 return vmlaq_lane_u32(a, b, c, 1); 4376 } 4377 4378 // CHECK: test_vmlaq_lane_f32 4379 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4380 // CHECK: vadd.f32 4381 float32x4_t test_vmlaq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) { 4382 return vmlaq_lane_f32(a, b, c, 1); 4383 } 4384 4385 4386 // CHECK: test_vmla_n_s16 4387 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4388 int16x4_t test_vmla_n_s16(int16x4_t a, int16x4_t b, int16_t c) { 4389 return vmla_n_s16(a, b, c); 4390 } 4391 4392 // CHECK: test_vmla_n_s32 4393 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4394 int32x2_t test_vmla_n_s32(int32x2_t a, int32x2_t b, int32_t c) { 4395 return vmla_n_s32(a, b, c); 4396 } 4397 4398 // CHECK: test_vmla_n_u16 4399 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4400 uint16x4_t test_vmla_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) { 4401 return vmla_n_u16(a, b, c); 4402 } 4403 4404 // CHECK: test_vmla_n_u32 4405 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4406 uint32x2_t test_vmla_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) { 4407 return vmla_n_u32(a, b, c); 4408 } 4409 4410 // CHECK: test_vmla_n_f32 4411 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4412 // CHECK: vadd.f32 4413 float32x2_t test_vmla_n_f32(float32x2_t a, float32x2_t b, float32_t c) { 4414 return vmla_n_f32(a, b, c); 4415 } 4416 4417 // CHECK: test_vmlaq_n_s16 4418 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4419 int16x8_t test_vmlaq_n_s16(int16x8_t a, int16x8_t b, int16_t c) { 4420 return vmlaq_n_s16(a, b, c); 4421 } 4422 4423 // CHECK: test_vmlaq_n_s32 4424 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4425 int32x4_t test_vmlaq_n_s32(int32x4_t a, int32x4_t b, int32_t c) { 4426 return vmlaq_n_s32(a, b, c); 4427 } 4428 4429 // CHECK: test_vmlaq_n_u16 4430 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4431 uint16x8_t test_vmlaq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) { 4432 return vmlaq_n_u16(a, b, c); 4433 } 4434 4435 // CHECK: test_vmlaq_n_u32 4436 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4437 uint32x4_t test_vmlaq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) { 4438 return vmlaq_n_u32(a, b, c); 4439 } 4440 4441 // CHECK: test_vmlaq_n_f32 4442 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4443 // CHECK: vadd.f32 4444 float32x4_t test_vmlaq_n_f32(float32x4_t a, float32x4_t b, float32_t c) { 4445 return vmlaq_n_f32(a, b, c); 4446 } 4447 4448 4449 // CHECK: test_vmls_s8 4450 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4451 int8x8_t test_vmls_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 4452 return vmls_s8(a, b, c); 4453 } 4454 4455 // CHECK: test_vmls_s16 4456 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4457 int16x4_t test_vmls_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4458 return vmls_s16(a, b, c); 4459 } 4460 4461 // CHECK: test_vmls_s32 4462 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4463 int32x2_t test_vmls_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4464 return vmls_s32(a, b, c); 4465 } 4466 4467 // CHECK: test_vmls_f32 4468 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4469 // CHECK: vsub.f32 4470 float32x2_t test_vmls_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4471 return vmls_f32(a, b, c); 4472 } 4473 4474 // CHECK: test_vmls_u8 4475 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4476 uint8x8_t test_vmls_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 4477 return vmls_u8(a, b, c); 4478 } 4479 4480 // CHECK: test_vmls_u16 4481 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4482 uint16x4_t test_vmls_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4483 return vmls_u16(a, b, c); 4484 } 4485 4486 // CHECK: test_vmls_u32 4487 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4488 uint32x2_t test_vmls_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4489 return vmls_u32(a, b, c); 4490 } 4491 4492 // CHECK: test_vmlsq_s8 4493 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4494 int8x16_t test_vmlsq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 4495 return vmlsq_s8(a, b, c); 4496 } 4497 4498 // CHECK: test_vmlsq_s16 4499 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4500 int16x8_t test_vmlsq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 4501 return vmlsq_s16(a, b, c); 4502 } 4503 4504 // CHECK: test_vmlsq_s32 4505 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4506 int32x4_t test_vmlsq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 4507 return vmlsq_s32(a, b, c); 4508 } 4509 4510 // CHECK: test_vmlsq_f32 4511 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4512 // CHECK: vsub.f32 4513 float32x4_t test_vmlsq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 4514 return vmlsq_f32(a, b, c); 4515 } 4516 4517 // CHECK: test_vmlsq_u8 4518 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4519 uint8x16_t test_vmlsq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 4520 return vmlsq_u8(a, b, c); 4521 } 4522 4523 // CHECK: test_vmlsq_u16 4524 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4525 uint16x8_t test_vmlsq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 4526 return vmlsq_u16(a, b, c); 4527 } 4528 4529 // CHECK: test_vmlsq_u32 4530 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4531 uint32x4_t test_vmlsq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 4532 return vmlsq_u32(a, b, c); 4533 } 4534 4535 4536 // CHECK: test_vmlsl_s8 4537 // CHECK: vmlsl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4538 int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 4539 return vmlsl_s8(a, b, c); 4540 } 4541 4542 // CHECK: test_vmlsl_s16 4543 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4544 int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4545 return vmlsl_s16(a, b, c); 4546 } 4547 4548 // CHECK: test_vmlsl_s32 4549 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4550 int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4551 return vmlsl_s32(a, b, c); 4552 } 4553 4554 // CHECK: test_vmlsl_u8 4555 // CHECK: vmlsl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4556 uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 4557 return vmlsl_u8(a, b, c); 4558 } 4559 4560 // CHECK: test_vmlsl_u16 4561 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4562 uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4563 return vmlsl_u16(a, b, c); 4564 } 4565 4566 // CHECK: test_vmlsl_u32 4567 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4568 uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4569 return vmlsl_u32(a, b, c); 4570 } 4571 4572 4573 // CHECK: test_vmlsl_lane_s16 4574 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4575 int32x4_t test_vmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4576 return vmlsl_lane_s16(a, b, c, 3); 4577 } 4578 4579 // CHECK: test_vmlsl_lane_s32 4580 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4581 int64x2_t test_vmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4582 return vmlsl_lane_s32(a, b, c, 1); 4583 } 4584 4585 // CHECK: test_vmlsl_lane_u16 4586 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4587 uint32x4_t test_vmlsl_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4588 return vmlsl_lane_u16(a, b, c, 3); 4589 } 4590 4591 // CHECK: test_vmlsl_lane_u32 4592 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4593 uint64x2_t test_vmlsl_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4594 return vmlsl_lane_u32(a, b, c, 1); 4595 } 4596 4597 4598 // CHECK: test_vmlsl_n_s16 4599 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4600 int32x4_t test_vmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 4601 return vmlsl_n_s16(a, b, c); 4602 } 4603 4604 // CHECK: test_vmlsl_n_s32 4605 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4606 int64x2_t test_vmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 4607 return vmlsl_n_s32(a, b, c); 4608 } 4609 4610 // CHECK: test_vmlsl_n_u16 4611 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4612 uint32x4_t test_vmlsl_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) { 4613 return vmlsl_n_u16(a, b, c); 4614 } 4615 4616 // CHECK: test_vmlsl_n_u32 4617 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4618 uint64x2_t test_vmlsl_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) { 4619 return vmlsl_n_u32(a, b, c); 4620 } 4621 4622 4623 // CHECK: test_vmls_lane_s16 4624 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4625 int16x4_t test_vmls_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4626 return vmls_lane_s16(a, b, c, 3); 4627 } 4628 4629 // CHECK: test_vmls_lane_s32 4630 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4631 int32x2_t test_vmls_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4632 return vmls_lane_s32(a, b, c, 1); 4633 } 4634 4635 // CHECK: test_vmls_lane_u16 4636 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4637 uint16x4_t test_vmls_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4638 return vmls_lane_u16(a, b, c, 3); 4639 } 4640 4641 // CHECK: test_vmls_lane_u32 4642 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4643 uint32x2_t test_vmls_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4644 return vmls_lane_u32(a, b, c, 1); 4645 } 4646 4647 // CHECK: test_vmls_lane_f32 4648 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4649 // CHECK: vsub.f32 4650 float32x2_t test_vmls_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4651 return vmls_lane_f32(a, b, c, 1); 4652 } 4653 4654 // CHECK: test_vmlsq_lane_s16 4655 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4656 int16x8_t test_vmlsq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) { 4657 return vmlsq_lane_s16(a, b, c, 3); 4658 } 4659 4660 // CHECK: test_vmlsq_lane_s32 4661 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4662 int32x4_t test_vmlsq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) { 4663 return vmlsq_lane_s32(a, b, c, 1); 4664 } 4665 4666 // CHECK: test_vmlsq_lane_u16 4667 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4668 uint16x8_t test_vmlsq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) { 4669 return vmlsq_lane_u16(a, b, c, 3); 4670 } 4671 4672 // CHECK: test_vmlsq_lane_u32 4673 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4674 uint32x4_t test_vmlsq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) { 4675 return vmlsq_lane_u32(a, b, c, 1); 4676 } 4677 4678 // CHECK: test_vmlsq_lane_f32 4679 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4680 // CHECK: vsub.f32 4681 float32x4_t test_vmlsq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) { 4682 return vmlsq_lane_f32(a, b, c, 1); 4683 } 4684 4685 4686 // CHECK: test_vmls_n_s16 4687 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4688 int16x4_t test_vmls_n_s16(int16x4_t a, int16x4_t b, int16_t c) { 4689 return vmls_n_s16(a, b, c); 4690 } 4691 4692 // CHECK: test_vmls_n_s32 4693 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4694 int32x2_t test_vmls_n_s32(int32x2_t a, int32x2_t b, int32_t c) { 4695 return vmls_n_s32(a, b, c); 4696 } 4697 4698 // CHECK: test_vmls_n_u16 4699 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4700 uint16x4_t test_vmls_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) { 4701 return vmls_n_u16(a, b, c); 4702 } 4703 4704 // CHECK: test_vmls_n_u32 4705 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4706 uint32x2_t test_vmls_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) { 4707 return vmls_n_u32(a, b, c); 4708 } 4709 4710 // CHECK: test_vmls_n_f32 4711 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4712 // CHECK: vsub.f32 4713 float32x2_t test_vmls_n_f32(float32x2_t a, float32x2_t b, float32_t c) { 4714 return vmls_n_f32(a, b, c); 4715 } 4716 4717 // CHECK: test_vmlsq_n_s16 4718 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4719 int16x8_t test_vmlsq_n_s16(int16x8_t a, int16x8_t b, int16_t c) { 4720 return vmlsq_n_s16(a, b, c); 4721 } 4722 4723 // CHECK: test_vmlsq_n_s32 4724 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4725 int32x4_t test_vmlsq_n_s32(int32x4_t a, int32x4_t b, int32_t c) { 4726 return vmlsq_n_s32(a, b, c); 4727 } 4728 4729 // CHECK: test_vmlsq_n_u16 4730 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4731 uint16x8_t test_vmlsq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) { 4732 return vmlsq_n_u16(a, b, c); 4733 } 4734 4735 // CHECK: test_vmlsq_n_u32 4736 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4737 uint32x4_t test_vmlsq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) { 4738 return vmlsq_n_u32(a, b, c); 4739 } 4740 4741 // CHECK: test_vmlsq_n_f32 4742 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4743 // CHECK: vsub.f32 4744 float32x4_t test_vmlsq_n_f32(float32x4_t a, float32x4_t b, float32_t c) { 4745 return vmlsq_n_f32(a, b, c); 4746 } 4747 4748 4749 // CHECK: test_vmovl_s8 4750 // CHECK: vmovl.s8 q{{[0-9]+}}, d{{[0-9]+}} 4751 int16x8_t test_vmovl_s8(int8x8_t a) { 4752 return vmovl_s8(a); 4753 } 4754 4755 // CHECK: test_vmovl_s16 4756 // CHECK: vmovl.s16 q{{[0-9]+}}, d{{[0-9]+}} 4757 int32x4_t test_vmovl_s16(int16x4_t a) { 4758 return vmovl_s16(a); 4759 } 4760 4761 // CHECK: test_vmovl_s32 4762 // CHECK: vmovl.s32 q{{[0-9]+}}, d{{[0-9]+}} 4763 int64x2_t test_vmovl_s32(int32x2_t a) { 4764 return vmovl_s32(a); 4765 } 4766 4767 // CHECK: test_vmovl_u8 4768 // CHECK: vmovl.u8 q{{[0-9]+}}, d{{[0-9]+}} 4769 uint16x8_t test_vmovl_u8(uint8x8_t a) { 4770 return vmovl_u8(a); 4771 } 4772 4773 // CHECK: test_vmovl_u16 4774 // CHECK: vmovl.u16 q{{[0-9]+}}, d{{[0-9]+}} 4775 uint32x4_t test_vmovl_u16(uint16x4_t a) { 4776 return vmovl_u16(a); 4777 } 4778 4779 // CHECK: test_vmovl_u32 4780 // CHECK: vmovl.u32 q{{[0-9]+}}, d{{[0-9]+}} 4781 uint64x2_t test_vmovl_u32(uint32x2_t a) { 4782 return vmovl_u32(a); 4783 } 4784 4785 4786 // CHECK: test_vmovn_s16 4787 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}} 4788 int8x8_t test_vmovn_s16(int16x8_t a) { 4789 return vmovn_s16(a); 4790 } 4791 4792 // CHECK: test_vmovn_s32 4793 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}} 4794 int16x4_t test_vmovn_s32(int32x4_t a) { 4795 return vmovn_s32(a); 4796 } 4797 4798 // CHECK: test_vmovn_s64 4799 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}} 4800 int32x2_t test_vmovn_s64(int64x2_t a) { 4801 return vmovn_s64(a); 4802 } 4803 4804 // CHECK: test_vmovn_u16 4805 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}} 4806 uint8x8_t test_vmovn_u16(uint16x8_t a) { 4807 return vmovn_u16(a); 4808 } 4809 4810 // CHECK: test_vmovn_u32 4811 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}} 4812 uint16x4_t test_vmovn_u32(uint32x4_t a) { 4813 return vmovn_u32(a); 4814 } 4815 4816 // CHECK: test_vmovn_u64 4817 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}} 4818 uint32x2_t test_vmovn_u64(uint64x2_t a) { 4819 return vmovn_u64(a); 4820 } 4821 4822 4823 // CHECK: test_vmov_n_u8 4824 // CHECK: vmov 4825 uint8x8_t test_vmov_n_u8(uint8_t a) { 4826 return vmov_n_u8(a); 4827 } 4828 4829 // CHECK: test_vmov_n_u16 4830 // CHECK: vmov 4831 uint16x4_t test_vmov_n_u16(uint16_t a) { 4832 return vmov_n_u16(a); 4833 } 4834 4835 // CHECK: test_vmov_n_u32 4836 // CHECK: vmov 4837 uint32x2_t test_vmov_n_u32(uint32_t a) { 4838 return vmov_n_u32(a); 4839 } 4840 4841 // CHECK: test_vmov_n_s8 4842 // CHECK: vmov 4843 int8x8_t test_vmov_n_s8(int8_t a) { 4844 return vmov_n_s8(a); 4845 } 4846 4847 // CHECK: test_vmov_n_s16 4848 // CHECK: vmov 4849 int16x4_t test_vmov_n_s16(int16_t a) { 4850 return vmov_n_s16(a); 4851 } 4852 4853 // CHECK: test_vmov_n_s32 4854 // CHECK: vmov 4855 int32x2_t test_vmov_n_s32(int32_t a) { 4856 return vmov_n_s32(a); 4857 } 4858 4859 // CHECK: test_vmov_n_p8 4860 // CHECK: vmov 4861 poly8x8_t test_vmov_n_p8(poly8_t a) { 4862 return vmov_n_p8(a); 4863 } 4864 4865 // CHECK: test_vmov_n_p16 4866 // CHECK: vmov 4867 poly16x4_t test_vmov_n_p16(poly16_t a) { 4868 return vmov_n_p16(a); 4869 } 4870 4871 // CHECK: test_vmov_n_f32 4872 // CHECK: vmov 4873 float32x2_t test_vmov_n_f32(float32_t a) { 4874 return vmov_n_f32(a); 4875 } 4876 4877 // CHECK: test_vmovq_n_u8 4878 // CHECK: vmov 4879 uint8x16_t test_vmovq_n_u8(uint8_t a) { 4880 return vmovq_n_u8(a); 4881 } 4882 4883 // CHECK: test_vmovq_n_u16 4884 // CHECK: vmov 4885 uint16x8_t test_vmovq_n_u16(uint16_t a) { 4886 return vmovq_n_u16(a); 4887 } 4888 4889 // CHECK: test_vmovq_n_u32 4890 // CHECK: vmov 4891 uint32x4_t test_vmovq_n_u32(uint32_t a) { 4892 return vmovq_n_u32(a); 4893 } 4894 4895 // CHECK: test_vmovq_n_s8 4896 // CHECK: vmov 4897 int8x16_t test_vmovq_n_s8(int8_t a) { 4898 return vmovq_n_s8(a); 4899 } 4900 4901 // CHECK: test_vmovq_n_s16 4902 // CHECK: vmov 4903 int16x8_t test_vmovq_n_s16(int16_t a) { 4904 return vmovq_n_s16(a); 4905 } 4906 4907 // CHECK: test_vmovq_n_s32 4908 // CHECK: vmov 4909 int32x4_t test_vmovq_n_s32(int32_t a) { 4910 return vmovq_n_s32(a); 4911 } 4912 4913 // CHECK: test_vmovq_n_p8 4914 // CHECK: vmov 4915 poly8x16_t test_vmovq_n_p8(poly8_t a) { 4916 return vmovq_n_p8(a); 4917 } 4918 4919 // CHECK: test_vmovq_n_p16 4920 // CHECK: vmov 4921 poly16x8_t test_vmovq_n_p16(poly16_t a) { 4922 return vmovq_n_p16(a); 4923 } 4924 4925 // CHECK: test_vmovq_n_f32 4926 // CHECK: vmov 4927 float32x4_t test_vmovq_n_f32(float32_t a) { 4928 return vmovq_n_f32(a); 4929 } 4930 4931 // CHECK: test_vmov_n_s64 4932 // CHECK: vmov 4933 int64x1_t test_vmov_n_s64(int64_t a) { 4934 return vmov_n_s64(a); 4935 } 4936 4937 // CHECK: test_vmov_n_u64 4938 // CHECK: vmov 4939 uint64x1_t test_vmov_n_u64(uint64_t a) { 4940 return vmov_n_u64(a); 4941 } 4942 4943 // CHECK: test_vmovq_n_s64 4944 // CHECK: vmov 4945 int64x2_t test_vmovq_n_s64(int64_t a) { 4946 return vmovq_n_s64(a); 4947 } 4948 4949 // CHECK: test_vmovq_n_u64 4950 // CHECK: vmov 4951 uint64x2_t test_vmovq_n_u64(uint64_t a) { 4952 return vmovq_n_u64(a); 4953 } 4954 4955 4956 // CHECK: test_vmul_s8 4957 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4958 int8x8_t test_vmul_s8(int8x8_t a, int8x8_t b) { 4959 return vmul_s8(a, b); 4960 } 4961 4962 // CHECK: test_vmul_s16 4963 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4964 int16x4_t test_vmul_s16(int16x4_t a, int16x4_t b) { 4965 return vmul_s16(a, b); 4966 } 4967 4968 // CHECK: test_vmul_s32 4969 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4970 int32x2_t test_vmul_s32(int32x2_t a, int32x2_t b) { 4971 return vmul_s32(a, b); 4972 } 4973 4974 // CHECK: test_vmul_f32 4975 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4976 float32x2_t test_vmul_f32(float32x2_t a, float32x2_t b) { 4977 return vmul_f32(a, b); 4978 } 4979 4980 // CHECK: test_vmul_u8 4981 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4982 uint8x8_t test_vmul_u8(uint8x8_t a, uint8x8_t b) { 4983 return vmul_u8(a, b); 4984 } 4985 4986 // CHECK: test_vmul_u16 4987 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4988 uint16x4_t test_vmul_u16(uint16x4_t a, uint16x4_t b) { 4989 return vmul_u16(a, b); 4990 } 4991 4992 // CHECK: test_vmul_u32 4993 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4994 uint32x2_t test_vmul_u32(uint32x2_t a, uint32x2_t b) { 4995 return vmul_u32(a, b); 4996 } 4997 4998 // CHECK: test_vmulq_s8 4999 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5000 int8x16_t test_vmulq_s8(int8x16_t a, int8x16_t b) { 5001 return vmulq_s8(a, b); 5002 } 5003 5004 // CHECK: test_vmulq_s16 5005 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5006 int16x8_t test_vmulq_s16(int16x8_t a, int16x8_t b) { 5007 return vmulq_s16(a, b); 5008 } 5009 5010 // CHECK: test_vmulq_s32 5011 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5012 int32x4_t test_vmulq_s32(int32x4_t a, int32x4_t b) { 5013 return vmulq_s32(a, b); 5014 } 5015 5016 // CHECK: test_vmulq_f32 5017 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5018 float32x4_t test_vmulq_f32(float32x4_t a, float32x4_t b) { 5019 return vmulq_f32(a, b); 5020 } 5021 5022 // CHECK: test_vmulq_u8 5023 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5024 uint8x16_t test_vmulq_u8(uint8x16_t a, uint8x16_t b) { 5025 return vmulq_u8(a, b); 5026 } 5027 5028 // CHECK: test_vmulq_u16 5029 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5030 uint16x8_t test_vmulq_u16(uint16x8_t a, uint16x8_t b) { 5031 return vmulq_u16(a, b); 5032 } 5033 5034 // CHECK: test_vmulq_u32 5035 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5036 uint32x4_t test_vmulq_u32(uint32x4_t a, uint32x4_t b) { 5037 return vmulq_u32(a, b); 5038 } 5039 5040 5041 // CHECK: test_vmull_s8 5042 // CHECK: vmull.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5043 int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) { 5044 return vmull_s8(a, b); 5045 } 5046 5047 // CHECK: test_vmull_s16 5048 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5049 int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) { 5050 return vmull_s16(a, b); 5051 } 5052 5053 // CHECK: test_vmull_s32 5054 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5055 int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) { 5056 return vmull_s32(a, b); 5057 } 5058 5059 // CHECK: test_vmull_u8 5060 // CHECK: vmull.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5061 uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) { 5062 return vmull_u8(a, b); 5063 } 5064 5065 // CHECK: test_vmull_u16 5066 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5067 uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) { 5068 return vmull_u16(a, b); 5069 } 5070 5071 // CHECK: test_vmull_u32 5072 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5073 uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) { 5074 return vmull_u32(a, b); 5075 } 5076 5077 // CHECK: test_vmull_p8 5078 // CHECK: vmull.p8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5079 poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) { 5080 return vmull_p8(a, b); 5081 } 5082 5083 5084 // CHECK: test_vmull_lane_s16 5085 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5086 int32x4_t test_vmull_lane_s16(int16x4_t a, int16x4_t b) { 5087 return vmull_lane_s16(a, b, 3); 5088 } 5089 5090 // CHECK: test_vmull_lane_s32 5091 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5092 int64x2_t test_vmull_lane_s32(int32x2_t a, int32x2_t b) { 5093 return vmull_lane_s32(a, b, 1); 5094 } 5095 5096 // CHECK: test_vmull_lane_u16 5097 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5098 uint32x4_t test_vmull_lane_u16(uint16x4_t a, uint16x4_t b) { 5099 return vmull_lane_u16(a, b, 3); 5100 } 5101 5102 // CHECK: test_vmull_lane_u32 5103 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5104 uint64x2_t test_vmull_lane_u32(uint32x2_t a, uint32x2_t b) { 5105 return vmull_lane_u32(a, b, 1); 5106 } 5107 5108 5109 // CHECK: test_vmull_n_s16 5110 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5111 int32x4_t test_vmull_n_s16(int16x4_t a, int16_t b) { 5112 return vmull_n_s16(a, b); 5113 } 5114 5115 // CHECK: test_vmull_n_s32 5116 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5117 int64x2_t test_vmull_n_s32(int32x2_t a, int32_t b) { 5118 return vmull_n_s32(a, b); 5119 } 5120 5121 // CHECK: test_vmull_n_u16 5122 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5123 uint32x4_t test_vmull_n_u16(uint16x4_t a, uint16_t b) { 5124 return vmull_n_u16(a, b); 5125 } 5126 5127 // CHECK: test_vmull_n_u32 5128 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5129 uint64x2_t test_vmull_n_u32(uint32x2_t a, uint32_t b) { 5130 return vmull_n_u32(a, b); 5131 } 5132 5133 5134 // CHECK: test_vmul_p8 5135 // CHECK: vmul.p8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5136 poly8x8_t test_vmul_p8(poly8x8_t a, poly8x8_t b) { 5137 return vmul_p8(a, b); 5138 } 5139 5140 // CHECK: test_vmulq_p8 5141 // CHECK: vmul.p8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5142 poly8x16_t test_vmulq_p8(poly8x16_t a, poly8x16_t b) { 5143 return vmulq_p8(a, b); 5144 } 5145 5146 5147 // CHECK: test_vmul_lane_s16 5148 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5149 int16x4_t test_vmul_lane_s16(int16x4_t a, int16x4_t b) { 5150 return vmul_lane_s16(a, b, 3); 5151 } 5152 5153 // CHECK: test_vmul_lane_s32 5154 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5155 int32x2_t test_vmul_lane_s32(int32x2_t a, int32x2_t b) { 5156 return vmul_lane_s32(a, b, 1); 5157 } 5158 5159 // CHECK: test_vmul_lane_f32 5160 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5161 float32x2_t test_vmul_lane_f32(float32x2_t a, float32x2_t b) { 5162 return vmul_lane_f32(a, b, 1); 5163 } 5164 5165 // CHECK: test_vmul_lane_u16 5166 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5167 uint16x4_t test_vmul_lane_u16(uint16x4_t a, uint16x4_t b) { 5168 return vmul_lane_u16(a, b, 3); 5169 } 5170 5171 // CHECK: test_vmul_lane_u32 5172 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5173 uint32x2_t test_vmul_lane_u32(uint32x2_t a, uint32x2_t b) { 5174 return vmul_lane_u32(a, b, 1); 5175 } 5176 5177 // CHECK: test_vmulq_lane_s16 5178 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5179 int16x8_t test_vmulq_lane_s16(int16x8_t a, int16x4_t b) { 5180 return vmulq_lane_s16(a, b, 3); 5181 } 5182 5183 // CHECK: test_vmulq_lane_s32 5184 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5185 int32x4_t test_vmulq_lane_s32(int32x4_t a, int32x2_t b) { 5186 return vmulq_lane_s32(a, b, 1); 5187 } 5188 5189 // CHECK: test_vmulq_lane_f32 5190 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5191 float32x4_t test_vmulq_lane_f32(float32x4_t a, float32x2_t b) { 5192 return vmulq_lane_f32(a, b, 1); 5193 } 5194 5195 // CHECK: test_vmulq_lane_u16 5196 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5197 uint16x8_t test_vmulq_lane_u16(uint16x8_t a, uint16x4_t b) { 5198 return vmulq_lane_u16(a, b, 3); 5199 } 5200 5201 // CHECK: test_vmulq_lane_u32 5202 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5203 uint32x4_t test_vmulq_lane_u32(uint32x4_t a, uint32x2_t b) { 5204 return vmulq_lane_u32(a, b, 1); 5205 } 5206 5207 5208 // CHECK: test_vmul_n_s16 5209 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5210 int16x4_t test_vmul_n_s16(int16x4_t a, int16_t b) { 5211 return vmul_n_s16(a, b); 5212 } 5213 5214 // CHECK: test_vmul_n_s32 5215 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5216 int32x2_t test_vmul_n_s32(int32x2_t a, int32_t b) { 5217 return vmul_n_s32(a, b); 5218 } 5219 5220 // CHECK: test_vmul_n_f32 5221 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5222 float32x2_t test_vmul_n_f32(float32x2_t a, float32_t b) { 5223 return vmul_n_f32(a, b); 5224 } 5225 5226 // CHECK: test_vmul_n_u16 5227 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5228 uint16x4_t test_vmul_n_u16(uint16x4_t a, uint16_t b) { 5229 return vmul_n_u16(a, b); 5230 } 5231 5232 // CHECK: test_vmul_n_u32 5233 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5234 uint32x2_t test_vmul_n_u32(uint32x2_t a, uint32_t b) { 5235 return vmul_n_u32(a, b); 5236 } 5237 5238 // CHECK: test_vmulq_n_s16 5239 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5240 int16x8_t test_vmulq_n_s16(int16x8_t a, int16_t b) { 5241 return vmulq_n_s16(a, b); 5242 } 5243 5244 // CHECK: test_vmulq_n_s32 5245 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5246 int32x4_t test_vmulq_n_s32(int32x4_t a, int32_t b) { 5247 return vmulq_n_s32(a, b); 5248 } 5249 5250 // CHECK: test_vmulq_n_f32 5251 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5252 float32x4_t test_vmulq_n_f32(float32x4_t a, float32_t b) { 5253 return vmulq_n_f32(a, b); 5254 } 5255 5256 // CHECK: test_vmulq_n_u16 5257 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5258 uint16x8_t test_vmulq_n_u16(uint16x8_t a, uint16_t b) { 5259 return vmulq_n_u16(a, b); 5260 } 5261 5262 // CHECK: test_vmulq_n_u32 5263 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5264 uint32x4_t test_vmulq_n_u32(uint32x4_t a, uint32_t b) { 5265 return vmulq_n_u32(a, b); 5266 } 5267 5268 5269 // CHECK: test_vmvn_s8 5270 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5271 int8x8_t test_vmvn_s8(int8x8_t a) { 5272 return vmvn_s8(a); 5273 } 5274 5275 // CHECK: test_vmvn_s16 5276 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5277 int16x4_t test_vmvn_s16(int16x4_t a) { 5278 return vmvn_s16(a); 5279 } 5280 5281 // CHECK: test_vmvn_s32 5282 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5283 int32x2_t test_vmvn_s32(int32x2_t a) { 5284 return vmvn_s32(a); 5285 } 5286 5287 // CHECK: test_vmvn_u8 5288 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5289 uint8x8_t test_vmvn_u8(uint8x8_t a) { 5290 return vmvn_u8(a); 5291 } 5292 5293 // CHECK: test_vmvn_u16 5294 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5295 uint16x4_t test_vmvn_u16(uint16x4_t a) { 5296 return vmvn_u16(a); 5297 } 5298 5299 // CHECK: test_vmvn_u32 5300 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5301 uint32x2_t test_vmvn_u32(uint32x2_t a) { 5302 return vmvn_u32(a); 5303 } 5304 5305 // CHECK: test_vmvn_p8 5306 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5307 poly8x8_t test_vmvn_p8(poly8x8_t a) { 5308 return vmvn_p8(a); 5309 } 5310 5311 // CHECK: test_vmvnq_s8 5312 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5313 int8x16_t test_vmvnq_s8(int8x16_t a) { 5314 return vmvnq_s8(a); 5315 } 5316 5317 // CHECK: test_vmvnq_s16 5318 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5319 int16x8_t test_vmvnq_s16(int16x8_t a) { 5320 return vmvnq_s16(a); 5321 } 5322 5323 // CHECK: test_vmvnq_s32 5324 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5325 int32x4_t test_vmvnq_s32(int32x4_t a) { 5326 return vmvnq_s32(a); 5327 } 5328 5329 // CHECK: test_vmvnq_u8 5330 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5331 uint8x16_t test_vmvnq_u8(uint8x16_t a) { 5332 return vmvnq_u8(a); 5333 } 5334 5335 // CHECK: test_vmvnq_u16 5336 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5337 uint16x8_t test_vmvnq_u16(uint16x8_t a) { 5338 return vmvnq_u16(a); 5339 } 5340 5341 // CHECK: test_vmvnq_u32 5342 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5343 uint32x4_t test_vmvnq_u32(uint32x4_t a) { 5344 return vmvnq_u32(a); 5345 } 5346 5347 // CHECK: test_vmvnq_p8 5348 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5349 poly8x16_t test_vmvnq_p8(poly8x16_t a) { 5350 return vmvnq_p8(a); 5351 } 5352 5353 5354 // CHECK: test_vneg_s8 5355 // CHECK: vneg.s8 d{{[0-9]+}}, d{{[0-9]+}} 5356 int8x8_t test_vneg_s8(int8x8_t a) { 5357 return vneg_s8(a); 5358 } 5359 5360 // CHECK: test_vneg_s16 5361 // CHECK: vneg.s16 d{{[0-9]+}}, d{{[0-9]+}} 5362 int16x4_t test_vneg_s16(int16x4_t a) { 5363 return vneg_s16(a); 5364 } 5365 5366 // CHECK: test_vneg_s32 5367 // CHECK: vneg.s32 d{{[0-9]+}}, d{{[0-9]+}} 5368 int32x2_t test_vneg_s32(int32x2_t a) { 5369 return vneg_s32(a); 5370 } 5371 5372 // CHECK: test_vneg_f32 5373 // CHECK: vneg.f32 d{{[0-9]+}}, d{{[0-9]+}} 5374 float32x2_t test_vneg_f32(float32x2_t a) { 5375 return vneg_f32(a); 5376 } 5377 5378 // CHECK: test_vnegq_s8 5379 // CHECK: vneg.s8 q{{[0-9]+}}, q{{[0-9]+}} 5380 int8x16_t test_vnegq_s8(int8x16_t a) { 5381 return vnegq_s8(a); 5382 } 5383 5384 // CHECK: test_vnegq_s16 5385 // CHECK: vneg.s16 q{{[0-9]+}}, q{{[0-9]+}} 5386 int16x8_t test_vnegq_s16(int16x8_t a) { 5387 return vnegq_s16(a); 5388 } 5389 5390 // CHECK: test_vnegq_s32 5391 // CHECK: vneg.s32 q{{[0-9]+}}, q{{[0-9]+}} 5392 int32x4_t test_vnegq_s32(int32x4_t a) { 5393 return vnegq_s32(a); 5394 } 5395 5396 // CHECK: test_vnegq_f32 5397 // CHECK: vneg.f32 q{{[0-9]+}}, q{{[0-9]+}} 5398 float32x4_t test_vnegq_f32(float32x4_t a) { 5399 return vnegq_f32(a); 5400 } 5401 5402 5403 // CHECK: test_vorn_s8 5404 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5405 int8x8_t test_vorn_s8(int8x8_t a, int8x8_t b) { 5406 return vorn_s8(a, b); 5407 } 5408 5409 // CHECK: test_vorn_s16 5410 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5411 int16x4_t test_vorn_s16(int16x4_t a, int16x4_t b) { 5412 return vorn_s16(a, b); 5413 } 5414 5415 // CHECK: test_vorn_s32 5416 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5417 int32x2_t test_vorn_s32(int32x2_t a, int32x2_t b) { 5418 return vorn_s32(a, b); 5419 } 5420 5421 // CHECK: test_vorn_s64 5422 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5423 int64x1_t test_vorn_s64(int64x1_t a, int64x1_t b) { 5424 return vorn_s64(a, b); 5425 } 5426 5427 // CHECK: test_vorn_u8 5428 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5429 uint8x8_t test_vorn_u8(uint8x8_t a, uint8x8_t b) { 5430 return vorn_u8(a, b); 5431 } 5432 5433 // CHECK: test_vorn_u16 5434 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5435 uint16x4_t test_vorn_u16(uint16x4_t a, uint16x4_t b) { 5436 return vorn_u16(a, b); 5437 } 5438 5439 // CHECK: test_vorn_u32 5440 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5441 uint32x2_t test_vorn_u32(uint32x2_t a, uint32x2_t b) { 5442 return vorn_u32(a, b); 5443 } 5444 5445 // CHECK: test_vorn_u64 5446 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5447 uint64x1_t test_vorn_u64(uint64x1_t a, uint64x1_t b) { 5448 return vorn_u64(a, b); 5449 } 5450 5451 // CHECK: test_vornq_s8 5452 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5453 int8x16_t test_vornq_s8(int8x16_t a, int8x16_t b) { 5454 return vornq_s8(a, b); 5455 } 5456 5457 // CHECK: test_vornq_s16 5458 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5459 int16x8_t test_vornq_s16(int16x8_t a, int16x8_t b) { 5460 return vornq_s16(a, b); 5461 } 5462 5463 // CHECK: test_vornq_s32 5464 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5465 int32x4_t test_vornq_s32(int32x4_t a, int32x4_t b) { 5466 return vornq_s32(a, b); 5467 } 5468 5469 // CHECK: test_vornq_s64 5470 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5471 int64x2_t test_vornq_s64(int64x2_t a, int64x2_t b) { 5472 return vornq_s64(a, b); 5473 } 5474 5475 // CHECK: test_vornq_u8 5476 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5477 uint8x16_t test_vornq_u8(uint8x16_t a, uint8x16_t b) { 5478 return vornq_u8(a, b); 5479 } 5480 5481 // CHECK: test_vornq_u16 5482 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5483 uint16x8_t test_vornq_u16(uint16x8_t a, uint16x8_t b) { 5484 return vornq_u16(a, b); 5485 } 5486 5487 // CHECK: test_vornq_u32 5488 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5489 uint32x4_t test_vornq_u32(uint32x4_t a, uint32x4_t b) { 5490 return vornq_u32(a, b); 5491 } 5492 5493 // CHECK: test_vornq_u64 5494 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5495 uint64x2_t test_vornq_u64(uint64x2_t a, uint64x2_t b) { 5496 return vornq_u64(a, b); 5497 } 5498 5499 5500 // CHECK: test_vorr_s8 5501 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5502 int8x8_t test_vorr_s8(int8x8_t a, int8x8_t b) { 5503 return vorr_s8(a, b); 5504 } 5505 5506 // CHECK: test_vorr_s16 5507 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5508 int16x4_t test_vorr_s16(int16x4_t a, int16x4_t b) { 5509 return vorr_s16(a, b); 5510 } 5511 5512 // CHECK: test_vorr_s32 5513 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5514 int32x2_t test_vorr_s32(int32x2_t a, int32x2_t b) { 5515 return vorr_s32(a, b); 5516 } 5517 5518 // CHECK: test_vorr_s64 5519 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5520 int64x1_t test_vorr_s64(int64x1_t a, int64x1_t b) { 5521 return vorr_s64(a, b); 5522 } 5523 5524 // CHECK: test_vorr_u8 5525 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5526 uint8x8_t test_vorr_u8(uint8x8_t a, uint8x8_t b) { 5527 return vorr_u8(a, b); 5528 } 5529 5530 // CHECK: test_vorr_u16 5531 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5532 uint16x4_t test_vorr_u16(uint16x4_t a, uint16x4_t b) { 5533 return vorr_u16(a, b); 5534 } 5535 5536 // CHECK: test_vorr_u32 5537 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5538 uint32x2_t test_vorr_u32(uint32x2_t a, uint32x2_t b) { 5539 return vorr_u32(a, b); 5540 } 5541 5542 // CHECK: test_vorr_u64 5543 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5544 uint64x1_t test_vorr_u64(uint64x1_t a, uint64x1_t b) { 5545 return vorr_u64(a, b); 5546 } 5547 5548 // CHECK: test_vorrq_s8 5549 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5550 int8x16_t test_vorrq_s8(int8x16_t a, int8x16_t b) { 5551 return vorrq_s8(a, b); 5552 } 5553 5554 // CHECK: test_vorrq_s16 5555 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5556 int16x8_t test_vorrq_s16(int16x8_t a, int16x8_t b) { 5557 return vorrq_s16(a, b); 5558 } 5559 5560 // CHECK: test_vorrq_s32 5561 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5562 int32x4_t test_vorrq_s32(int32x4_t a, int32x4_t b) { 5563 return vorrq_s32(a, b); 5564 } 5565 5566 // CHECK: test_vorrq_s64 5567 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5568 int64x2_t test_vorrq_s64(int64x2_t a, int64x2_t b) { 5569 return vorrq_s64(a, b); 5570 } 5571 5572 // CHECK: test_vorrq_u8 5573 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5574 uint8x16_t test_vorrq_u8(uint8x16_t a, uint8x16_t b) { 5575 return vorrq_u8(a, b); 5576 } 5577 5578 // CHECK: test_vorrq_u16 5579 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5580 uint16x8_t test_vorrq_u16(uint16x8_t a, uint16x8_t b) { 5581 return vorrq_u16(a, b); 5582 } 5583 5584 // CHECK: test_vorrq_u32 5585 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5586 uint32x4_t test_vorrq_u32(uint32x4_t a, uint32x4_t b) { 5587 return vorrq_u32(a, b); 5588 } 5589 5590 // CHECK: test_vorrq_u64 5591 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5592 uint64x2_t test_vorrq_u64(uint64x2_t a, uint64x2_t b) { 5593 return vorrq_u64(a, b); 5594 } 5595 5596 5597 // CHECK: test_vpadal_s8 5598 // CHECK: vpadal.s8 d{{[0-9]+}}, d{{[0-9]+}} 5599 int16x4_t test_vpadal_s8(int16x4_t a, int8x8_t b) { 5600 return vpadal_s8(a, b); 5601 } 5602 5603 // CHECK: test_vpadal_s16 5604 // CHECK: vpadal.s16 d{{[0-9]+}}, d{{[0-9]+}} 5605 int32x2_t test_vpadal_s16(int32x2_t a, int16x4_t b) { 5606 return vpadal_s16(a, b); 5607 } 5608 5609 // CHECK: test_vpadal_s32 5610 // CHECK: vpadal.s32 d{{[0-9]+}}, d{{[0-9]+}} 5611 int64x1_t test_vpadal_s32(int64x1_t a, int32x2_t b) { 5612 return vpadal_s32(a, b); 5613 } 5614 5615 // CHECK: test_vpadal_u8 5616 // CHECK: vpadal.u8 d{{[0-9]+}}, d{{[0-9]+}} 5617 uint16x4_t test_vpadal_u8(uint16x4_t a, uint8x8_t b) { 5618 return vpadal_u8(a, b); 5619 } 5620 5621 // CHECK: test_vpadal_u16 5622 // CHECK: vpadal.u16 d{{[0-9]+}}, d{{[0-9]+}} 5623 uint32x2_t test_vpadal_u16(uint32x2_t a, uint16x4_t b) { 5624 return vpadal_u16(a, b); 5625 } 5626 5627 // CHECK: test_vpadal_u32 5628 // CHECK: vpadal.u32 d{{[0-9]+}}, d{{[0-9]+}} 5629 uint64x1_t test_vpadal_u32(uint64x1_t a, uint32x2_t b) { 5630 return vpadal_u32(a, b); 5631 } 5632 5633 // CHECK: test_vpadalq_s8 5634 // CHECK: vpadal.s8 q{{[0-9]+}}, q{{[0-9]+}} 5635 int16x8_t test_vpadalq_s8(int16x8_t a, int8x16_t b) { 5636 return vpadalq_s8(a, b); 5637 } 5638 5639 // CHECK: test_vpadalq_s16 5640 // CHECK: vpadal.s16 q{{[0-9]+}}, q{{[0-9]+}} 5641 int32x4_t test_vpadalq_s16(int32x4_t a, int16x8_t b) { 5642 return vpadalq_s16(a, b); 5643 } 5644 5645 // CHECK: test_vpadalq_s32 5646 // CHECK: vpadal.s32 q{{[0-9]+}}, q{{[0-9]+}} 5647 int64x2_t test_vpadalq_s32(int64x2_t a, int32x4_t b) { 5648 return vpadalq_s32(a, b); 5649 } 5650 5651 // CHECK: test_vpadalq_u8 5652 // CHECK: vpadal.u8 q{{[0-9]+}}, q{{[0-9]+}} 5653 uint16x8_t test_vpadalq_u8(uint16x8_t a, uint8x16_t b) { 5654 return vpadalq_u8(a, b); 5655 } 5656 5657 // CHECK: test_vpadalq_u16 5658 // CHECK: vpadal.u16 q{{[0-9]+}}, q{{[0-9]+}} 5659 uint32x4_t test_vpadalq_u16(uint32x4_t a, uint16x8_t b) { 5660 return vpadalq_u16(a, b); 5661 } 5662 5663 // CHECK: test_vpadalq_u32 5664 // CHECK: vpadal.u32 q{{[0-9]+}}, q{{[0-9]+}} 5665 uint64x2_t test_vpadalq_u32(uint64x2_t a, uint32x4_t b) { 5666 return vpadalq_u32(a, b); 5667 } 5668 5669 5670 // CHECK: test_vpadd_s8 5671 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5672 int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) { 5673 return vpadd_s8(a, b); 5674 } 5675 5676 // CHECK: test_vpadd_s16 5677 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5678 int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) { 5679 return vpadd_s16(a, b); 5680 } 5681 5682 // CHECK: test_vpadd_s32 5683 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5684 int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) { 5685 return vpadd_s32(a, b); 5686 } 5687 5688 // CHECK: test_vpadd_u8 5689 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5690 uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) { 5691 return vpadd_u8(a, b); 5692 } 5693 5694 // CHECK: test_vpadd_u16 5695 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5696 uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) { 5697 return vpadd_u16(a, b); 5698 } 5699 5700 // CHECK: test_vpadd_u32 5701 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5702 uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) { 5703 return vpadd_u32(a, b); 5704 } 5705 5706 // CHECK: test_vpadd_f32 5707 // CHECK: vpadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5708 float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) { 5709 return vpadd_f32(a, b); 5710 } 5711 5712 5713 // CHECK: test_vpaddl_s8 5714 // CHECK: vpaddl.s8 d{{[0-9]+}}, d{{[0-9]+}} 5715 int16x4_t test_vpaddl_s8(int8x8_t a) { 5716 return vpaddl_s8(a); 5717 } 5718 5719 // CHECK: test_vpaddl_s16 5720 // CHECK: vpaddl.s16 d{{[0-9]+}}, d{{[0-9]+}} 5721 int32x2_t test_vpaddl_s16(int16x4_t a) { 5722 return vpaddl_s16(a); 5723 } 5724 5725 // CHECK: test_vpaddl_s32 5726 // CHECK: vpaddl.s32 d{{[0-9]+}}, d{{[0-9]+}} 5727 int64x1_t test_vpaddl_s32(int32x2_t a) { 5728 return vpaddl_s32(a); 5729 } 5730 5731 // CHECK: test_vpaddl_u8 5732 // CHECK: vpaddl.u8 d{{[0-9]+}}, d{{[0-9]+}} 5733 uint16x4_t test_vpaddl_u8(uint8x8_t a) { 5734 return vpaddl_u8(a); 5735 } 5736 5737 // CHECK: test_vpaddl_u16 5738 // CHECK: vpaddl.u16 d{{[0-9]+}}, d{{[0-9]+}} 5739 uint32x2_t test_vpaddl_u16(uint16x4_t a) { 5740 return vpaddl_u16(a); 5741 } 5742 5743 // CHECK: test_vpaddl_u32 5744 // CHECK: vpaddl.u32 d{{[0-9]+}}, d{{[0-9]+}} 5745 uint64x1_t test_vpaddl_u32(uint32x2_t a) { 5746 return vpaddl_u32(a); 5747 } 5748 5749 // CHECK: test_vpaddlq_s8 5750 // CHECK: vpaddl.s8 q{{[0-9]+}}, q{{[0-9]+}} 5751 int16x8_t test_vpaddlq_s8(int8x16_t a) { 5752 return vpaddlq_s8(a); 5753 } 5754 5755 // CHECK: test_vpaddlq_s16 5756 // CHECK: vpaddl.s16 q{{[0-9]+}}, q{{[0-9]+}} 5757 int32x4_t test_vpaddlq_s16(int16x8_t a) { 5758 return vpaddlq_s16(a); 5759 } 5760 5761 // CHECK: test_vpaddlq_s32 5762 // CHECK: vpaddl.s32 q{{[0-9]+}}, q{{[0-9]+}} 5763 int64x2_t test_vpaddlq_s32(int32x4_t a) { 5764 return vpaddlq_s32(a); 5765 } 5766 5767 // CHECK: test_vpaddlq_u8 5768 // CHECK: vpaddl.u8 q{{[0-9]+}}, q{{[0-9]+}} 5769 uint16x8_t test_vpaddlq_u8(uint8x16_t a) { 5770 return vpaddlq_u8(a); 5771 } 5772 5773 // CHECK: test_vpaddlq_u16 5774 // CHECK: vpaddl.u16 q{{[0-9]+}}, q{{[0-9]+}} 5775 uint32x4_t test_vpaddlq_u16(uint16x8_t a) { 5776 return vpaddlq_u16(a); 5777 } 5778 5779 // CHECK: test_vpaddlq_u32 5780 // CHECK: vpaddl.u32 q{{[0-9]+}}, q{{[0-9]+}} 5781 uint64x2_t test_vpaddlq_u32(uint32x4_t a) { 5782 return vpaddlq_u32(a); 5783 } 5784 5785 5786 // CHECK: test_vpmax_s8 5787 // CHECK: vpmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5788 int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) { 5789 return vpmax_s8(a, b); 5790 } 5791 5792 // CHECK: test_vpmax_s16 5793 // CHECK: vpmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5794 int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) { 5795 return vpmax_s16(a, b); 5796 } 5797 5798 // CHECK: test_vpmax_s32 5799 // CHECK: vpmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5800 int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) { 5801 return vpmax_s32(a, b); 5802 } 5803 5804 // CHECK: test_vpmax_u8 5805 // CHECK: vpmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5806 uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) { 5807 return vpmax_u8(a, b); 5808 } 5809 5810 // CHECK: test_vpmax_u16 5811 // CHECK: vpmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5812 uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) { 5813 return vpmax_u16(a, b); 5814 } 5815 5816 // CHECK: test_vpmax_u32 5817 // CHECK: vpmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5818 uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) { 5819 return vpmax_u32(a, b); 5820 } 5821 5822 // CHECK: test_vpmax_f32 5823 // CHECK: vpmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5824 float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) { 5825 return vpmax_f32(a, b); 5826 } 5827 5828 5829 // CHECK: test_vpmin_s8 5830 // CHECK: vpmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5831 int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) { 5832 return vpmin_s8(a, b); 5833 } 5834 5835 // CHECK: test_vpmin_s16 5836 // CHECK: vpmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5837 int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) { 5838 return vpmin_s16(a, b); 5839 } 5840 5841 // CHECK: test_vpmin_s32 5842 // CHECK: vpmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5843 int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) { 5844 return vpmin_s32(a, b); 5845 } 5846 5847 // CHECK: test_vpmin_u8 5848 // CHECK: vpmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5849 uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) { 5850 return vpmin_u8(a, b); 5851 } 5852 5853 // CHECK: test_vpmin_u16 5854 // CHECK: vpmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5855 uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) { 5856 return vpmin_u16(a, b); 5857 } 5858 5859 // CHECK: test_vpmin_u32 5860 // CHECK: vpmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5861 uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) { 5862 return vpmin_u32(a, b); 5863 } 5864 5865 // CHECK: test_vpmin_f32 5866 // CHECK: vpmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5867 float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) { 5868 return vpmin_f32(a, b); 5869 } 5870 5871 5872 // CHECK: test_vqabs_s8 5873 // CHECK: vqabs.s8 d{{[0-9]+}}, d{{[0-9]+}} 5874 int8x8_t test_vqabs_s8(int8x8_t a) { 5875 return vqabs_s8(a); 5876 } 5877 5878 // CHECK: test_vqabs_s16 5879 // CHECK: vqabs.s16 d{{[0-9]+}}, d{{[0-9]+}} 5880 int16x4_t test_vqabs_s16(int16x4_t a) { 5881 return vqabs_s16(a); 5882 } 5883 5884 // CHECK: test_vqabs_s32 5885 // CHECK: vqabs.s32 d{{[0-9]+}}, d{{[0-9]+}} 5886 int32x2_t test_vqabs_s32(int32x2_t a) { 5887 return vqabs_s32(a); 5888 } 5889 5890 // CHECK: test_vqabsq_s8 5891 // CHECK: vqabs.s8 q{{[0-9]+}}, q{{[0-9]+}} 5892 int8x16_t test_vqabsq_s8(int8x16_t a) { 5893 return vqabsq_s8(a); 5894 } 5895 5896 // CHECK: test_vqabsq_s16 5897 // CHECK: vqabs.s16 q{{[0-9]+}}, q{{[0-9]+}} 5898 int16x8_t test_vqabsq_s16(int16x8_t a) { 5899 return vqabsq_s16(a); 5900 } 5901 5902 // CHECK: test_vqabsq_s32 5903 // CHECK: vqabs.s32 q{{[0-9]+}}, q{{[0-9]+}} 5904 int32x4_t test_vqabsq_s32(int32x4_t a) { 5905 return vqabsq_s32(a); 5906 } 5907 5908 5909 // CHECK: test_vqadd_s8 5910 // CHECK: vqadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5911 int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) { 5912 return vqadd_s8(a, b); 5913 } 5914 5915 // CHECK: test_vqadd_s16 5916 // CHECK: vqadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5917 int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) { 5918 return vqadd_s16(a, b); 5919 } 5920 5921 // CHECK: test_vqadd_s32 5922 // CHECK: vqadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5923 int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) { 5924 return vqadd_s32(a, b); 5925 } 5926 5927 // CHECK: test_vqadd_s64 5928 // CHECK: vqadd.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5929 int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) { 5930 return vqadd_s64(a, b); 5931 } 5932 5933 // CHECK: test_vqadd_u8 5934 // CHECK: vqadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5935 uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) { 5936 return vqadd_u8(a, b); 5937 } 5938 5939 // CHECK: test_vqadd_u16 5940 // CHECK: vqadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5941 uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) { 5942 return vqadd_u16(a, b); 5943 } 5944 5945 // CHECK: test_vqadd_u32 5946 // CHECK: vqadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5947 uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) { 5948 return vqadd_u32(a, b); 5949 } 5950 5951 // CHECK: test_vqadd_u64 5952 // CHECK: vqadd.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5953 uint64x1_t test_vqadd_u64(uint64x1_t a, uint64x1_t b) { 5954 return vqadd_u64(a, b); 5955 } 5956 5957 // CHECK: test_vqaddq_s8 5958 // CHECK: vqadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5959 int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) { 5960 return vqaddq_s8(a, b); 5961 } 5962 5963 // CHECK: test_vqaddq_s16 5964 // CHECK: vqadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5965 int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) { 5966 return vqaddq_s16(a, b); 5967 } 5968 5969 // CHECK: test_vqaddq_s32 5970 // CHECK: vqadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5971 int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) { 5972 return vqaddq_s32(a, b); 5973 } 5974 5975 // CHECK: test_vqaddq_s64 5976 // CHECK: vqadd.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5977 int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) { 5978 return vqaddq_s64(a, b); 5979 } 5980 5981 // CHECK: test_vqaddq_u8 5982 // CHECK: vqadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5983 uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) { 5984 return vqaddq_u8(a, b); 5985 } 5986 5987 // CHECK: test_vqaddq_u16 5988 // CHECK: vqadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5989 uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) { 5990 return vqaddq_u16(a, b); 5991 } 5992 5993 // CHECK: test_vqaddq_u32 5994 // CHECK: vqadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5995 uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) { 5996 return vqaddq_u32(a, b); 5997 } 5998 5999 // CHECK: test_vqaddq_u64 6000 // CHECK: vqadd.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6001 uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) { 6002 return vqaddq_u64(a, b); 6003 } 6004 6005 6006 // CHECK: test_vqdmlal_s16 6007 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6008 int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6009 return vqdmlal_s16(a, b, c); 6010 } 6011 6012 // CHECK: test_vqdmlal_s32 6013 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6014 int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6015 return vqdmlal_s32(a, b, c); 6016 } 6017 6018 6019 // CHECK: test_vqdmlal_lane_s16 6020 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6021 int32x4_t test_vqdmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6022 return vqdmlal_lane_s16(a, b, c, 3); 6023 } 6024 6025 // CHECK: test_vqdmlal_lane_s32 6026 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6027 int64x2_t test_vqdmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6028 return vqdmlal_lane_s32(a, b, c, 1); 6029 } 6030 6031 6032 // CHECK: test_vqdmlal_n_s16 6033 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6034 int32x4_t test_vqdmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 6035 return vqdmlal_n_s16(a, b, c); 6036 } 6037 6038 // CHECK: test_vqdmlal_n_s32 6039 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6040 int64x2_t test_vqdmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 6041 return vqdmlal_n_s32(a, b, c); 6042 } 6043 6044 6045 // CHECK: test_vqdmlsl_s16 6046 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6047 int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6048 return vqdmlsl_s16(a, b, c); 6049 } 6050 6051 // CHECK: test_vqdmlsl_s32 6052 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6053 int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6054 return vqdmlsl_s32(a, b, c); 6055 } 6056 6057 6058 // CHECK: test_vqdmlsl_lane_s16 6059 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6060 int32x4_t test_vqdmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6061 return vqdmlsl_lane_s16(a, b, c, 3); 6062 } 6063 6064 // CHECK: test_vqdmlsl_lane_s32 6065 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6066 int64x2_t test_vqdmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6067 return vqdmlsl_lane_s32(a, b, c, 1); 6068 } 6069 6070 6071 // CHECK: test_vqdmlsl_n_s16 6072 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6073 int32x4_t test_vqdmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 6074 return vqdmlsl_n_s16(a, b, c); 6075 } 6076 6077 // CHECK: test_vqdmlsl_n_s32 6078 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6079 int64x2_t test_vqdmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 6080 return vqdmlsl_n_s32(a, b, c); 6081 } 6082 6083 6084 // CHECK: test_vqdmulh_s16 6085 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6086 int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) { 6087 return vqdmulh_s16(a, b); 6088 } 6089 6090 // CHECK: test_vqdmulh_s32 6091 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6092 int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) { 6093 return vqdmulh_s32(a, b); 6094 } 6095 6096 // CHECK: test_vqdmulhq_s16 6097 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6098 int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) { 6099 return vqdmulhq_s16(a, b); 6100 } 6101 6102 // CHECK: test_vqdmulhq_s32 6103 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6104 int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) { 6105 return vqdmulhq_s32(a, b); 6106 } 6107 6108 6109 // CHECK: test_vqdmulh_lane_s16 6110 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6111 int16x4_t test_vqdmulh_lane_s16(int16x4_t a, int16x4_t b) { 6112 return vqdmulh_lane_s16(a, b, 3); 6113 } 6114 6115 // CHECK: test_vqdmulh_lane_s32 6116 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6117 int32x2_t test_vqdmulh_lane_s32(int32x2_t a, int32x2_t b) { 6118 return vqdmulh_lane_s32(a, b, 1); 6119 } 6120 6121 // CHECK: test_vqdmulhq_lane_s16 6122 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6123 int16x8_t test_vqdmulhq_lane_s16(int16x8_t a, int16x4_t b) { 6124 return vqdmulhq_lane_s16(a, b, 3); 6125 } 6126 6127 // CHECK: test_vqdmulhq_lane_s32 6128 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6129 int32x4_t test_vqdmulhq_lane_s32(int32x4_t a, int32x2_t b) { 6130 return vqdmulhq_lane_s32(a, b, 1); 6131 } 6132 6133 6134 // CHECK: test_vqdmulh_n_s16 6135 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6136 int16x4_t test_vqdmulh_n_s16(int16x4_t a, int16_t b) { 6137 return vqdmulh_n_s16(a, b); 6138 } 6139 6140 // CHECK: test_vqdmulh_n_s32 6141 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6142 int32x2_t test_vqdmulh_n_s32(int32x2_t a, int32_t b) { 6143 return vqdmulh_n_s32(a, b); 6144 } 6145 6146 // CHECK: test_vqdmulhq_n_s16 6147 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6148 int16x8_t test_vqdmulhq_n_s16(int16x8_t a, int16_t b) { 6149 return vqdmulhq_n_s16(a, b); 6150 } 6151 6152 // CHECK: test_vqdmulhq_n_s32 6153 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6154 int32x4_t test_vqdmulhq_n_s32(int32x4_t a, int32_t b) { 6155 return vqdmulhq_n_s32(a, b); 6156 } 6157 6158 6159 // CHECK: test_vqdmull_s16 6160 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6161 int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) { 6162 return vqdmull_s16(a, b); 6163 } 6164 6165 // CHECK: test_vqdmull_s32 6166 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6167 int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) { 6168 return vqdmull_s32(a, b); 6169 } 6170 6171 6172 // CHECK: test_vqdmull_lane_s16 6173 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6174 int32x4_t test_vqdmull_lane_s16(int16x4_t a, int16x4_t b) { 6175 return vqdmull_lane_s16(a, b, 3); 6176 } 6177 6178 // CHECK: test_vqdmull_lane_s32 6179 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6180 int64x2_t test_vqdmull_lane_s32(int32x2_t a, int32x2_t b) { 6181 return vqdmull_lane_s32(a, b, 1); 6182 } 6183 6184 6185 // CHECK: test_vqdmull_n_s16 6186 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6187 int32x4_t test_vqdmull_n_s16(int16x4_t a, int16_t b) { 6188 return vqdmull_n_s16(a, b); 6189 } 6190 6191 // CHECK: test_vqdmull_n_s32 6192 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6193 int64x2_t test_vqdmull_n_s32(int32x2_t a, int32_t b) { 6194 return vqdmull_n_s32(a, b); 6195 } 6196 6197 6198 // CHECK: test_vqmovn_s16 6199 // CHECK: vqmovn.s16 d{{[0-9]+}}, q{{[0-9]+}} 6200 int8x8_t test_vqmovn_s16(int16x8_t a) { 6201 return vqmovn_s16(a); 6202 } 6203 6204 // CHECK: test_vqmovn_s32 6205 // CHECK: vqmovn.s32 d{{[0-9]+}}, q{{[0-9]+}} 6206 int16x4_t test_vqmovn_s32(int32x4_t a) { 6207 return vqmovn_s32(a); 6208 } 6209 6210 // CHECK: test_vqmovn_s64 6211 // CHECK: vqmovn.s64 d{{[0-9]+}}, q{{[0-9]+}} 6212 int32x2_t test_vqmovn_s64(int64x2_t a) { 6213 return vqmovn_s64(a); 6214 } 6215 6216 // CHECK: test_vqmovn_u16 6217 // CHECK: vqmovn.u16 d{{[0-9]+}}, q{{[0-9]+}} 6218 uint8x8_t test_vqmovn_u16(uint16x8_t a) { 6219 return vqmovn_u16(a); 6220 } 6221 6222 // CHECK: test_vqmovn_u32 6223 // CHECK: vqmovn.u32 d{{[0-9]+}}, q{{[0-9]+}} 6224 uint16x4_t test_vqmovn_u32(uint32x4_t a) { 6225 return vqmovn_u32(a); 6226 } 6227 6228 // CHECK: test_vqmovn_u64 6229 // CHECK: vqmovn.u64 d{{[0-9]+}}, q{{[0-9]+}} 6230 uint32x2_t test_vqmovn_u64(uint64x2_t a) { 6231 return vqmovn_u64(a); 6232 } 6233 6234 6235 // CHECK: test_vqmovun_s16 6236 // CHECK: vqmovun.s16 d{{[0-9]+}}, q{{[0-9]+}} 6237 uint8x8_t test_vqmovun_s16(int16x8_t a) { 6238 return vqmovun_s16(a); 6239 } 6240 6241 // CHECK: test_vqmovun_s32 6242 // CHECK: vqmovun.s32 d{{[0-9]+}}, q{{[0-9]+}} 6243 uint16x4_t test_vqmovun_s32(int32x4_t a) { 6244 return vqmovun_s32(a); 6245 } 6246 6247 // CHECK: test_vqmovun_s64 6248 // CHECK: vqmovun.s64 d{{[0-9]+}}, q{{[0-9]+}} 6249 uint32x2_t test_vqmovun_s64(int64x2_t a) { 6250 return vqmovun_s64(a); 6251 } 6252 6253 6254 // CHECK: test_vqneg_s8 6255 // CHECK: vqneg.s8 d{{[0-9]+}}, d{{[0-9]+}} 6256 int8x8_t test_vqneg_s8(int8x8_t a) { 6257 return vqneg_s8(a); 6258 } 6259 6260 // CHECK: test_vqneg_s16 6261 // CHECK: vqneg.s16 d{{[0-9]+}}, d{{[0-9]+}} 6262 int16x4_t test_vqneg_s16(int16x4_t a) { 6263 return vqneg_s16(a); 6264 } 6265 6266 // CHECK: test_vqneg_s32 6267 // CHECK: vqneg.s32 d{{[0-9]+}}, d{{[0-9]+}} 6268 int32x2_t test_vqneg_s32(int32x2_t a) { 6269 return vqneg_s32(a); 6270 } 6271 6272 // CHECK: test_vqnegq_s8 6273 // CHECK: vqneg.s8 q{{[0-9]+}}, q{{[0-9]+}} 6274 int8x16_t test_vqnegq_s8(int8x16_t a) { 6275 return vqnegq_s8(a); 6276 } 6277 6278 // CHECK: test_vqnegq_s16 6279 // CHECK: vqneg.s16 q{{[0-9]+}}, q{{[0-9]+}} 6280 int16x8_t test_vqnegq_s16(int16x8_t a) { 6281 return vqnegq_s16(a); 6282 } 6283 6284 // CHECK: test_vqnegq_s32 6285 // CHECK: vqneg.s32 q{{[0-9]+}}, q{{[0-9]+}} 6286 int32x4_t test_vqnegq_s32(int32x4_t a) { 6287 return vqnegq_s32(a); 6288 } 6289 6290 6291 // CHECK: test_vqrdmulh_s16 6292 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6293 int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) { 6294 return vqrdmulh_s16(a, b); 6295 } 6296 6297 // CHECK: test_vqrdmulh_s32 6298 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6299 int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) { 6300 return vqrdmulh_s32(a, b); 6301 } 6302 6303 // CHECK: test_vqrdmulhq_s16 6304 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6305 int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) { 6306 return vqrdmulhq_s16(a, b); 6307 } 6308 6309 // CHECK: test_vqrdmulhq_s32 6310 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6311 int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) { 6312 return vqrdmulhq_s32(a, b); 6313 } 6314 6315 6316 // CHECK: test_vqrdmulh_lane_s16 6317 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6318 int16x4_t test_vqrdmulh_lane_s16(int16x4_t a, int16x4_t b) { 6319 return vqrdmulh_lane_s16(a, b, 3); 6320 } 6321 6322 // CHECK: test_vqrdmulh_lane_s32 6323 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6324 int32x2_t test_vqrdmulh_lane_s32(int32x2_t a, int32x2_t b) { 6325 return vqrdmulh_lane_s32(a, b, 1); 6326 } 6327 6328 // CHECK: test_vqrdmulhq_lane_s16 6329 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6330 int16x8_t test_vqrdmulhq_lane_s16(int16x8_t a, int16x4_t b) { 6331 return vqrdmulhq_lane_s16(a, b, 3); 6332 } 6333 6334 // CHECK: test_vqrdmulhq_lane_s32 6335 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6336 int32x4_t test_vqrdmulhq_lane_s32(int32x4_t a, int32x2_t b) { 6337 return vqrdmulhq_lane_s32(a, b, 1); 6338 } 6339 6340 6341 // CHECK: test_vqrdmulh_n_s16 6342 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6343 int16x4_t test_vqrdmulh_n_s16(int16x4_t a, int16_t b) { 6344 return vqrdmulh_n_s16(a, b); 6345 } 6346 6347 // CHECK: test_vqrdmulh_n_s32 6348 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6349 int32x2_t test_vqrdmulh_n_s32(int32x2_t a, int32_t b) { 6350 return vqrdmulh_n_s32(a, b); 6351 } 6352 6353 // CHECK: test_vqrdmulhq_n_s16 6354 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6355 int16x8_t test_vqrdmulhq_n_s16(int16x8_t a, int16_t b) { 6356 return vqrdmulhq_n_s16(a, b); 6357 } 6358 6359 // CHECK: test_vqrdmulhq_n_s32 6360 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6361 int32x4_t test_vqrdmulhq_n_s32(int32x4_t a, int32_t b) { 6362 return vqrdmulhq_n_s32(a, b); 6363 } 6364 6365 6366 // CHECK: test_vqrshl_s8 6367 // CHECK: vqrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6368 int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) { 6369 return vqrshl_s8(a, b); 6370 } 6371 6372 // CHECK: test_vqrshl_s16 6373 // CHECK: vqrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6374 int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) { 6375 return vqrshl_s16(a, b); 6376 } 6377 6378 // CHECK: test_vqrshl_s32 6379 // CHECK: vqrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6380 int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) { 6381 return vqrshl_s32(a, b); 6382 } 6383 6384 // CHECK: test_vqrshl_s64 6385 // CHECK: vqrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6386 int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) { 6387 return vqrshl_s64(a, b); 6388 } 6389 6390 // CHECK: test_vqrshl_u8 6391 // CHECK: vqrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6392 uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) { 6393 return vqrshl_u8(a, b); 6394 } 6395 6396 // CHECK: test_vqrshl_u16 6397 // CHECK: vqrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6398 uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) { 6399 return vqrshl_u16(a, b); 6400 } 6401 6402 // CHECK: test_vqrshl_u32 6403 // CHECK: vqrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6404 uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) { 6405 return vqrshl_u32(a, b); 6406 } 6407 6408 // CHECK: test_vqrshl_u64 6409 // CHECK: vqrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6410 uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) { 6411 return vqrshl_u64(a, b); 6412 } 6413 6414 // CHECK: test_vqrshlq_s8 6415 // CHECK: vqrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6416 int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) { 6417 return vqrshlq_s8(a, b); 6418 } 6419 6420 // CHECK: test_vqrshlq_s16 6421 // CHECK: vqrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6422 int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) { 6423 return vqrshlq_s16(a, b); 6424 } 6425 6426 // CHECK: test_vqrshlq_s32 6427 // CHECK: vqrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6428 int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) { 6429 return vqrshlq_s32(a, b); 6430 } 6431 6432 // CHECK: test_vqrshlq_s64 6433 // CHECK: vqrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6434 int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) { 6435 return vqrshlq_s64(a, b); 6436 } 6437 6438 // CHECK: test_vqrshlq_u8 6439 // CHECK: vqrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6440 uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) { 6441 return vqrshlq_u8(a, b); 6442 } 6443 6444 // CHECK: test_vqrshlq_u16 6445 // CHECK: vqrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6446 uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) { 6447 return vqrshlq_u16(a, b); 6448 } 6449 6450 // CHECK: test_vqrshlq_u32 6451 // CHECK: vqrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6452 uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) { 6453 return vqrshlq_u32(a, b); 6454 } 6455 6456 // CHECK: test_vqrshlq_u64 6457 // CHECK: vqrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6458 uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) { 6459 return vqrshlq_u64(a, b); 6460 } 6461 6462 6463 // CHECK: test_vqrshrn_n_s16 6464 // CHECK: vqrshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6465 int8x8_t test_vqrshrn_n_s16(int16x8_t a) { 6466 return vqrshrn_n_s16(a, 1); 6467 } 6468 6469 // CHECK: test_vqrshrn_n_s32 6470 // CHECK: vqrshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6471 int16x4_t test_vqrshrn_n_s32(int32x4_t a) { 6472 return vqrshrn_n_s32(a, 1); 6473 } 6474 6475 // CHECK: test_vqrshrn_n_s64 6476 // CHECK: vqrshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6477 int32x2_t test_vqrshrn_n_s64(int64x2_t a) { 6478 return vqrshrn_n_s64(a, 1); 6479 } 6480 6481 // CHECK: test_vqrshrn_n_u16 6482 // CHECK: vqrshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6483 uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) { 6484 return vqrshrn_n_u16(a, 1); 6485 } 6486 6487 // CHECK: test_vqrshrn_n_u32 6488 // CHECK: vqrshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6489 uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) { 6490 return vqrshrn_n_u32(a, 1); 6491 } 6492 6493 // CHECK: test_vqrshrn_n_u64 6494 // CHECK: vqrshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6495 uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) { 6496 return vqrshrn_n_u64(a, 1); 6497 } 6498 6499 6500 // CHECK: test_vqrshrun_n_s16 6501 // CHECK: vqrshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6502 uint8x8_t test_vqrshrun_n_s16(int16x8_t a) { 6503 return vqrshrun_n_s16(a, 1); 6504 } 6505 6506 // CHECK: test_vqrshrun_n_s32 6507 // CHECK: vqrshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6508 uint16x4_t test_vqrshrun_n_s32(int32x4_t a) { 6509 return vqrshrun_n_s32(a, 1); 6510 } 6511 6512 // CHECK: test_vqrshrun_n_s64 6513 // CHECK: vqrshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6514 uint32x2_t test_vqrshrun_n_s64(int64x2_t a) { 6515 return vqrshrun_n_s64(a, 1); 6516 } 6517 6518 6519 // CHECK: test_vqshl_s8 6520 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6521 int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) { 6522 return vqshl_s8(a, b); 6523 } 6524 6525 // CHECK: test_vqshl_s16 6526 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6527 int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) { 6528 return vqshl_s16(a, b); 6529 } 6530 6531 // CHECK: test_vqshl_s32 6532 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6533 int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) { 6534 return vqshl_s32(a, b); 6535 } 6536 6537 // CHECK: test_vqshl_s64 6538 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6539 int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) { 6540 return vqshl_s64(a, b); 6541 } 6542 6543 // CHECK: test_vqshl_u8 6544 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6545 uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) { 6546 return vqshl_u8(a, b); 6547 } 6548 6549 // CHECK: test_vqshl_u16 6550 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6551 uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) { 6552 return vqshl_u16(a, b); 6553 } 6554 6555 // CHECK: test_vqshl_u32 6556 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6557 uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) { 6558 return vqshl_u32(a, b); 6559 } 6560 6561 // CHECK: test_vqshl_u64 6562 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6563 uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) { 6564 return vqshl_u64(a, b); 6565 } 6566 6567 // CHECK: test_vqshlq_s8 6568 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6569 int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) { 6570 return vqshlq_s8(a, b); 6571 } 6572 6573 // CHECK: test_vqshlq_s16 6574 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6575 int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) { 6576 return vqshlq_s16(a, b); 6577 } 6578 6579 // CHECK: test_vqshlq_s32 6580 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6581 int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) { 6582 return vqshlq_s32(a, b); 6583 } 6584 6585 // CHECK: test_vqshlq_s64 6586 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6587 int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) { 6588 return vqshlq_s64(a, b); 6589 } 6590 6591 // CHECK: test_vqshlq_u8 6592 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6593 uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) { 6594 return vqshlq_u8(a, b); 6595 } 6596 6597 // CHECK: test_vqshlq_u16 6598 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6599 uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) { 6600 return vqshlq_u16(a, b); 6601 } 6602 6603 // CHECK: test_vqshlq_u32 6604 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6605 uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) { 6606 return vqshlq_u32(a, b); 6607 } 6608 6609 // CHECK: test_vqshlq_u64 6610 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6611 uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) { 6612 return vqshlq_u64(a, b); 6613 } 6614 6615 6616 // CHECK: test_vqshlu_n_s8 6617 // CHECK: vqshlu.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6618 uint8x8_t test_vqshlu_n_s8(int8x8_t a) { 6619 return vqshlu_n_s8(a, 1); 6620 } 6621 6622 // CHECK: test_vqshlu_n_s16 6623 // CHECK: vqshlu.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6624 uint16x4_t test_vqshlu_n_s16(int16x4_t a) { 6625 return vqshlu_n_s16(a, 1); 6626 } 6627 6628 // CHECK: test_vqshlu_n_s32 6629 // CHECK: vqshlu.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6630 uint32x2_t test_vqshlu_n_s32(int32x2_t a) { 6631 return vqshlu_n_s32(a, 1); 6632 } 6633 6634 // CHECK: test_vqshlu_n_s64 6635 // CHECK: vqshlu.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6636 uint64x1_t test_vqshlu_n_s64(int64x1_t a) { 6637 return vqshlu_n_s64(a, 1); 6638 } 6639 6640 // CHECK: test_vqshluq_n_s8 6641 // CHECK: vqshlu.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6642 uint8x16_t test_vqshluq_n_s8(int8x16_t a) { 6643 return vqshluq_n_s8(a, 1); 6644 } 6645 6646 // CHECK: test_vqshluq_n_s16 6647 // CHECK: vqshlu.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6648 uint16x8_t test_vqshluq_n_s16(int16x8_t a) { 6649 return vqshluq_n_s16(a, 1); 6650 } 6651 6652 // CHECK: test_vqshluq_n_s32 6653 // CHECK: vqshlu.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6654 uint32x4_t test_vqshluq_n_s32(int32x4_t a) { 6655 return vqshluq_n_s32(a, 1); 6656 } 6657 6658 // CHECK: test_vqshluq_n_s64 6659 // CHECK: vqshlu.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6660 uint64x2_t test_vqshluq_n_s64(int64x2_t a) { 6661 return vqshluq_n_s64(a, 1); 6662 } 6663 6664 6665 // CHECK: test_vqshl_n_s8 6666 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6667 int8x8_t test_vqshl_n_s8(int8x8_t a) { 6668 return vqshl_n_s8(a, 1); 6669 } 6670 6671 // CHECK: test_vqshl_n_s16 6672 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6673 int16x4_t test_vqshl_n_s16(int16x4_t a) { 6674 return vqshl_n_s16(a, 1); 6675 } 6676 6677 // CHECK: test_vqshl_n_s32 6678 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6679 int32x2_t test_vqshl_n_s32(int32x2_t a) { 6680 return vqshl_n_s32(a, 1); 6681 } 6682 6683 // CHECK: test_vqshl_n_s64 6684 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6685 int64x1_t test_vqshl_n_s64(int64x1_t a) { 6686 return vqshl_n_s64(a, 1); 6687 } 6688 6689 // CHECK: test_vqshl_n_u8 6690 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6691 uint8x8_t test_vqshl_n_u8(uint8x8_t a) { 6692 return vqshl_n_u8(a, 1); 6693 } 6694 6695 // CHECK: test_vqshl_n_u16 6696 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6697 uint16x4_t test_vqshl_n_u16(uint16x4_t a) { 6698 return vqshl_n_u16(a, 1); 6699 } 6700 6701 // CHECK: test_vqshl_n_u32 6702 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6703 uint32x2_t test_vqshl_n_u32(uint32x2_t a) { 6704 return vqshl_n_u32(a, 1); 6705 } 6706 6707 // CHECK: test_vqshl_n_u64 6708 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6709 uint64x1_t test_vqshl_n_u64(uint64x1_t a) { 6710 return vqshl_n_u64(a, 1); 6711 } 6712 6713 // CHECK: test_vqshlq_n_s8 6714 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6715 int8x16_t test_vqshlq_n_s8(int8x16_t a) { 6716 return vqshlq_n_s8(a, 1); 6717 } 6718 6719 // CHECK: test_vqshlq_n_s16 6720 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6721 int16x8_t test_vqshlq_n_s16(int16x8_t a) { 6722 return vqshlq_n_s16(a, 1); 6723 } 6724 6725 // CHECK: test_vqshlq_n_s32 6726 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6727 int32x4_t test_vqshlq_n_s32(int32x4_t a) { 6728 return vqshlq_n_s32(a, 1); 6729 } 6730 6731 // CHECK: test_vqshlq_n_s64 6732 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6733 int64x2_t test_vqshlq_n_s64(int64x2_t a) { 6734 return vqshlq_n_s64(a, 1); 6735 } 6736 6737 // CHECK: test_vqshlq_n_u8 6738 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6739 uint8x16_t test_vqshlq_n_u8(uint8x16_t a) { 6740 return vqshlq_n_u8(a, 1); 6741 } 6742 6743 // CHECK: test_vqshlq_n_u16 6744 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6745 uint16x8_t test_vqshlq_n_u16(uint16x8_t a) { 6746 return vqshlq_n_u16(a, 1); 6747 } 6748 6749 // CHECK: test_vqshlq_n_u32 6750 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6751 uint32x4_t test_vqshlq_n_u32(uint32x4_t a) { 6752 return vqshlq_n_u32(a, 1); 6753 } 6754 6755 // CHECK: test_vqshlq_n_u64 6756 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6757 uint64x2_t test_vqshlq_n_u64(uint64x2_t a) { 6758 return vqshlq_n_u64(a, 1); 6759 } 6760 6761 6762 // CHECK: test_vqshrn_n_s16 6763 // CHECK: vqshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6764 int8x8_t test_vqshrn_n_s16(int16x8_t a) { 6765 return vqshrn_n_s16(a, 1); 6766 } 6767 6768 // CHECK: test_vqshrn_n_s32 6769 // CHECK: vqshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6770 int16x4_t test_vqshrn_n_s32(int32x4_t a) { 6771 return vqshrn_n_s32(a, 1); 6772 } 6773 6774 // CHECK: test_vqshrn_n_s64 6775 // CHECK: vqshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6776 int32x2_t test_vqshrn_n_s64(int64x2_t a) { 6777 return vqshrn_n_s64(a, 1); 6778 } 6779 6780 // CHECK: test_vqshrn_n_u16 6781 // CHECK: vqshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6782 uint8x8_t test_vqshrn_n_u16(uint16x8_t a) { 6783 return vqshrn_n_u16(a, 1); 6784 } 6785 6786 // CHECK: test_vqshrn_n_u32 6787 // CHECK: vqshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6788 uint16x4_t test_vqshrn_n_u32(uint32x4_t a) { 6789 return vqshrn_n_u32(a, 1); 6790 } 6791 6792 // CHECK: test_vqshrn_n_u64 6793 // CHECK: vqshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6794 uint32x2_t test_vqshrn_n_u64(uint64x2_t a) { 6795 return vqshrn_n_u64(a, 1); 6796 } 6797 6798 6799 // CHECK: test_vqshrun_n_s16 6800 // CHECK: vqshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6801 uint8x8_t test_vqshrun_n_s16(int16x8_t a) { 6802 return vqshrun_n_s16(a, 1); 6803 } 6804 6805 // CHECK: test_vqshrun_n_s32 6806 // CHECK: vqshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6807 uint16x4_t test_vqshrun_n_s32(int32x4_t a) { 6808 return vqshrun_n_s32(a, 1); 6809 } 6810 6811 // CHECK: test_vqshrun_n_s64 6812 // CHECK: vqshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6813 uint32x2_t test_vqshrun_n_s64(int64x2_t a) { 6814 return vqshrun_n_s64(a, 1); 6815 } 6816 6817 6818 // CHECK: test_vqsub_s8 6819 // CHECK: vqsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6820 int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) { 6821 return vqsub_s8(a, b); 6822 } 6823 6824 // CHECK: test_vqsub_s16 6825 // CHECK: vqsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6826 int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) { 6827 return vqsub_s16(a, b); 6828 } 6829 6830 // CHECK: test_vqsub_s32 6831 // CHECK: vqsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6832 int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) { 6833 return vqsub_s32(a, b); 6834 } 6835 6836 // CHECK: test_vqsub_s64 6837 // CHECK: vqsub.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6838 int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) { 6839 return vqsub_s64(a, b); 6840 } 6841 6842 // CHECK: test_vqsub_u8 6843 // CHECK: vqsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6844 uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) { 6845 return vqsub_u8(a, b); 6846 } 6847 6848 // CHECK: test_vqsub_u16 6849 // CHECK: vqsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6850 uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) { 6851 return vqsub_u16(a, b); 6852 } 6853 6854 // CHECK: test_vqsub_u32 6855 // CHECK: vqsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6856 uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) { 6857 return vqsub_u32(a, b); 6858 } 6859 6860 // CHECK: test_vqsub_u64 6861 // CHECK: vqsub.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6862 uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) { 6863 return vqsub_u64(a, b); 6864 } 6865 6866 // CHECK: test_vqsubq_s8 6867 // CHECK: vqsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6868 int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) { 6869 return vqsubq_s8(a, b); 6870 } 6871 6872 // CHECK: test_vqsubq_s16 6873 // CHECK: vqsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6874 int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) { 6875 return vqsubq_s16(a, b); 6876 } 6877 6878 // CHECK: test_vqsubq_s32 6879 // CHECK: vqsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6880 int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) { 6881 return vqsubq_s32(a, b); 6882 } 6883 6884 // CHECK: test_vqsubq_s64 6885 // CHECK: vqsub.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6886 int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) { 6887 return vqsubq_s64(a, b); 6888 } 6889 6890 // CHECK: test_vqsubq_u8 6891 // CHECK: vqsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6892 uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) { 6893 return vqsubq_u8(a, b); 6894 } 6895 6896 // CHECK: test_vqsubq_u16 6897 // CHECK: vqsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6898 uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) { 6899 return vqsubq_u16(a, b); 6900 } 6901 6902 // CHECK: test_vqsubq_u32 6903 // CHECK: vqsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6904 uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) { 6905 return vqsubq_u32(a, b); 6906 } 6907 6908 // CHECK: test_vqsubq_u64 6909 // CHECK: vqsub.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6910 uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) { 6911 return vqsubq_u64(a, b); 6912 } 6913 6914 6915 // CHECK: test_vraddhn_s16 6916 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6917 int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) { 6918 return vraddhn_s16(a, b); 6919 } 6920 6921 // CHECK: test_vraddhn_s32 6922 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6923 int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) { 6924 return vraddhn_s32(a, b); 6925 } 6926 6927 // CHECK: test_vraddhn_s64 6928 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6929 int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) { 6930 return vraddhn_s64(a, b); 6931 } 6932 6933 // CHECK: test_vraddhn_u16 6934 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6935 uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) { 6936 return vraddhn_u16(a, b); 6937 } 6938 6939 // CHECK: test_vraddhn_u32 6940 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6941 uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) { 6942 return vraddhn_u32(a, b); 6943 } 6944 6945 // CHECK: test_vraddhn_u64 6946 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6947 uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) { 6948 return vraddhn_u64(a, b); 6949 } 6950 6951 6952 // CHECK: test_vrecpe_f32 6953 // CHECK: vrecpe.f32 d{{[0-9]+}}, d{{[0-9]+}} 6954 float32x2_t test_vrecpe_f32(float32x2_t a) { 6955 return vrecpe_f32(a); 6956 } 6957 6958 // CHECK: test_vrecpe_u32 6959 // CHECK: vrecpe.u32 d{{[0-9]+}}, d{{[0-9]+}} 6960 uint32x2_t test_vrecpe_u32(uint32x2_t a) { 6961 return vrecpe_u32(a); 6962 } 6963 6964 // CHECK: test_vrecpeq_f32 6965 // CHECK: vrecpe.f32 q{{[0-9]+}}, q{{[0-9]+}} 6966 float32x4_t test_vrecpeq_f32(float32x4_t a) { 6967 return vrecpeq_f32(a); 6968 } 6969 6970 // CHECK: test_vrecpeq_u32 6971 // CHECK: vrecpe.u32 q{{[0-9]+}}, q{{[0-9]+}} 6972 uint32x4_t test_vrecpeq_u32(uint32x4_t a) { 6973 return vrecpeq_u32(a); 6974 } 6975 6976 6977 // CHECK: test_vrecps_f32 6978 // CHECK: vrecps.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6979 float32x2_t test_vrecps_f32(float32x2_t a, float32x2_t b) { 6980 return vrecps_f32(a, b); 6981 } 6982 6983 // CHECK: test_vrecpsq_f32 6984 // CHECK: vrecps.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6985 float32x4_t test_vrecpsq_f32(float32x4_t a, float32x4_t b) { 6986 return vrecpsq_f32(a, b); 6987 } 6988 6989 6990 // CHECK: test_vreinterpret_s8_s16 6991 int8x8_t test_vreinterpret_s8_s16(int16x4_t a) { 6992 return vreinterpret_s8_s16(a); 6993 } 6994 6995 // CHECK: test_vreinterpret_s8_s32 6996 int8x8_t test_vreinterpret_s8_s32(int32x2_t a) { 6997 return vreinterpret_s8_s32(a); 6998 } 6999 7000 // CHECK: test_vreinterpret_s8_s64 7001 int8x8_t test_vreinterpret_s8_s64(int64x1_t a) { 7002 return vreinterpret_s8_s64(a); 7003 } 7004 7005 // CHECK: test_vreinterpret_s8_u8 7006 int8x8_t test_vreinterpret_s8_u8(uint8x8_t a) { 7007 return vreinterpret_s8_u8(a); 7008 } 7009 7010 // CHECK: test_vreinterpret_s8_u16 7011 int8x8_t test_vreinterpret_s8_u16(uint16x4_t a) { 7012 return vreinterpret_s8_u16(a); 7013 } 7014 7015 // CHECK: test_vreinterpret_s8_u32 7016 int8x8_t test_vreinterpret_s8_u32(uint32x2_t a) { 7017 return vreinterpret_s8_u32(a); 7018 } 7019 7020 // CHECK: test_vreinterpret_s8_u64 7021 int8x8_t test_vreinterpret_s8_u64(uint64x1_t a) { 7022 return vreinterpret_s8_u64(a); 7023 } 7024 7025 // CHECK: test_vreinterpret_s8_f16 7026 int8x8_t test_vreinterpret_s8_f16(float16x4_t a) { 7027 return vreinterpret_s8_f16(a); 7028 } 7029 7030 // CHECK: test_vreinterpret_s8_f32 7031 int8x8_t test_vreinterpret_s8_f32(float32x2_t a) { 7032 return vreinterpret_s8_f32(a); 7033 } 7034 7035 // CHECK: test_vreinterpret_s8_p8 7036 int8x8_t test_vreinterpret_s8_p8(poly8x8_t a) { 7037 return vreinterpret_s8_p8(a); 7038 } 7039 7040 // CHECK: test_vreinterpret_s8_p16 7041 int8x8_t test_vreinterpret_s8_p16(poly16x4_t a) { 7042 return vreinterpret_s8_p16(a); 7043 } 7044 7045 // CHECK: test_vreinterpret_s16_s8 7046 int16x4_t test_vreinterpret_s16_s8(int8x8_t a) { 7047 return vreinterpret_s16_s8(a); 7048 } 7049 7050 // CHECK: test_vreinterpret_s16_s32 7051 int16x4_t test_vreinterpret_s16_s32(int32x2_t a) { 7052 return vreinterpret_s16_s32(a); 7053 } 7054 7055 // CHECK: test_vreinterpret_s16_s64 7056 int16x4_t test_vreinterpret_s16_s64(int64x1_t a) { 7057 return vreinterpret_s16_s64(a); 7058 } 7059 7060 // CHECK: test_vreinterpret_s16_u8 7061 int16x4_t test_vreinterpret_s16_u8(uint8x8_t a) { 7062 return vreinterpret_s16_u8(a); 7063 } 7064 7065 // CHECK: test_vreinterpret_s16_u16 7066 int16x4_t test_vreinterpret_s16_u16(uint16x4_t a) { 7067 return vreinterpret_s16_u16(a); 7068 } 7069 7070 // CHECK: test_vreinterpret_s16_u32 7071 int16x4_t test_vreinterpret_s16_u32(uint32x2_t a) { 7072 return vreinterpret_s16_u32(a); 7073 } 7074 7075 // CHECK: test_vreinterpret_s16_u64 7076 int16x4_t test_vreinterpret_s16_u64(uint64x1_t a) { 7077 return vreinterpret_s16_u64(a); 7078 } 7079 7080 // CHECK: test_vreinterpret_s16_f16 7081 int16x4_t test_vreinterpret_s16_f16(float16x4_t a) { 7082 return vreinterpret_s16_f16(a); 7083 } 7084 7085 // CHECK: test_vreinterpret_s16_f32 7086 int16x4_t test_vreinterpret_s16_f32(float32x2_t a) { 7087 return vreinterpret_s16_f32(a); 7088 } 7089 7090 // CHECK: test_vreinterpret_s16_p8 7091 int16x4_t test_vreinterpret_s16_p8(poly8x8_t a) { 7092 return vreinterpret_s16_p8(a); 7093 } 7094 7095 // CHECK: test_vreinterpret_s16_p16 7096 int16x4_t test_vreinterpret_s16_p16(poly16x4_t a) { 7097 return vreinterpret_s16_p16(a); 7098 } 7099 7100 // CHECK: test_vreinterpret_s32_s8 7101 int32x2_t test_vreinterpret_s32_s8(int8x8_t a) { 7102 return vreinterpret_s32_s8(a); 7103 } 7104 7105 // CHECK: test_vreinterpret_s32_s16 7106 int32x2_t test_vreinterpret_s32_s16(int16x4_t a) { 7107 return vreinterpret_s32_s16(a); 7108 } 7109 7110 // CHECK: test_vreinterpret_s32_s64 7111 int32x2_t test_vreinterpret_s32_s64(int64x1_t a) { 7112 return vreinterpret_s32_s64(a); 7113 } 7114 7115 // CHECK: test_vreinterpret_s32_u8 7116 int32x2_t test_vreinterpret_s32_u8(uint8x8_t a) { 7117 return vreinterpret_s32_u8(a); 7118 } 7119 7120 // CHECK: test_vreinterpret_s32_u16 7121 int32x2_t test_vreinterpret_s32_u16(uint16x4_t a) { 7122 return vreinterpret_s32_u16(a); 7123 } 7124 7125 // CHECK: test_vreinterpret_s32_u32 7126 int32x2_t test_vreinterpret_s32_u32(uint32x2_t a) { 7127 return vreinterpret_s32_u32(a); 7128 } 7129 7130 // CHECK: test_vreinterpret_s32_u64 7131 int32x2_t test_vreinterpret_s32_u64(uint64x1_t a) { 7132 return vreinterpret_s32_u64(a); 7133 } 7134 7135 // CHECK: test_vreinterpret_s32_f16 7136 int32x2_t test_vreinterpret_s32_f16(float16x4_t a) { 7137 return vreinterpret_s32_f16(a); 7138 } 7139 7140 // CHECK: test_vreinterpret_s32_f32 7141 int32x2_t test_vreinterpret_s32_f32(float32x2_t a) { 7142 return vreinterpret_s32_f32(a); 7143 } 7144 7145 // CHECK: test_vreinterpret_s32_p8 7146 int32x2_t test_vreinterpret_s32_p8(poly8x8_t a) { 7147 return vreinterpret_s32_p8(a); 7148 } 7149 7150 // CHECK: test_vreinterpret_s32_p16 7151 int32x2_t test_vreinterpret_s32_p16(poly16x4_t a) { 7152 return vreinterpret_s32_p16(a); 7153 } 7154 7155 // CHECK: test_vreinterpret_s64_s8 7156 int64x1_t test_vreinterpret_s64_s8(int8x8_t a) { 7157 return vreinterpret_s64_s8(a); 7158 } 7159 7160 // CHECK: test_vreinterpret_s64_s16 7161 int64x1_t test_vreinterpret_s64_s16(int16x4_t a) { 7162 return vreinterpret_s64_s16(a); 7163 } 7164 7165 // CHECK: test_vreinterpret_s64_s32 7166 int64x1_t test_vreinterpret_s64_s32(int32x2_t a) { 7167 return vreinterpret_s64_s32(a); 7168 } 7169 7170 // CHECK: test_vreinterpret_s64_u8 7171 int64x1_t test_vreinterpret_s64_u8(uint8x8_t a) { 7172 return vreinterpret_s64_u8(a); 7173 } 7174 7175 // CHECK: test_vreinterpret_s64_u16 7176 int64x1_t test_vreinterpret_s64_u16(uint16x4_t a) { 7177 return vreinterpret_s64_u16(a); 7178 } 7179 7180 // CHECK: test_vreinterpret_s64_u32 7181 int64x1_t test_vreinterpret_s64_u32(uint32x2_t a) { 7182 return vreinterpret_s64_u32(a); 7183 } 7184 7185 // CHECK: test_vreinterpret_s64_u64 7186 int64x1_t test_vreinterpret_s64_u64(uint64x1_t a) { 7187 return vreinterpret_s64_u64(a); 7188 } 7189 7190 // CHECK: test_vreinterpret_s64_f16 7191 int64x1_t test_vreinterpret_s64_f16(float16x4_t a) { 7192 return vreinterpret_s64_f16(a); 7193 } 7194 7195 // CHECK: test_vreinterpret_s64_f32 7196 int64x1_t test_vreinterpret_s64_f32(float32x2_t a) { 7197 return vreinterpret_s64_f32(a); 7198 } 7199 7200 // CHECK: test_vreinterpret_s64_p8 7201 int64x1_t test_vreinterpret_s64_p8(poly8x8_t a) { 7202 return vreinterpret_s64_p8(a); 7203 } 7204 7205 // CHECK: test_vreinterpret_s64_p16 7206 int64x1_t test_vreinterpret_s64_p16(poly16x4_t a) { 7207 return vreinterpret_s64_p16(a); 7208 } 7209 7210 // CHECK: test_vreinterpret_u8_s8 7211 uint8x8_t test_vreinterpret_u8_s8(int8x8_t a) { 7212 return vreinterpret_u8_s8(a); 7213 } 7214 7215 // CHECK: test_vreinterpret_u8_s16 7216 uint8x8_t test_vreinterpret_u8_s16(int16x4_t a) { 7217 return vreinterpret_u8_s16(a); 7218 } 7219 7220 // CHECK: test_vreinterpret_u8_s32 7221 uint8x8_t test_vreinterpret_u8_s32(int32x2_t a) { 7222 return vreinterpret_u8_s32(a); 7223 } 7224 7225 // CHECK: test_vreinterpret_u8_s64 7226 uint8x8_t test_vreinterpret_u8_s64(int64x1_t a) { 7227 return vreinterpret_u8_s64(a); 7228 } 7229 7230 // CHECK: test_vreinterpret_u8_u16 7231 uint8x8_t test_vreinterpret_u8_u16(uint16x4_t a) { 7232 return vreinterpret_u8_u16(a); 7233 } 7234 7235 // CHECK: test_vreinterpret_u8_u32 7236 uint8x8_t test_vreinterpret_u8_u32(uint32x2_t a) { 7237 return vreinterpret_u8_u32(a); 7238 } 7239 7240 // CHECK: test_vreinterpret_u8_u64 7241 uint8x8_t test_vreinterpret_u8_u64(uint64x1_t a) { 7242 return vreinterpret_u8_u64(a); 7243 } 7244 7245 // CHECK: test_vreinterpret_u8_f16 7246 uint8x8_t test_vreinterpret_u8_f16(float16x4_t a) { 7247 return vreinterpret_u8_f16(a); 7248 } 7249 7250 // CHECK: test_vreinterpret_u8_f32 7251 uint8x8_t test_vreinterpret_u8_f32(float32x2_t a) { 7252 return vreinterpret_u8_f32(a); 7253 } 7254 7255 // CHECK: test_vreinterpret_u8_p8 7256 uint8x8_t test_vreinterpret_u8_p8(poly8x8_t a) { 7257 return vreinterpret_u8_p8(a); 7258 } 7259 7260 // CHECK: test_vreinterpret_u8_p16 7261 uint8x8_t test_vreinterpret_u8_p16(poly16x4_t a) { 7262 return vreinterpret_u8_p16(a); 7263 } 7264 7265 // CHECK: test_vreinterpret_u16_s8 7266 uint16x4_t test_vreinterpret_u16_s8(int8x8_t a) { 7267 return vreinterpret_u16_s8(a); 7268 } 7269 7270 // CHECK: test_vreinterpret_u16_s16 7271 uint16x4_t test_vreinterpret_u16_s16(int16x4_t a) { 7272 return vreinterpret_u16_s16(a); 7273 } 7274 7275 // CHECK: test_vreinterpret_u16_s32 7276 uint16x4_t test_vreinterpret_u16_s32(int32x2_t a) { 7277 return vreinterpret_u16_s32(a); 7278 } 7279 7280 // CHECK: test_vreinterpret_u16_s64 7281 uint16x4_t test_vreinterpret_u16_s64(int64x1_t a) { 7282 return vreinterpret_u16_s64(a); 7283 } 7284 7285 // CHECK: test_vreinterpret_u16_u8 7286 uint16x4_t test_vreinterpret_u16_u8(uint8x8_t a) { 7287 return vreinterpret_u16_u8(a); 7288 } 7289 7290 // CHECK: test_vreinterpret_u16_u32 7291 uint16x4_t test_vreinterpret_u16_u32(uint32x2_t a) { 7292 return vreinterpret_u16_u32(a); 7293 } 7294 7295 // CHECK: test_vreinterpret_u16_u64 7296 uint16x4_t test_vreinterpret_u16_u64(uint64x1_t a) { 7297 return vreinterpret_u16_u64(a); 7298 } 7299 7300 // CHECK: test_vreinterpret_u16_f16 7301 uint16x4_t test_vreinterpret_u16_f16(float16x4_t a) { 7302 return vreinterpret_u16_f16(a); 7303 } 7304 7305 // CHECK: test_vreinterpret_u16_f32 7306 uint16x4_t test_vreinterpret_u16_f32(float32x2_t a) { 7307 return vreinterpret_u16_f32(a); 7308 } 7309 7310 // CHECK: test_vreinterpret_u16_p8 7311 uint16x4_t test_vreinterpret_u16_p8(poly8x8_t a) { 7312 return vreinterpret_u16_p8(a); 7313 } 7314 7315 // CHECK: test_vreinterpret_u16_p16 7316 uint16x4_t test_vreinterpret_u16_p16(poly16x4_t a) { 7317 return vreinterpret_u16_p16(a); 7318 } 7319 7320 // CHECK: test_vreinterpret_u32_s8 7321 uint32x2_t test_vreinterpret_u32_s8(int8x8_t a) { 7322 return vreinterpret_u32_s8(a); 7323 } 7324 7325 // CHECK: test_vreinterpret_u32_s16 7326 uint32x2_t test_vreinterpret_u32_s16(int16x4_t a) { 7327 return vreinterpret_u32_s16(a); 7328 } 7329 7330 // CHECK: test_vreinterpret_u32_s32 7331 uint32x2_t test_vreinterpret_u32_s32(int32x2_t a) { 7332 return vreinterpret_u32_s32(a); 7333 } 7334 7335 // CHECK: test_vreinterpret_u32_s64 7336 uint32x2_t test_vreinterpret_u32_s64(int64x1_t a) { 7337 return vreinterpret_u32_s64(a); 7338 } 7339 7340 // CHECK: test_vreinterpret_u32_u8 7341 uint32x2_t test_vreinterpret_u32_u8(uint8x8_t a) { 7342 return vreinterpret_u32_u8(a); 7343 } 7344 7345 // CHECK: test_vreinterpret_u32_u16 7346 uint32x2_t test_vreinterpret_u32_u16(uint16x4_t a) { 7347 return vreinterpret_u32_u16(a); 7348 } 7349 7350 // CHECK: test_vreinterpret_u32_u64 7351 uint32x2_t test_vreinterpret_u32_u64(uint64x1_t a) { 7352 return vreinterpret_u32_u64(a); 7353 } 7354 7355 // CHECK: test_vreinterpret_u32_f16 7356 uint32x2_t test_vreinterpret_u32_f16(float16x4_t a) { 7357 return vreinterpret_u32_f16(a); 7358 } 7359 7360 // CHECK: test_vreinterpret_u32_f32 7361 uint32x2_t test_vreinterpret_u32_f32(float32x2_t a) { 7362 return vreinterpret_u32_f32(a); 7363 } 7364 7365 // CHECK: test_vreinterpret_u32_p8 7366 uint32x2_t test_vreinterpret_u32_p8(poly8x8_t a) { 7367 return vreinterpret_u32_p8(a); 7368 } 7369 7370 // CHECK: test_vreinterpret_u32_p16 7371 uint32x2_t test_vreinterpret_u32_p16(poly16x4_t a) { 7372 return vreinterpret_u32_p16(a); 7373 } 7374 7375 // CHECK: test_vreinterpret_u64_s8 7376 uint64x1_t test_vreinterpret_u64_s8(int8x8_t a) { 7377 return vreinterpret_u64_s8(a); 7378 } 7379 7380 // CHECK: test_vreinterpret_u64_s16 7381 uint64x1_t test_vreinterpret_u64_s16(int16x4_t a) { 7382 return vreinterpret_u64_s16(a); 7383 } 7384 7385 // CHECK: test_vreinterpret_u64_s32 7386 uint64x1_t test_vreinterpret_u64_s32(int32x2_t a) { 7387 return vreinterpret_u64_s32(a); 7388 } 7389 7390 // CHECK: test_vreinterpret_u64_s64 7391 uint64x1_t test_vreinterpret_u64_s64(int64x1_t a) { 7392 return vreinterpret_u64_s64(a); 7393 } 7394 7395 // CHECK: test_vreinterpret_u64_u8 7396 uint64x1_t test_vreinterpret_u64_u8(uint8x8_t a) { 7397 return vreinterpret_u64_u8(a); 7398 } 7399 7400 // CHECK: test_vreinterpret_u64_u16 7401 uint64x1_t test_vreinterpret_u64_u16(uint16x4_t a) { 7402 return vreinterpret_u64_u16(a); 7403 } 7404 7405 // CHECK: test_vreinterpret_u64_u32 7406 uint64x1_t test_vreinterpret_u64_u32(uint32x2_t a) { 7407 return vreinterpret_u64_u32(a); 7408 } 7409 7410 // CHECK: test_vreinterpret_u64_f16 7411 uint64x1_t test_vreinterpret_u64_f16(float16x4_t a) { 7412 return vreinterpret_u64_f16(a); 7413 } 7414 7415 // CHECK: test_vreinterpret_u64_f32 7416 uint64x1_t test_vreinterpret_u64_f32(float32x2_t a) { 7417 return vreinterpret_u64_f32(a); 7418 } 7419 7420 // CHECK: test_vreinterpret_u64_p8 7421 uint64x1_t test_vreinterpret_u64_p8(poly8x8_t a) { 7422 return vreinterpret_u64_p8(a); 7423 } 7424 7425 // CHECK: test_vreinterpret_u64_p16 7426 uint64x1_t test_vreinterpret_u64_p16(poly16x4_t a) { 7427 return vreinterpret_u64_p16(a); 7428 } 7429 7430 // CHECK: test_vreinterpret_f16_s8 7431 float16x4_t test_vreinterpret_f16_s8(int8x8_t a) { 7432 return vreinterpret_f16_s8(a); 7433 } 7434 7435 // CHECK: test_vreinterpret_f16_s16 7436 float16x4_t test_vreinterpret_f16_s16(int16x4_t a) { 7437 return vreinterpret_f16_s16(a); 7438 } 7439 7440 // CHECK: test_vreinterpret_f16_s32 7441 float16x4_t test_vreinterpret_f16_s32(int32x2_t a) { 7442 return vreinterpret_f16_s32(a); 7443 } 7444 7445 // CHECK: test_vreinterpret_f16_s64 7446 float16x4_t test_vreinterpret_f16_s64(int64x1_t a) { 7447 return vreinterpret_f16_s64(a); 7448 } 7449 7450 // CHECK: test_vreinterpret_f16_u8 7451 float16x4_t test_vreinterpret_f16_u8(uint8x8_t a) { 7452 return vreinterpret_f16_u8(a); 7453 } 7454 7455 // CHECK: test_vreinterpret_f16_u16 7456 float16x4_t test_vreinterpret_f16_u16(uint16x4_t a) { 7457 return vreinterpret_f16_u16(a); 7458 } 7459 7460 // CHECK: test_vreinterpret_f16_u32 7461 float16x4_t test_vreinterpret_f16_u32(uint32x2_t a) { 7462 return vreinterpret_f16_u32(a); 7463 } 7464 7465 // CHECK: test_vreinterpret_f16_u64 7466 float16x4_t test_vreinterpret_f16_u64(uint64x1_t a) { 7467 return vreinterpret_f16_u64(a); 7468 } 7469 7470 // CHECK: test_vreinterpret_f16_f32 7471 float16x4_t test_vreinterpret_f16_f32(float32x2_t a) { 7472 return vreinterpret_f16_f32(a); 7473 } 7474 7475 // CHECK: test_vreinterpret_f16_p8 7476 float16x4_t test_vreinterpret_f16_p8(poly8x8_t a) { 7477 return vreinterpret_f16_p8(a); 7478 } 7479 7480 // CHECK: test_vreinterpret_f16_p16 7481 float16x4_t test_vreinterpret_f16_p16(poly16x4_t a) { 7482 return vreinterpret_f16_p16(a); 7483 } 7484 7485 // CHECK: test_vreinterpret_f32_s8 7486 float32x2_t test_vreinterpret_f32_s8(int8x8_t a) { 7487 return vreinterpret_f32_s8(a); 7488 } 7489 7490 // CHECK: test_vreinterpret_f32_s16 7491 float32x2_t test_vreinterpret_f32_s16(int16x4_t a) { 7492 return vreinterpret_f32_s16(a); 7493 } 7494 7495 // CHECK: test_vreinterpret_f32_s32 7496 float32x2_t test_vreinterpret_f32_s32(int32x2_t a) { 7497 return vreinterpret_f32_s32(a); 7498 } 7499 7500 // CHECK: test_vreinterpret_f32_s64 7501 float32x2_t test_vreinterpret_f32_s64(int64x1_t a) { 7502 return vreinterpret_f32_s64(a); 7503 } 7504 7505 // CHECK: test_vreinterpret_f32_u8 7506 float32x2_t test_vreinterpret_f32_u8(uint8x8_t a) { 7507 return vreinterpret_f32_u8(a); 7508 } 7509 7510 // CHECK: test_vreinterpret_f32_u16 7511 float32x2_t test_vreinterpret_f32_u16(uint16x4_t a) { 7512 return vreinterpret_f32_u16(a); 7513 } 7514 7515 // CHECK: test_vreinterpret_f32_u32 7516 float32x2_t test_vreinterpret_f32_u32(uint32x2_t a) { 7517 return vreinterpret_f32_u32(a); 7518 } 7519 7520 // CHECK: test_vreinterpret_f32_u64 7521 float32x2_t test_vreinterpret_f32_u64(uint64x1_t a) { 7522 return vreinterpret_f32_u64(a); 7523 } 7524 7525 // CHECK: test_vreinterpret_f32_f16 7526 float32x2_t test_vreinterpret_f32_f16(float16x4_t a) { 7527 return vreinterpret_f32_f16(a); 7528 } 7529 7530 // CHECK: test_vreinterpret_f32_p8 7531 float32x2_t test_vreinterpret_f32_p8(poly8x8_t a) { 7532 return vreinterpret_f32_p8(a); 7533 } 7534 7535 // CHECK: test_vreinterpret_f32_p16 7536 float32x2_t test_vreinterpret_f32_p16(poly16x4_t a) { 7537 return vreinterpret_f32_p16(a); 7538 } 7539 7540 // CHECK: test_vreinterpret_p8_s8 7541 poly8x8_t test_vreinterpret_p8_s8(int8x8_t a) { 7542 return vreinterpret_p8_s8(a); 7543 } 7544 7545 // CHECK: test_vreinterpret_p8_s16 7546 poly8x8_t test_vreinterpret_p8_s16(int16x4_t a) { 7547 return vreinterpret_p8_s16(a); 7548 } 7549 7550 // CHECK: test_vreinterpret_p8_s32 7551 poly8x8_t test_vreinterpret_p8_s32(int32x2_t a) { 7552 return vreinterpret_p8_s32(a); 7553 } 7554 7555 // CHECK: test_vreinterpret_p8_s64 7556 poly8x8_t test_vreinterpret_p8_s64(int64x1_t a) { 7557 return vreinterpret_p8_s64(a); 7558 } 7559 7560 // CHECK: test_vreinterpret_p8_u8 7561 poly8x8_t test_vreinterpret_p8_u8(uint8x8_t a) { 7562 return vreinterpret_p8_u8(a); 7563 } 7564 7565 // CHECK: test_vreinterpret_p8_u16 7566 poly8x8_t test_vreinterpret_p8_u16(uint16x4_t a) { 7567 return vreinterpret_p8_u16(a); 7568 } 7569 7570 // CHECK: test_vreinterpret_p8_u32 7571 poly8x8_t test_vreinterpret_p8_u32(uint32x2_t a) { 7572 return vreinterpret_p8_u32(a); 7573 } 7574 7575 // CHECK: test_vreinterpret_p8_u64 7576 poly8x8_t test_vreinterpret_p8_u64(uint64x1_t a) { 7577 return vreinterpret_p8_u64(a); 7578 } 7579 7580 // CHECK: test_vreinterpret_p8_f16 7581 poly8x8_t test_vreinterpret_p8_f16(float16x4_t a) { 7582 return vreinterpret_p8_f16(a); 7583 } 7584 7585 // CHECK: test_vreinterpret_p8_f32 7586 poly8x8_t test_vreinterpret_p8_f32(float32x2_t a) { 7587 return vreinterpret_p8_f32(a); 7588 } 7589 7590 // CHECK: test_vreinterpret_p8_p16 7591 poly8x8_t test_vreinterpret_p8_p16(poly16x4_t a) { 7592 return vreinterpret_p8_p16(a); 7593 } 7594 7595 // CHECK: test_vreinterpret_p16_s8 7596 poly16x4_t test_vreinterpret_p16_s8(int8x8_t a) { 7597 return vreinterpret_p16_s8(a); 7598 } 7599 7600 // CHECK: test_vreinterpret_p16_s16 7601 poly16x4_t test_vreinterpret_p16_s16(int16x4_t a) { 7602 return vreinterpret_p16_s16(a); 7603 } 7604 7605 // CHECK: test_vreinterpret_p16_s32 7606 poly16x4_t test_vreinterpret_p16_s32(int32x2_t a) { 7607 return vreinterpret_p16_s32(a); 7608 } 7609 7610 // CHECK: test_vreinterpret_p16_s64 7611 poly16x4_t test_vreinterpret_p16_s64(int64x1_t a) { 7612 return vreinterpret_p16_s64(a); 7613 } 7614 7615 // CHECK: test_vreinterpret_p16_u8 7616 poly16x4_t test_vreinterpret_p16_u8(uint8x8_t a) { 7617 return vreinterpret_p16_u8(a); 7618 } 7619 7620 // CHECK: test_vreinterpret_p16_u16 7621 poly16x4_t test_vreinterpret_p16_u16(uint16x4_t a) { 7622 return vreinterpret_p16_u16(a); 7623 } 7624 7625 // CHECK: test_vreinterpret_p16_u32 7626 poly16x4_t test_vreinterpret_p16_u32(uint32x2_t a) { 7627 return vreinterpret_p16_u32(a); 7628 } 7629 7630 // CHECK: test_vreinterpret_p16_u64 7631 poly16x4_t test_vreinterpret_p16_u64(uint64x1_t a) { 7632 return vreinterpret_p16_u64(a); 7633 } 7634 7635 // CHECK: test_vreinterpret_p16_f16 7636 poly16x4_t test_vreinterpret_p16_f16(float16x4_t a) { 7637 return vreinterpret_p16_f16(a); 7638 } 7639 7640 // CHECK: test_vreinterpret_p16_f32 7641 poly16x4_t test_vreinterpret_p16_f32(float32x2_t a) { 7642 return vreinterpret_p16_f32(a); 7643 } 7644 7645 // CHECK: test_vreinterpret_p16_p8 7646 poly16x4_t test_vreinterpret_p16_p8(poly8x8_t a) { 7647 return vreinterpret_p16_p8(a); 7648 } 7649 7650 // CHECK: test_vreinterpretq_s8_s16 7651 int8x16_t test_vreinterpretq_s8_s16(int16x8_t a) { 7652 return vreinterpretq_s8_s16(a); 7653 } 7654 7655 // CHECK: test_vreinterpretq_s8_s32 7656 int8x16_t test_vreinterpretq_s8_s32(int32x4_t a) { 7657 return vreinterpretq_s8_s32(a); 7658 } 7659 7660 // CHECK: test_vreinterpretq_s8_s64 7661 int8x16_t test_vreinterpretq_s8_s64(int64x2_t a) { 7662 return vreinterpretq_s8_s64(a); 7663 } 7664 7665 // CHECK: test_vreinterpretq_s8_u8 7666 int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a) { 7667 return vreinterpretq_s8_u8(a); 7668 } 7669 7670 // CHECK: test_vreinterpretq_s8_u16 7671 int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a) { 7672 return vreinterpretq_s8_u16(a); 7673 } 7674 7675 // CHECK: test_vreinterpretq_s8_u32 7676 int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a) { 7677 return vreinterpretq_s8_u32(a); 7678 } 7679 7680 // CHECK: test_vreinterpretq_s8_u64 7681 int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a) { 7682 return vreinterpretq_s8_u64(a); 7683 } 7684 7685 // CHECK: test_vreinterpretq_s8_f16 7686 int8x16_t test_vreinterpretq_s8_f16(float16x8_t a) { 7687 return vreinterpretq_s8_f16(a); 7688 } 7689 7690 // CHECK: test_vreinterpretq_s8_f32 7691 int8x16_t test_vreinterpretq_s8_f32(float32x4_t a) { 7692 return vreinterpretq_s8_f32(a); 7693 } 7694 7695 // CHECK: test_vreinterpretq_s8_p8 7696 int8x16_t test_vreinterpretq_s8_p8(poly8x16_t a) { 7697 return vreinterpretq_s8_p8(a); 7698 } 7699 7700 // CHECK: test_vreinterpretq_s8_p16 7701 int8x16_t test_vreinterpretq_s8_p16(poly16x8_t a) { 7702 return vreinterpretq_s8_p16(a); 7703 } 7704 7705 // CHECK: test_vreinterpretq_s16_s8 7706 int16x8_t test_vreinterpretq_s16_s8(int8x16_t a) { 7707 return vreinterpretq_s16_s8(a); 7708 } 7709 7710 // CHECK: test_vreinterpretq_s16_s32 7711 int16x8_t test_vreinterpretq_s16_s32(int32x4_t a) { 7712 return vreinterpretq_s16_s32(a); 7713 } 7714 7715 // CHECK: test_vreinterpretq_s16_s64 7716 int16x8_t test_vreinterpretq_s16_s64(int64x2_t a) { 7717 return vreinterpretq_s16_s64(a); 7718 } 7719 7720 // CHECK: test_vreinterpretq_s16_u8 7721 int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a) { 7722 return vreinterpretq_s16_u8(a); 7723 } 7724 7725 // CHECK: test_vreinterpretq_s16_u16 7726 int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a) { 7727 return vreinterpretq_s16_u16(a); 7728 } 7729 7730 // CHECK: test_vreinterpretq_s16_u32 7731 int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a) { 7732 return vreinterpretq_s16_u32(a); 7733 } 7734 7735 // CHECK: test_vreinterpretq_s16_u64 7736 int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a) { 7737 return vreinterpretq_s16_u64(a); 7738 } 7739 7740 // CHECK: test_vreinterpretq_s16_f16 7741 int16x8_t test_vreinterpretq_s16_f16(float16x8_t a) { 7742 return vreinterpretq_s16_f16(a); 7743 } 7744 7745 // CHECK: test_vreinterpretq_s16_f32 7746 int16x8_t test_vreinterpretq_s16_f32(float32x4_t a) { 7747 return vreinterpretq_s16_f32(a); 7748 } 7749 7750 // CHECK: test_vreinterpretq_s16_p8 7751 int16x8_t test_vreinterpretq_s16_p8(poly8x16_t a) { 7752 return vreinterpretq_s16_p8(a); 7753 } 7754 7755 // CHECK: test_vreinterpretq_s16_p16 7756 int16x8_t test_vreinterpretq_s16_p16(poly16x8_t a) { 7757 return vreinterpretq_s16_p16(a); 7758 } 7759 7760 // CHECK: test_vreinterpretq_s32_s8 7761 int32x4_t test_vreinterpretq_s32_s8(int8x16_t a) { 7762 return vreinterpretq_s32_s8(a); 7763 } 7764 7765 // CHECK: test_vreinterpretq_s32_s16 7766 int32x4_t test_vreinterpretq_s32_s16(int16x8_t a) { 7767 return vreinterpretq_s32_s16(a); 7768 } 7769 7770 // CHECK: test_vreinterpretq_s32_s64 7771 int32x4_t test_vreinterpretq_s32_s64(int64x2_t a) { 7772 return vreinterpretq_s32_s64(a); 7773 } 7774 7775 // CHECK: test_vreinterpretq_s32_u8 7776 int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a) { 7777 return vreinterpretq_s32_u8(a); 7778 } 7779 7780 // CHECK: test_vreinterpretq_s32_u16 7781 int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a) { 7782 return vreinterpretq_s32_u16(a); 7783 } 7784 7785 // CHECK: test_vreinterpretq_s32_u32 7786 int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a) { 7787 return vreinterpretq_s32_u32(a); 7788 } 7789 7790 // CHECK: test_vreinterpretq_s32_u64 7791 int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a) { 7792 return vreinterpretq_s32_u64(a); 7793 } 7794 7795 // CHECK: test_vreinterpretq_s32_f16 7796 int32x4_t test_vreinterpretq_s32_f16(float16x8_t a) { 7797 return vreinterpretq_s32_f16(a); 7798 } 7799 7800 // CHECK: test_vreinterpretq_s32_f32 7801 int32x4_t test_vreinterpretq_s32_f32(float32x4_t a) { 7802 return vreinterpretq_s32_f32(a); 7803 } 7804 7805 // CHECK: test_vreinterpretq_s32_p8 7806 int32x4_t test_vreinterpretq_s32_p8(poly8x16_t a) { 7807 return vreinterpretq_s32_p8(a); 7808 } 7809 7810 // CHECK: test_vreinterpretq_s32_p16 7811 int32x4_t test_vreinterpretq_s32_p16(poly16x8_t a) { 7812 return vreinterpretq_s32_p16(a); 7813 } 7814 7815 // CHECK: test_vreinterpretq_s64_s8 7816 int64x2_t test_vreinterpretq_s64_s8(int8x16_t a) { 7817 return vreinterpretq_s64_s8(a); 7818 } 7819 7820 // CHECK: test_vreinterpretq_s64_s16 7821 int64x2_t test_vreinterpretq_s64_s16(int16x8_t a) { 7822 return vreinterpretq_s64_s16(a); 7823 } 7824 7825 // CHECK: test_vreinterpretq_s64_s32 7826 int64x2_t test_vreinterpretq_s64_s32(int32x4_t a) { 7827 return vreinterpretq_s64_s32(a); 7828 } 7829 7830 // CHECK: test_vreinterpretq_s64_u8 7831 int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a) { 7832 return vreinterpretq_s64_u8(a); 7833 } 7834 7835 // CHECK: test_vreinterpretq_s64_u16 7836 int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a) { 7837 return vreinterpretq_s64_u16(a); 7838 } 7839 7840 // CHECK: test_vreinterpretq_s64_u32 7841 int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a) { 7842 return vreinterpretq_s64_u32(a); 7843 } 7844 7845 // CHECK: test_vreinterpretq_s64_u64 7846 int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a) { 7847 return vreinterpretq_s64_u64(a); 7848 } 7849 7850 // CHECK: test_vreinterpretq_s64_f16 7851 int64x2_t test_vreinterpretq_s64_f16(float16x8_t a) { 7852 return vreinterpretq_s64_f16(a); 7853 } 7854 7855 // CHECK: test_vreinterpretq_s64_f32 7856 int64x2_t test_vreinterpretq_s64_f32(float32x4_t a) { 7857 return vreinterpretq_s64_f32(a); 7858 } 7859 7860 // CHECK: test_vreinterpretq_s64_p8 7861 int64x2_t test_vreinterpretq_s64_p8(poly8x16_t a) { 7862 return vreinterpretq_s64_p8(a); 7863 } 7864 7865 // CHECK: test_vreinterpretq_s64_p16 7866 int64x2_t test_vreinterpretq_s64_p16(poly16x8_t a) { 7867 return vreinterpretq_s64_p16(a); 7868 } 7869 7870 // CHECK: test_vreinterpretq_u8_s8 7871 uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a) { 7872 return vreinterpretq_u8_s8(a); 7873 } 7874 7875 // CHECK: test_vreinterpretq_u8_s16 7876 uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a) { 7877 return vreinterpretq_u8_s16(a); 7878 } 7879 7880 // CHECK: test_vreinterpretq_u8_s32 7881 uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a) { 7882 return vreinterpretq_u8_s32(a); 7883 } 7884 7885 // CHECK: test_vreinterpretq_u8_s64 7886 uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a) { 7887 return vreinterpretq_u8_s64(a); 7888 } 7889 7890 // CHECK: test_vreinterpretq_u8_u16 7891 uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a) { 7892 return vreinterpretq_u8_u16(a); 7893 } 7894 7895 // CHECK: test_vreinterpretq_u8_u32 7896 uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a) { 7897 return vreinterpretq_u8_u32(a); 7898 } 7899 7900 // CHECK: test_vreinterpretq_u8_u64 7901 uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a) { 7902 return vreinterpretq_u8_u64(a); 7903 } 7904 7905 // CHECK: test_vreinterpretq_u8_f16 7906 uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a) { 7907 return vreinterpretq_u8_f16(a); 7908 } 7909 7910 // CHECK: test_vreinterpretq_u8_f32 7911 uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a) { 7912 return vreinterpretq_u8_f32(a); 7913 } 7914 7915 // CHECK: test_vreinterpretq_u8_p8 7916 uint8x16_t test_vreinterpretq_u8_p8(poly8x16_t a) { 7917 return vreinterpretq_u8_p8(a); 7918 } 7919 7920 // CHECK: test_vreinterpretq_u8_p16 7921 uint8x16_t test_vreinterpretq_u8_p16(poly16x8_t a) { 7922 return vreinterpretq_u8_p16(a); 7923 } 7924 7925 // CHECK: test_vreinterpretq_u16_s8 7926 uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a) { 7927 return vreinterpretq_u16_s8(a); 7928 } 7929 7930 // CHECK: test_vreinterpretq_u16_s16 7931 uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a) { 7932 return vreinterpretq_u16_s16(a); 7933 } 7934 7935 // CHECK: test_vreinterpretq_u16_s32 7936 uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a) { 7937 return vreinterpretq_u16_s32(a); 7938 } 7939 7940 // CHECK: test_vreinterpretq_u16_s64 7941 uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a) { 7942 return vreinterpretq_u16_s64(a); 7943 } 7944 7945 // CHECK: test_vreinterpretq_u16_u8 7946 uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a) { 7947 return vreinterpretq_u16_u8(a); 7948 } 7949 7950 // CHECK: test_vreinterpretq_u16_u32 7951 uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a) { 7952 return vreinterpretq_u16_u32(a); 7953 } 7954 7955 // CHECK: test_vreinterpretq_u16_u64 7956 uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a) { 7957 return vreinterpretq_u16_u64(a); 7958 } 7959 7960 // CHECK: test_vreinterpretq_u16_f16 7961 uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a) { 7962 return vreinterpretq_u16_f16(a); 7963 } 7964 7965 // CHECK: test_vreinterpretq_u16_f32 7966 uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a) { 7967 return vreinterpretq_u16_f32(a); 7968 } 7969 7970 // CHECK: test_vreinterpretq_u16_p8 7971 uint16x8_t test_vreinterpretq_u16_p8(poly8x16_t a) { 7972 return vreinterpretq_u16_p8(a); 7973 } 7974 7975 // CHECK: test_vreinterpretq_u16_p16 7976 uint16x8_t test_vreinterpretq_u16_p16(poly16x8_t a) { 7977 return vreinterpretq_u16_p16(a); 7978 } 7979 7980 // CHECK: test_vreinterpretq_u32_s8 7981 uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a) { 7982 return vreinterpretq_u32_s8(a); 7983 } 7984 7985 // CHECK: test_vreinterpretq_u32_s16 7986 uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a) { 7987 return vreinterpretq_u32_s16(a); 7988 } 7989 7990 // CHECK: test_vreinterpretq_u32_s32 7991 uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a) { 7992 return vreinterpretq_u32_s32(a); 7993 } 7994 7995 // CHECK: test_vreinterpretq_u32_s64 7996 uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a) { 7997 return vreinterpretq_u32_s64(a); 7998 } 7999 8000 // CHECK: test_vreinterpretq_u32_u8 8001 uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a) { 8002 return vreinterpretq_u32_u8(a); 8003 } 8004 8005 // CHECK: test_vreinterpretq_u32_u16 8006 uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a) { 8007 return vreinterpretq_u32_u16(a); 8008 } 8009 8010 // CHECK: test_vreinterpretq_u32_u64 8011 uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a) { 8012 return vreinterpretq_u32_u64(a); 8013 } 8014 8015 // CHECK: test_vreinterpretq_u32_f16 8016 uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a) { 8017 return vreinterpretq_u32_f16(a); 8018 } 8019 8020 // CHECK: test_vreinterpretq_u32_f32 8021 uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a) { 8022 return vreinterpretq_u32_f32(a); 8023 } 8024 8025 // CHECK: test_vreinterpretq_u32_p8 8026 uint32x4_t test_vreinterpretq_u32_p8(poly8x16_t a) { 8027 return vreinterpretq_u32_p8(a); 8028 } 8029 8030 // CHECK: test_vreinterpretq_u32_p16 8031 uint32x4_t test_vreinterpretq_u32_p16(poly16x8_t a) { 8032 return vreinterpretq_u32_p16(a); 8033 } 8034 8035 // CHECK: test_vreinterpretq_u64_s8 8036 uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a) { 8037 return vreinterpretq_u64_s8(a); 8038 } 8039 8040 // CHECK: test_vreinterpretq_u64_s16 8041 uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a) { 8042 return vreinterpretq_u64_s16(a); 8043 } 8044 8045 // CHECK: test_vreinterpretq_u64_s32 8046 uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a) { 8047 return vreinterpretq_u64_s32(a); 8048 } 8049 8050 // CHECK: test_vreinterpretq_u64_s64 8051 uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a) { 8052 return vreinterpretq_u64_s64(a); 8053 } 8054 8055 // CHECK: test_vreinterpretq_u64_u8 8056 uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a) { 8057 return vreinterpretq_u64_u8(a); 8058 } 8059 8060 // CHECK: test_vreinterpretq_u64_u16 8061 uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a) { 8062 return vreinterpretq_u64_u16(a); 8063 } 8064 8065 // CHECK: test_vreinterpretq_u64_u32 8066 uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a) { 8067 return vreinterpretq_u64_u32(a); 8068 } 8069 8070 // CHECK: test_vreinterpretq_u64_f16 8071 uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a) { 8072 return vreinterpretq_u64_f16(a); 8073 } 8074 8075 // CHECK: test_vreinterpretq_u64_f32 8076 uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a) { 8077 return vreinterpretq_u64_f32(a); 8078 } 8079 8080 // CHECK: test_vreinterpretq_u64_p8 8081 uint64x2_t test_vreinterpretq_u64_p8(poly8x16_t a) { 8082 return vreinterpretq_u64_p8(a); 8083 } 8084 8085 // CHECK: test_vreinterpretq_u64_p16 8086 uint64x2_t test_vreinterpretq_u64_p16(poly16x8_t a) { 8087 return vreinterpretq_u64_p16(a); 8088 } 8089 8090 // CHECK: test_vreinterpretq_f16_s8 8091 float16x8_t test_vreinterpretq_f16_s8(int8x16_t a) { 8092 return vreinterpretq_f16_s8(a); 8093 } 8094 8095 // CHECK: test_vreinterpretq_f16_s16 8096 float16x8_t test_vreinterpretq_f16_s16(int16x8_t a) { 8097 return vreinterpretq_f16_s16(a); 8098 } 8099 8100 // CHECK: test_vreinterpretq_f16_s32 8101 float16x8_t test_vreinterpretq_f16_s32(int32x4_t a) { 8102 return vreinterpretq_f16_s32(a); 8103 } 8104 8105 // CHECK: test_vreinterpretq_f16_s64 8106 float16x8_t test_vreinterpretq_f16_s64(int64x2_t a) { 8107 return vreinterpretq_f16_s64(a); 8108 } 8109 8110 // CHECK: test_vreinterpretq_f16_u8 8111 float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a) { 8112 return vreinterpretq_f16_u8(a); 8113 } 8114 8115 // CHECK: test_vreinterpretq_f16_u16 8116 float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a) { 8117 return vreinterpretq_f16_u16(a); 8118 } 8119 8120 // CHECK: test_vreinterpretq_f16_u32 8121 float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a) { 8122 return vreinterpretq_f16_u32(a); 8123 } 8124 8125 // CHECK: test_vreinterpretq_f16_u64 8126 float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a) { 8127 return vreinterpretq_f16_u64(a); 8128 } 8129 8130 // CHECK: test_vreinterpretq_f16_f32 8131 float16x8_t test_vreinterpretq_f16_f32(float32x4_t a) { 8132 return vreinterpretq_f16_f32(a); 8133 } 8134 8135 // CHECK: test_vreinterpretq_f16_p8 8136 float16x8_t test_vreinterpretq_f16_p8(poly8x16_t a) { 8137 return vreinterpretq_f16_p8(a); 8138 } 8139 8140 // CHECK: test_vreinterpretq_f16_p16 8141 float16x8_t test_vreinterpretq_f16_p16(poly16x8_t a) { 8142 return vreinterpretq_f16_p16(a); 8143 } 8144 8145 // CHECK: test_vreinterpretq_f32_s8 8146 float32x4_t test_vreinterpretq_f32_s8(int8x16_t a) { 8147 return vreinterpretq_f32_s8(a); 8148 } 8149 8150 // CHECK: test_vreinterpretq_f32_s16 8151 float32x4_t test_vreinterpretq_f32_s16(int16x8_t a) { 8152 return vreinterpretq_f32_s16(a); 8153 } 8154 8155 // CHECK: test_vreinterpretq_f32_s32 8156 float32x4_t test_vreinterpretq_f32_s32(int32x4_t a) { 8157 return vreinterpretq_f32_s32(a); 8158 } 8159 8160 // CHECK: test_vreinterpretq_f32_s64 8161 float32x4_t test_vreinterpretq_f32_s64(int64x2_t a) { 8162 return vreinterpretq_f32_s64(a); 8163 } 8164 8165 // CHECK: test_vreinterpretq_f32_u8 8166 float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a) { 8167 return vreinterpretq_f32_u8(a); 8168 } 8169 8170 // CHECK: test_vreinterpretq_f32_u16 8171 float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a) { 8172 return vreinterpretq_f32_u16(a); 8173 } 8174 8175 // CHECK: test_vreinterpretq_f32_u32 8176 float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a) { 8177 return vreinterpretq_f32_u32(a); 8178 } 8179 8180 // CHECK: test_vreinterpretq_f32_u64 8181 float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a) { 8182 return vreinterpretq_f32_u64(a); 8183 } 8184 8185 // CHECK: test_vreinterpretq_f32_f16 8186 float32x4_t test_vreinterpretq_f32_f16(float16x8_t a) { 8187 return vreinterpretq_f32_f16(a); 8188 } 8189 8190 // CHECK: test_vreinterpretq_f32_p8 8191 float32x4_t test_vreinterpretq_f32_p8(poly8x16_t a) { 8192 return vreinterpretq_f32_p8(a); 8193 } 8194 8195 // CHECK: test_vreinterpretq_f32_p16 8196 float32x4_t test_vreinterpretq_f32_p16(poly16x8_t a) { 8197 return vreinterpretq_f32_p16(a); 8198 } 8199 8200 // CHECK: test_vreinterpretq_p8_s8 8201 poly8x16_t test_vreinterpretq_p8_s8(int8x16_t a) { 8202 return vreinterpretq_p8_s8(a); 8203 } 8204 8205 // CHECK: test_vreinterpretq_p8_s16 8206 poly8x16_t test_vreinterpretq_p8_s16(int16x8_t a) { 8207 return vreinterpretq_p8_s16(a); 8208 } 8209 8210 // CHECK: test_vreinterpretq_p8_s32 8211 poly8x16_t test_vreinterpretq_p8_s32(int32x4_t a) { 8212 return vreinterpretq_p8_s32(a); 8213 } 8214 8215 // CHECK: test_vreinterpretq_p8_s64 8216 poly8x16_t test_vreinterpretq_p8_s64(int64x2_t a) { 8217 return vreinterpretq_p8_s64(a); 8218 } 8219 8220 // CHECK: test_vreinterpretq_p8_u8 8221 poly8x16_t test_vreinterpretq_p8_u8(uint8x16_t a) { 8222 return vreinterpretq_p8_u8(a); 8223 } 8224 8225 // CHECK: test_vreinterpretq_p8_u16 8226 poly8x16_t test_vreinterpretq_p8_u16(uint16x8_t a) { 8227 return vreinterpretq_p8_u16(a); 8228 } 8229 8230 // CHECK: test_vreinterpretq_p8_u32 8231 poly8x16_t test_vreinterpretq_p8_u32(uint32x4_t a) { 8232 return vreinterpretq_p8_u32(a); 8233 } 8234 8235 // CHECK: test_vreinterpretq_p8_u64 8236 poly8x16_t test_vreinterpretq_p8_u64(uint64x2_t a) { 8237 return vreinterpretq_p8_u64(a); 8238 } 8239 8240 // CHECK: test_vreinterpretq_p8_f16 8241 poly8x16_t test_vreinterpretq_p8_f16(float16x8_t a) { 8242 return vreinterpretq_p8_f16(a); 8243 } 8244 8245 // CHECK: test_vreinterpretq_p8_f32 8246 poly8x16_t test_vreinterpretq_p8_f32(float32x4_t a) { 8247 return vreinterpretq_p8_f32(a); 8248 } 8249 8250 // CHECK: test_vreinterpretq_p8_p16 8251 poly8x16_t test_vreinterpretq_p8_p16(poly16x8_t a) { 8252 return vreinterpretq_p8_p16(a); 8253 } 8254 8255 // CHECK: test_vreinterpretq_p16_s8 8256 poly16x8_t test_vreinterpretq_p16_s8(int8x16_t a) { 8257 return vreinterpretq_p16_s8(a); 8258 } 8259 8260 // CHECK: test_vreinterpretq_p16_s16 8261 poly16x8_t test_vreinterpretq_p16_s16(int16x8_t a) { 8262 return vreinterpretq_p16_s16(a); 8263 } 8264 8265 // CHECK: test_vreinterpretq_p16_s32 8266 poly16x8_t test_vreinterpretq_p16_s32(int32x4_t a) { 8267 return vreinterpretq_p16_s32(a); 8268 } 8269 8270 // CHECK: test_vreinterpretq_p16_s64 8271 poly16x8_t test_vreinterpretq_p16_s64(int64x2_t a) { 8272 return vreinterpretq_p16_s64(a); 8273 } 8274 8275 // CHECK: test_vreinterpretq_p16_u8 8276 poly16x8_t test_vreinterpretq_p16_u8(uint8x16_t a) { 8277 return vreinterpretq_p16_u8(a); 8278 } 8279 8280 // CHECK: test_vreinterpretq_p16_u16 8281 poly16x8_t test_vreinterpretq_p16_u16(uint16x8_t a) { 8282 return vreinterpretq_p16_u16(a); 8283 } 8284 8285 // CHECK: test_vreinterpretq_p16_u32 8286 poly16x8_t test_vreinterpretq_p16_u32(uint32x4_t a) { 8287 return vreinterpretq_p16_u32(a); 8288 } 8289 8290 // CHECK: test_vreinterpretq_p16_u64 8291 poly16x8_t test_vreinterpretq_p16_u64(uint64x2_t a) { 8292 return vreinterpretq_p16_u64(a); 8293 } 8294 8295 // CHECK: test_vreinterpretq_p16_f16 8296 poly16x8_t test_vreinterpretq_p16_f16(float16x8_t a) { 8297 return vreinterpretq_p16_f16(a); 8298 } 8299 8300 // CHECK: test_vreinterpretq_p16_f32 8301 poly16x8_t test_vreinterpretq_p16_f32(float32x4_t a) { 8302 return vreinterpretq_p16_f32(a); 8303 } 8304 8305 // CHECK: test_vreinterpretq_p16_p8 8306 poly16x8_t test_vreinterpretq_p16_p8(poly8x16_t a) { 8307 return vreinterpretq_p16_p8(a); 8308 } 8309 8310 8311 // CHECK: test_vrev16_s8 8312 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8313 int8x8_t test_vrev16_s8(int8x8_t a) { 8314 return vrev16_s8(a); 8315 } 8316 8317 // CHECK: test_vrev16_u8 8318 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8319 uint8x8_t test_vrev16_u8(uint8x8_t a) { 8320 return vrev16_u8(a); 8321 } 8322 8323 // CHECK: test_vrev16_p8 8324 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8325 poly8x8_t test_vrev16_p8(poly8x8_t a) { 8326 return vrev16_p8(a); 8327 } 8328 8329 // CHECK: test_vrev16q_s8 8330 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8331 int8x16_t test_vrev16q_s8(int8x16_t a) { 8332 return vrev16q_s8(a); 8333 } 8334 8335 // CHECK: test_vrev16q_u8 8336 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8337 uint8x16_t test_vrev16q_u8(uint8x16_t a) { 8338 return vrev16q_u8(a); 8339 } 8340 8341 // CHECK: test_vrev16q_p8 8342 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8343 poly8x16_t test_vrev16q_p8(poly8x16_t a) { 8344 return vrev16q_p8(a); 8345 } 8346 8347 8348 // CHECK: test_vrev32_s8 8349 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8350 int8x8_t test_vrev32_s8(int8x8_t a) { 8351 return vrev32_s8(a); 8352 } 8353 8354 // CHECK: test_vrev32_s16 8355 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8356 int16x4_t test_vrev32_s16(int16x4_t a) { 8357 return vrev32_s16(a); 8358 } 8359 8360 // CHECK: test_vrev32_u8 8361 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8362 uint8x8_t test_vrev32_u8(uint8x8_t a) { 8363 return vrev32_u8(a); 8364 } 8365 8366 // CHECK: test_vrev32_u16 8367 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8368 uint16x4_t test_vrev32_u16(uint16x4_t a) { 8369 return vrev32_u16(a); 8370 } 8371 8372 // CHECK: test_vrev32_p8 8373 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8374 poly8x8_t test_vrev32_p8(poly8x8_t a) { 8375 return vrev32_p8(a); 8376 } 8377 8378 // CHECK: test_vrev32_p16 8379 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8380 poly16x4_t test_vrev32_p16(poly16x4_t a) { 8381 return vrev32_p16(a); 8382 } 8383 8384 // CHECK: test_vrev32q_s8 8385 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8386 int8x16_t test_vrev32q_s8(int8x16_t a) { 8387 return vrev32q_s8(a); 8388 } 8389 8390 // CHECK: test_vrev32q_s16 8391 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8392 int16x8_t test_vrev32q_s16(int16x8_t a) { 8393 return vrev32q_s16(a); 8394 } 8395 8396 // CHECK: test_vrev32q_u8 8397 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8398 uint8x16_t test_vrev32q_u8(uint8x16_t a) { 8399 return vrev32q_u8(a); 8400 } 8401 8402 // CHECK: test_vrev32q_u16 8403 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8404 uint16x8_t test_vrev32q_u16(uint16x8_t a) { 8405 return vrev32q_u16(a); 8406 } 8407 8408 // CHECK: test_vrev32q_p8 8409 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8410 poly8x16_t test_vrev32q_p8(poly8x16_t a) { 8411 return vrev32q_p8(a); 8412 } 8413 8414 // CHECK: test_vrev32q_p16 8415 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8416 poly16x8_t test_vrev32q_p16(poly16x8_t a) { 8417 return vrev32q_p16(a); 8418 } 8419 8420 8421 // CHECK: test_vrev64_s8 8422 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8423 int8x8_t test_vrev64_s8(int8x8_t a) { 8424 return vrev64_s8(a); 8425 } 8426 8427 // CHECK: test_vrev64_s16 8428 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8429 int16x4_t test_vrev64_s16(int16x4_t a) { 8430 return vrev64_s16(a); 8431 } 8432 8433 // CHECK: test_vrev64_s32 8434 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8435 int32x2_t test_vrev64_s32(int32x2_t a) { 8436 return vrev64_s32(a); 8437 } 8438 8439 // CHECK: test_vrev64_u8 8440 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8441 uint8x8_t test_vrev64_u8(uint8x8_t a) { 8442 return vrev64_u8(a); 8443 } 8444 8445 // CHECK: test_vrev64_u16 8446 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8447 uint16x4_t test_vrev64_u16(uint16x4_t a) { 8448 return vrev64_u16(a); 8449 } 8450 8451 // CHECK: test_vrev64_u32 8452 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8453 uint32x2_t test_vrev64_u32(uint32x2_t a) { 8454 return vrev64_u32(a); 8455 } 8456 8457 // CHECK: test_vrev64_p8 8458 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8459 poly8x8_t test_vrev64_p8(poly8x8_t a) { 8460 return vrev64_p8(a); 8461 } 8462 8463 // CHECK: test_vrev64_p16 8464 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8465 poly16x4_t test_vrev64_p16(poly16x4_t a) { 8466 return vrev64_p16(a); 8467 } 8468 8469 // CHECK: test_vrev64_f32 8470 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8471 float32x2_t test_vrev64_f32(float32x2_t a) { 8472 return vrev64_f32(a); 8473 } 8474 8475 // CHECK: test_vrev64q_s8 8476 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8477 int8x16_t test_vrev64q_s8(int8x16_t a) { 8478 return vrev64q_s8(a); 8479 } 8480 8481 // CHECK: test_vrev64q_s16 8482 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8483 int16x8_t test_vrev64q_s16(int16x8_t a) { 8484 return vrev64q_s16(a); 8485 } 8486 8487 // CHECK: test_vrev64q_s32 8488 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8489 int32x4_t test_vrev64q_s32(int32x4_t a) { 8490 return vrev64q_s32(a); 8491 } 8492 8493 // CHECK: test_vrev64q_u8 8494 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8495 uint8x16_t test_vrev64q_u8(uint8x16_t a) { 8496 return vrev64q_u8(a); 8497 } 8498 8499 // CHECK: test_vrev64q_u16 8500 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8501 uint16x8_t test_vrev64q_u16(uint16x8_t a) { 8502 return vrev64q_u16(a); 8503 } 8504 8505 // CHECK: test_vrev64q_u32 8506 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8507 uint32x4_t test_vrev64q_u32(uint32x4_t a) { 8508 return vrev64q_u32(a); 8509 } 8510 8511 // CHECK: test_vrev64q_p8 8512 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8513 poly8x16_t test_vrev64q_p8(poly8x16_t a) { 8514 return vrev64q_p8(a); 8515 } 8516 8517 // CHECK: test_vrev64q_p16 8518 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8519 poly16x8_t test_vrev64q_p16(poly16x8_t a) { 8520 return vrev64q_p16(a); 8521 } 8522 8523 // CHECK: test_vrev64q_f32 8524 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8525 float32x4_t test_vrev64q_f32(float32x4_t a) { 8526 return vrev64q_f32(a); 8527 } 8528 8529 8530 // CHECK: test_vrhadd_s8 8531 // CHECK: vrhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8532 int8x8_t test_vrhadd_s8(int8x8_t a, int8x8_t b) { 8533 return vrhadd_s8(a, b); 8534 } 8535 8536 // CHECK: test_vrhadd_s16 8537 // CHECK: vrhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8538 int16x4_t test_vrhadd_s16(int16x4_t a, int16x4_t b) { 8539 return vrhadd_s16(a, b); 8540 } 8541 8542 // CHECK: test_vrhadd_s32 8543 // CHECK: vrhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8544 int32x2_t test_vrhadd_s32(int32x2_t a, int32x2_t b) { 8545 return vrhadd_s32(a, b); 8546 } 8547 8548 // CHECK: test_vrhadd_u8 8549 // CHECK: vrhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8550 uint8x8_t test_vrhadd_u8(uint8x8_t a, uint8x8_t b) { 8551 return vrhadd_u8(a, b); 8552 } 8553 8554 // CHECK: test_vrhadd_u16 8555 // CHECK: vrhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8556 uint16x4_t test_vrhadd_u16(uint16x4_t a, uint16x4_t b) { 8557 return vrhadd_u16(a, b); 8558 } 8559 8560 // CHECK: test_vrhadd_u32 8561 // CHECK: vrhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8562 uint32x2_t test_vrhadd_u32(uint32x2_t a, uint32x2_t b) { 8563 return vrhadd_u32(a, b); 8564 } 8565 8566 // CHECK: test_vrhaddq_s8 8567 // CHECK: vrhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8568 int8x16_t test_vrhaddq_s8(int8x16_t a, int8x16_t b) { 8569 return vrhaddq_s8(a, b); 8570 } 8571 8572 // CHECK: test_vrhaddq_s16 8573 // CHECK: vrhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8574 int16x8_t test_vrhaddq_s16(int16x8_t a, int16x8_t b) { 8575 return vrhaddq_s16(a, b); 8576 } 8577 8578 // CHECK: test_vrhaddq_s32 8579 // CHECK: vrhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8580 int32x4_t test_vrhaddq_s32(int32x4_t a, int32x4_t b) { 8581 return vrhaddq_s32(a, b); 8582 } 8583 8584 // CHECK: test_vrhaddq_u8 8585 // CHECK: vrhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8586 uint8x16_t test_vrhaddq_u8(uint8x16_t a, uint8x16_t b) { 8587 return vrhaddq_u8(a, b); 8588 } 8589 8590 // CHECK: test_vrhaddq_u16 8591 // CHECK: vrhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8592 uint16x8_t test_vrhaddq_u16(uint16x8_t a, uint16x8_t b) { 8593 return vrhaddq_u16(a, b); 8594 } 8595 8596 // CHECK: test_vrhaddq_u32 8597 // CHECK: vrhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8598 uint32x4_t test_vrhaddq_u32(uint32x4_t a, uint32x4_t b) { 8599 return vrhaddq_u32(a, b); 8600 } 8601 8602 8603 // CHECK: test_vrshl_s8 8604 // CHECK: vrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8605 int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) { 8606 return vrshl_s8(a, b); 8607 } 8608 8609 // CHECK: test_vrshl_s16 8610 // CHECK: vrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8611 int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) { 8612 return vrshl_s16(a, b); 8613 } 8614 8615 // CHECK: test_vrshl_s32 8616 // CHECK: vrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8617 int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) { 8618 return vrshl_s32(a, b); 8619 } 8620 8621 // CHECK: test_vrshl_s64 8622 // CHECK: vrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8623 int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) { 8624 return vrshl_s64(a, b); 8625 } 8626 8627 // CHECK: test_vrshl_u8 8628 // CHECK: vrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8629 uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) { 8630 return vrshl_u8(a, b); 8631 } 8632 8633 // CHECK: test_vrshl_u16 8634 // CHECK: vrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8635 uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) { 8636 return vrshl_u16(a, b); 8637 } 8638 8639 // CHECK: test_vrshl_u32 8640 // CHECK: vrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8641 uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) { 8642 return vrshl_u32(a, b); 8643 } 8644 8645 // CHECK: test_vrshl_u64 8646 // CHECK: vrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8647 uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) { 8648 return vrshl_u64(a, b); 8649 } 8650 8651 // CHECK: test_vrshlq_s8 8652 // CHECK: vrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8653 int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) { 8654 return vrshlq_s8(a, b); 8655 } 8656 8657 // CHECK: test_vrshlq_s16 8658 // CHECK: vrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8659 int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) { 8660 return vrshlq_s16(a, b); 8661 } 8662 8663 // CHECK: test_vrshlq_s32 8664 // CHECK: vrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8665 int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) { 8666 return vrshlq_s32(a, b); 8667 } 8668 8669 // CHECK: test_vrshlq_s64 8670 // CHECK: vrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8671 int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) { 8672 return vrshlq_s64(a, b); 8673 } 8674 8675 // CHECK: test_vrshlq_u8 8676 // CHECK: vrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8677 uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) { 8678 return vrshlq_u8(a, b); 8679 } 8680 8681 // CHECK: test_vrshlq_u16 8682 // CHECK: vrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8683 uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) { 8684 return vrshlq_u16(a, b); 8685 } 8686 8687 // CHECK: test_vrshlq_u32 8688 // CHECK: vrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8689 uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) { 8690 return vrshlq_u32(a, b); 8691 } 8692 8693 // CHECK: test_vrshlq_u64 8694 // CHECK: vrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8695 uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) { 8696 return vrshlq_u64(a, b); 8697 } 8698 8699 8700 // CHECK: test_vrshrn_n_s16 8701 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8702 int8x8_t test_vrshrn_n_s16(int16x8_t a) { 8703 return vrshrn_n_s16(a, 1); 8704 } 8705 8706 // CHECK: test_vrshrn_n_s32 8707 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8708 int16x4_t test_vrshrn_n_s32(int32x4_t a) { 8709 return vrshrn_n_s32(a, 1); 8710 } 8711 8712 // CHECK: test_vrshrn_n_s64 8713 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8714 int32x2_t test_vrshrn_n_s64(int64x2_t a) { 8715 return vrshrn_n_s64(a, 1); 8716 } 8717 8718 // CHECK: test_vrshrn_n_u16 8719 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8720 uint8x8_t test_vrshrn_n_u16(uint16x8_t a) { 8721 return vrshrn_n_u16(a, 1); 8722 } 8723 8724 // CHECK: test_vrshrn_n_u32 8725 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8726 uint16x4_t test_vrshrn_n_u32(uint32x4_t a) { 8727 return vrshrn_n_u32(a, 1); 8728 } 8729 8730 // CHECK: test_vrshrn_n_u64 8731 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8732 uint32x2_t test_vrshrn_n_u64(uint64x2_t a) { 8733 return vrshrn_n_u64(a, 1); 8734 } 8735 8736 8737 // CHECK: test_vrshr_n_s8 8738 // CHECK: vrshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8739 int8x8_t test_vrshr_n_s8(int8x8_t a) { 8740 return vrshr_n_s8(a, 1); 8741 } 8742 8743 // CHECK: test_vrshr_n_s16 8744 // CHECK: vrshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8745 int16x4_t test_vrshr_n_s16(int16x4_t a) { 8746 return vrshr_n_s16(a, 1); 8747 } 8748 8749 // CHECK: test_vrshr_n_s32 8750 // CHECK: vrshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8751 int32x2_t test_vrshr_n_s32(int32x2_t a) { 8752 return vrshr_n_s32(a, 1); 8753 } 8754 8755 // CHECK: test_vrshr_n_s64 8756 // CHECK: vrshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8757 int64x1_t test_vrshr_n_s64(int64x1_t a) { 8758 return vrshr_n_s64(a, 1); 8759 } 8760 8761 // CHECK: test_vrshr_n_u8 8762 // CHECK: vrshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8763 uint8x8_t test_vrshr_n_u8(uint8x8_t a) { 8764 return vrshr_n_u8(a, 1); 8765 } 8766 8767 // CHECK: test_vrshr_n_u16 8768 // CHECK: vrshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8769 uint16x4_t test_vrshr_n_u16(uint16x4_t a) { 8770 return vrshr_n_u16(a, 1); 8771 } 8772 8773 // CHECK: test_vrshr_n_u32 8774 // CHECK: vrshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8775 uint32x2_t test_vrshr_n_u32(uint32x2_t a) { 8776 return vrshr_n_u32(a, 1); 8777 } 8778 8779 // CHECK: test_vrshr_n_u64 8780 // CHECK: vrshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8781 uint64x1_t test_vrshr_n_u64(uint64x1_t a) { 8782 return vrshr_n_u64(a, 1); 8783 } 8784 8785 // CHECK: test_vrshrq_n_s8 8786 // CHECK: vrshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8787 int8x16_t test_vrshrq_n_s8(int8x16_t a) { 8788 return vrshrq_n_s8(a, 1); 8789 } 8790 8791 // CHECK: test_vrshrq_n_s16 8792 // CHECK: vrshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8793 int16x8_t test_vrshrq_n_s16(int16x8_t a) { 8794 return vrshrq_n_s16(a, 1); 8795 } 8796 8797 // CHECK: test_vrshrq_n_s32 8798 // CHECK: vrshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8799 int32x4_t test_vrshrq_n_s32(int32x4_t a) { 8800 return vrshrq_n_s32(a, 1); 8801 } 8802 8803 // CHECK: test_vrshrq_n_s64 8804 // CHECK: vrshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8805 int64x2_t test_vrshrq_n_s64(int64x2_t a) { 8806 return vrshrq_n_s64(a, 1); 8807 } 8808 8809 // CHECK: test_vrshrq_n_u8 8810 // CHECK: vrshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8811 uint8x16_t test_vrshrq_n_u8(uint8x16_t a) { 8812 return vrshrq_n_u8(a, 1); 8813 } 8814 8815 // CHECK: test_vrshrq_n_u16 8816 // CHECK: vrshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8817 uint16x8_t test_vrshrq_n_u16(uint16x8_t a) { 8818 return vrshrq_n_u16(a, 1); 8819 } 8820 8821 // CHECK: test_vrshrq_n_u32 8822 // CHECK: vrshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8823 uint32x4_t test_vrshrq_n_u32(uint32x4_t a) { 8824 return vrshrq_n_u32(a, 1); 8825 } 8826 8827 // CHECK: test_vrshrq_n_u64 8828 // CHECK: vrshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8829 uint64x2_t test_vrshrq_n_u64(uint64x2_t a) { 8830 return vrshrq_n_u64(a, 1); 8831 } 8832 8833 8834 // CHECK: test_vrsqrte_f32 8835 // CHECK: vrsqrte.f32 d{{[0-9]+}}, d{{[0-9]+}} 8836 float32x2_t test_vrsqrte_f32(float32x2_t a) { 8837 return vrsqrte_f32(a); 8838 } 8839 8840 // CHECK: test_vrsqrte_u32 8841 // CHECK: vrsqrte.u32 d{{[0-9]+}}, d{{[0-9]+}} 8842 uint32x2_t test_vrsqrte_u32(uint32x2_t a) { 8843 return vrsqrte_u32(a); 8844 } 8845 8846 // CHECK: test_vrsqrteq_f32 8847 // CHECK: vrsqrte.f32 q{{[0-9]+}}, q{{[0-9]+}} 8848 float32x4_t test_vrsqrteq_f32(float32x4_t a) { 8849 return vrsqrteq_f32(a); 8850 } 8851 8852 // CHECK: test_vrsqrteq_u32 8853 // CHECK: vrsqrte.u32 q{{[0-9]+}}, q{{[0-9]+}} 8854 uint32x4_t test_vrsqrteq_u32(uint32x4_t a) { 8855 return vrsqrteq_u32(a); 8856 } 8857 8858 8859 // CHECK: test_vrsqrts_f32 8860 // CHECK: vrsqrts.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8861 float32x2_t test_vrsqrts_f32(float32x2_t a, float32x2_t b) { 8862 return vrsqrts_f32(a, b); 8863 } 8864 8865 // CHECK: test_vrsqrtsq_f32 8866 // CHECK: vrsqrts.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8867 float32x4_t test_vrsqrtsq_f32(float32x4_t a, float32x4_t b) { 8868 return vrsqrtsq_f32(a, b); 8869 } 8870 8871 8872 // CHECK: test_vrsra_n_s8 8873 // CHECK: vrsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8874 int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) { 8875 return vrsra_n_s8(a, b, 1); 8876 } 8877 8878 // CHECK: test_vrsra_n_s16 8879 // CHECK: vrsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8880 int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) { 8881 return vrsra_n_s16(a, b, 1); 8882 } 8883 8884 // CHECK: test_vrsra_n_s32 8885 // CHECK: vrsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8886 int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) { 8887 return vrsra_n_s32(a, b, 1); 8888 } 8889 8890 // CHECK: test_vrsra_n_s64 8891 // CHECK: vrsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8892 int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) { 8893 return vrsra_n_s64(a, b, 1); 8894 } 8895 8896 // CHECK: test_vrsra_n_u8 8897 // CHECK: vrsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8898 uint8x8_t test_vrsra_n_u8(uint8x8_t a, uint8x8_t b) { 8899 return vrsra_n_u8(a, b, 1); 8900 } 8901 8902 // CHECK: test_vrsra_n_u16 8903 // CHECK: vrsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8904 uint16x4_t test_vrsra_n_u16(uint16x4_t a, uint16x4_t b) { 8905 return vrsra_n_u16(a, b, 1); 8906 } 8907 8908 // CHECK: test_vrsra_n_u32 8909 // CHECK: vrsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8910 uint32x2_t test_vrsra_n_u32(uint32x2_t a, uint32x2_t b) { 8911 return vrsra_n_u32(a, b, 1); 8912 } 8913 8914 // CHECK: test_vrsra_n_u64 8915 // CHECK: vrsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8916 uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) { 8917 return vrsra_n_u64(a, b, 1); 8918 } 8919 8920 // CHECK: test_vrsraq_n_s8 8921 // CHECK: vrsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8922 int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) { 8923 return vrsraq_n_s8(a, b, 1); 8924 } 8925 8926 // CHECK: test_vrsraq_n_s16 8927 // CHECK: vrsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8928 int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) { 8929 return vrsraq_n_s16(a, b, 1); 8930 } 8931 8932 // CHECK: test_vrsraq_n_s32 8933 // CHECK: vrsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8934 int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) { 8935 return vrsraq_n_s32(a, b, 1); 8936 } 8937 8938 // CHECK: test_vrsraq_n_s64 8939 // CHECK: vrsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8940 int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) { 8941 return vrsraq_n_s64(a, b, 1); 8942 } 8943 8944 // CHECK: test_vrsraq_n_u8 8945 // CHECK: vrsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8946 uint8x16_t test_vrsraq_n_u8(uint8x16_t a, uint8x16_t b) { 8947 return vrsraq_n_u8(a, b, 1); 8948 } 8949 8950 // CHECK: test_vrsraq_n_u16 8951 // CHECK: vrsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8952 uint16x8_t test_vrsraq_n_u16(uint16x8_t a, uint16x8_t b) { 8953 return vrsraq_n_u16(a, b, 1); 8954 } 8955 8956 // CHECK: test_vrsraq_n_u32 8957 // CHECK: vrsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8958 uint32x4_t test_vrsraq_n_u32(uint32x4_t a, uint32x4_t b) { 8959 return vrsraq_n_u32(a, b, 1); 8960 } 8961 8962 // CHECK: test_vrsraq_n_u64 8963 // CHECK: vrsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8964 uint64x2_t test_vrsraq_n_u64(uint64x2_t a, uint64x2_t b) { 8965 return vrsraq_n_u64(a, b, 1); 8966 } 8967 8968 8969 // CHECK: test_vrsubhn_s16 8970 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8971 int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) { 8972 return vrsubhn_s16(a, b); 8973 } 8974 8975 // CHECK: test_vrsubhn_s32 8976 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8977 int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) { 8978 return vrsubhn_s32(a, b); 8979 } 8980 8981 // CHECK: test_vrsubhn_s64 8982 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8983 int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) { 8984 return vrsubhn_s64(a, b); 8985 } 8986 8987 // CHECK: test_vrsubhn_u16 8988 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8989 uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) { 8990 return vrsubhn_u16(a, b); 8991 } 8992 8993 // CHECK: test_vrsubhn_u32 8994 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8995 uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) { 8996 return vrsubhn_u32(a, b); 8997 } 8998 8999 // CHECK: test_vrsubhn_u64 9000 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9001 uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) { 9002 return vrsubhn_u64(a, b); 9003 } 9004 9005 9006 // CHECK: test_vset_lane_u8 9007 // CHECK: vmov 9008 uint8x8_t test_vset_lane_u8(uint8_t a, uint8x8_t b) { 9009 return vset_lane_u8(a, b, 7); 9010 } 9011 9012 // CHECK: test_vset_lane_u16 9013 // CHECK: vmov 9014 uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) { 9015 return vset_lane_u16(a, b, 3); 9016 } 9017 9018 // CHECK: test_vset_lane_u32 9019 // CHECK: vmov 9020 uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) { 9021 return vset_lane_u32(a, b, 1); 9022 } 9023 9024 // CHECK: test_vset_lane_s8 9025 // CHECK: vmov 9026 int8x8_t test_vset_lane_s8(int8_t a, int8x8_t b) { 9027 return vset_lane_s8(a, b, 7); 9028 } 9029 9030 // CHECK: test_vset_lane_s16 9031 // CHECK: vmov 9032 int16x4_t test_vset_lane_s16(int16_t a, int16x4_t b) { 9033 return vset_lane_s16(a, b, 3); 9034 } 9035 9036 // CHECK: test_vset_lane_s32 9037 // CHECK: vmov 9038 int32x2_t test_vset_lane_s32(int32_t a, int32x2_t b) { 9039 return vset_lane_s32(a, b, 1); 9040 } 9041 9042 // CHECK: test_vset_lane_p8 9043 // CHECK: vmov 9044 poly8x8_t test_vset_lane_p8(poly8_t a, poly8x8_t b) { 9045 return vset_lane_p8(a, b, 7); 9046 } 9047 9048 // CHECK: test_vset_lane_p16 9049 // CHECK: vmov 9050 poly16x4_t test_vset_lane_p16(poly16_t a, poly16x4_t b) { 9051 return vset_lane_p16(a, b, 3); 9052 } 9053 9054 // CHECK: test_vset_lane_f32 9055 // CHECK: vmov 9056 float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) { 9057 return vset_lane_f32(a, b, 1); 9058 } 9059 9060 // CHECK: test_vsetq_lane_u8 9061 // CHECK: vmov 9062 uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) { 9063 return vsetq_lane_u8(a, b, 15); 9064 } 9065 9066 // CHECK: test_vsetq_lane_u16 9067 // CHECK: vmov 9068 uint16x8_t test_vsetq_lane_u16(uint16_t a, uint16x8_t b) { 9069 return vsetq_lane_u16(a, b, 7); 9070 } 9071 9072 // CHECK: test_vsetq_lane_u32 9073 // CHECK: vmov 9074 uint32x4_t test_vsetq_lane_u32(uint32_t a, uint32x4_t b) { 9075 return vsetq_lane_u32(a, b, 3); 9076 } 9077 9078 // CHECK: test_vsetq_lane_s8 9079 // CHECK: vmov 9080 int8x16_t test_vsetq_lane_s8(int8_t a, int8x16_t b) { 9081 return vsetq_lane_s8(a, b, 15); 9082 } 9083 9084 // CHECK: test_vsetq_lane_s16 9085 // CHECK: vmov 9086 int16x8_t test_vsetq_lane_s16(int16_t a, int16x8_t b) { 9087 return vsetq_lane_s16(a, b, 7); 9088 } 9089 9090 // CHECK: test_vsetq_lane_s32 9091 // CHECK: vmov 9092 int32x4_t test_vsetq_lane_s32(int32_t a, int32x4_t b) { 9093 return vsetq_lane_s32(a, b, 3); 9094 } 9095 9096 // CHECK: test_vsetq_lane_p8 9097 // CHECK: vmov 9098 poly8x16_t test_vsetq_lane_p8(poly8_t a, poly8x16_t b) { 9099 return vsetq_lane_p8(a, b, 15); 9100 } 9101 9102 // CHECK: test_vsetq_lane_p16 9103 // CHECK: vmov 9104 poly16x8_t test_vsetq_lane_p16(poly16_t a, poly16x8_t b) { 9105 return vsetq_lane_p16(a, b, 7); 9106 } 9107 9108 // CHECK: test_vsetq_lane_f32 9109 // CHECK: vmov 9110 float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) { 9111 return vsetq_lane_f32(a, b, 3); 9112 } 9113 9114 // CHECK: test_vset_lane_s64 9115 // CHECK: vmov 9116 int64x1_t test_vset_lane_s64(int64_t a, int64x1_t b) { 9117 return vset_lane_s64(a, b, 0); 9118 } 9119 9120 // CHECK: test_vset_lane_u64 9121 // CHECK: vmov 9122 uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) { 9123 return vset_lane_u64(a, b, 0); 9124 } 9125 9126 // CHECK: test_vsetq_lane_s64 9127 // CHECK: vmov 9128 int64x2_t test_vsetq_lane_s64(int64_t a, int64x2_t b) { 9129 return vsetq_lane_s64(a, b, 1); 9130 } 9131 9132 // CHECK: test_vsetq_lane_u64 9133 // CHECK: vmov 9134 uint64x2_t test_vsetq_lane_u64(uint64_t a, uint64x2_t b) { 9135 return vsetq_lane_u64(a, b, 1); 9136 } 9137 9138 9139 // CHECK: test_vshl_s8 9140 // CHECK: vshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9141 int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) { 9142 return vshl_s8(a, b); 9143 } 9144 9145 // CHECK: test_vshl_s16 9146 // CHECK: vshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9147 int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) { 9148 return vshl_s16(a, b); 9149 } 9150 9151 // CHECK: test_vshl_s32 9152 // CHECK: vshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9153 int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) { 9154 return vshl_s32(a, b); 9155 } 9156 9157 // CHECK: test_vshl_s64 9158 // CHECK: vshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9159 int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) { 9160 return vshl_s64(a, b); 9161 } 9162 9163 // CHECK: test_vshl_u8 9164 // CHECK: vshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9165 uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) { 9166 return vshl_u8(a, b); 9167 } 9168 9169 // CHECK: test_vshl_u16 9170 // CHECK: vshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9171 uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) { 9172 return vshl_u16(a, b); 9173 } 9174 9175 // CHECK: test_vshl_u32 9176 // CHECK: vshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9177 uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) { 9178 return vshl_u32(a, b); 9179 } 9180 9181 // CHECK: test_vshl_u64 9182 // CHECK: vshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9183 uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) { 9184 return vshl_u64(a, b); 9185 } 9186 9187 // CHECK: test_vshlq_s8 9188 // CHECK: vshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9189 int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) { 9190 return vshlq_s8(a, b); 9191 } 9192 9193 // CHECK: test_vshlq_s16 9194 // CHECK: vshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9195 int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) { 9196 return vshlq_s16(a, b); 9197 } 9198 9199 // CHECK: test_vshlq_s32 9200 // CHECK: vshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9201 int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) { 9202 return vshlq_s32(a, b); 9203 } 9204 9205 // CHECK: test_vshlq_s64 9206 // CHECK: vshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9207 int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) { 9208 return vshlq_s64(a, b); 9209 } 9210 9211 // CHECK: test_vshlq_u8 9212 // CHECK: vshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9213 uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) { 9214 return vshlq_u8(a, b); 9215 } 9216 9217 // CHECK: test_vshlq_u16 9218 // CHECK: vshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9219 uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) { 9220 return vshlq_u16(a, b); 9221 } 9222 9223 // CHECK: test_vshlq_u32 9224 // CHECK: vshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9225 uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) { 9226 return vshlq_u32(a, b); 9227 } 9228 9229 // CHECK: test_vshlq_u64 9230 // CHECK: vshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9231 uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) { 9232 return vshlq_u64(a, b); 9233 } 9234 9235 9236 // CHECK: test_vshll_n_s8 9237 // CHECK: vshll.s8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9238 int16x8_t test_vshll_n_s8(int8x8_t a) { 9239 return vshll_n_s8(a, 1); 9240 } 9241 9242 // CHECK: test_vshll_n_s16 9243 // CHECK: vshll.s16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9244 int32x4_t test_vshll_n_s16(int16x4_t a) { 9245 return vshll_n_s16(a, 1); 9246 } 9247 9248 // CHECK: test_vshll_n_s32 9249 // CHECK: vshll.s32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9250 int64x2_t test_vshll_n_s32(int32x2_t a) { 9251 return vshll_n_s32(a, 1); 9252 } 9253 9254 // CHECK: test_vshll_n_u8 9255 // CHECK: vshll.u8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9256 uint16x8_t test_vshll_n_u8(uint8x8_t a) { 9257 return vshll_n_u8(a, 1); 9258 } 9259 9260 // CHECK: test_vshll_n_u16 9261 // CHECK: vshll.u16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9262 uint32x4_t test_vshll_n_u16(uint16x4_t a) { 9263 return vshll_n_u16(a, 1); 9264 } 9265 9266 // CHECK: test_vshll_n_u32 9267 // CHECK: vshll.u32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9268 uint64x2_t test_vshll_n_u32(uint32x2_t a) { 9269 return vshll_n_u32(a, 1); 9270 } 9271 9272 9273 // CHECK: test_vshl_n_s8 9274 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9275 int8x8_t test_vshl_n_s8(int8x8_t a) { 9276 return vshl_n_s8(a, 1); 9277 } 9278 9279 // CHECK: test_vshl_n_s16 9280 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9281 int16x4_t test_vshl_n_s16(int16x4_t a) { 9282 return vshl_n_s16(a, 1); 9283 } 9284 9285 // CHECK: test_vshl_n_s32 9286 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9287 int32x2_t test_vshl_n_s32(int32x2_t a) { 9288 return vshl_n_s32(a, 1); 9289 } 9290 9291 // CHECK: test_vshl_n_s64 9292 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9293 int64x1_t test_vshl_n_s64(int64x1_t a) { 9294 return vshl_n_s64(a, 1); 9295 } 9296 9297 // CHECK: test_vshl_n_u8 9298 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9299 uint8x8_t test_vshl_n_u8(uint8x8_t a) { 9300 return vshl_n_u8(a, 1); 9301 } 9302 9303 // CHECK: test_vshl_n_u16 9304 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9305 uint16x4_t test_vshl_n_u16(uint16x4_t a) { 9306 return vshl_n_u16(a, 1); 9307 } 9308 9309 // CHECK: test_vshl_n_u32 9310 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9311 uint32x2_t test_vshl_n_u32(uint32x2_t a) { 9312 return vshl_n_u32(a, 1); 9313 } 9314 9315 // CHECK: test_vshl_n_u64 9316 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9317 uint64x1_t test_vshl_n_u64(uint64x1_t a) { 9318 return vshl_n_u64(a, 1); 9319 } 9320 9321 // CHECK: test_vshlq_n_s8 9322 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9323 int8x16_t test_vshlq_n_s8(int8x16_t a) { 9324 return vshlq_n_s8(a, 1); 9325 } 9326 9327 // CHECK: test_vshlq_n_s16 9328 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9329 int16x8_t test_vshlq_n_s16(int16x8_t a) { 9330 return vshlq_n_s16(a, 1); 9331 } 9332 9333 // CHECK: test_vshlq_n_s32 9334 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9335 int32x4_t test_vshlq_n_s32(int32x4_t a) { 9336 return vshlq_n_s32(a, 1); 9337 } 9338 9339 // CHECK: test_vshlq_n_s64 9340 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9341 int64x2_t test_vshlq_n_s64(int64x2_t a) { 9342 return vshlq_n_s64(a, 1); 9343 } 9344 9345 // CHECK: test_vshlq_n_u8 9346 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9347 uint8x16_t test_vshlq_n_u8(uint8x16_t a) { 9348 return vshlq_n_u8(a, 1); 9349 } 9350 9351 // CHECK: test_vshlq_n_u16 9352 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9353 uint16x8_t test_vshlq_n_u16(uint16x8_t a) { 9354 return vshlq_n_u16(a, 1); 9355 } 9356 9357 // CHECK: test_vshlq_n_u32 9358 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9359 uint32x4_t test_vshlq_n_u32(uint32x4_t a) { 9360 return vshlq_n_u32(a, 1); 9361 } 9362 9363 // CHECK: test_vshlq_n_u64 9364 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9365 uint64x2_t test_vshlq_n_u64(uint64x2_t a) { 9366 return vshlq_n_u64(a, 1); 9367 } 9368 9369 9370 // CHECK: test_vshrn_n_s16 9371 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9372 int8x8_t test_vshrn_n_s16(int16x8_t a) { 9373 return vshrn_n_s16(a, 1); 9374 } 9375 9376 // CHECK: test_vshrn_n_s32 9377 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9378 int16x4_t test_vshrn_n_s32(int32x4_t a) { 9379 return vshrn_n_s32(a, 1); 9380 } 9381 9382 // CHECK: test_vshrn_n_s64 9383 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9384 int32x2_t test_vshrn_n_s64(int64x2_t a) { 9385 return vshrn_n_s64(a, 1); 9386 } 9387 9388 // CHECK: test_vshrn_n_u16 9389 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9390 uint8x8_t test_vshrn_n_u16(uint16x8_t a) { 9391 return vshrn_n_u16(a, 1); 9392 } 9393 9394 // CHECK: test_vshrn_n_u32 9395 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9396 uint16x4_t test_vshrn_n_u32(uint32x4_t a) { 9397 return vshrn_n_u32(a, 1); 9398 } 9399 9400 // CHECK: test_vshrn_n_u64 9401 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9402 uint32x2_t test_vshrn_n_u64(uint64x2_t a) { 9403 return vshrn_n_u64(a, 1); 9404 } 9405 9406 9407 // CHECK: test_vshr_n_s8 9408 // CHECK: vshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9409 int8x8_t test_vshr_n_s8(int8x8_t a) { 9410 return vshr_n_s8(a, 1); 9411 } 9412 9413 // CHECK: test_vshr_n_s16 9414 // CHECK: vshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9415 int16x4_t test_vshr_n_s16(int16x4_t a) { 9416 return vshr_n_s16(a, 1); 9417 } 9418 9419 // CHECK: test_vshr_n_s32 9420 // CHECK: vshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9421 int32x2_t test_vshr_n_s32(int32x2_t a) { 9422 return vshr_n_s32(a, 1); 9423 } 9424 9425 // CHECK: test_vshr_n_s64 9426 // CHECK: vshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9427 int64x1_t test_vshr_n_s64(int64x1_t a) { 9428 return vshr_n_s64(a, 1); 9429 } 9430 9431 // CHECK: test_vshr_n_u8 9432 // CHECK: vshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9433 uint8x8_t test_vshr_n_u8(uint8x8_t a) { 9434 return vshr_n_u8(a, 1); 9435 } 9436 9437 // CHECK: test_vshr_n_u16 9438 // CHECK: vshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9439 uint16x4_t test_vshr_n_u16(uint16x4_t a) { 9440 return vshr_n_u16(a, 1); 9441 } 9442 9443 // CHECK: test_vshr_n_u32 9444 // CHECK: vshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9445 uint32x2_t test_vshr_n_u32(uint32x2_t a) { 9446 return vshr_n_u32(a, 1); 9447 } 9448 9449 // CHECK: test_vshr_n_u64 9450 // CHECK: vshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9451 uint64x1_t test_vshr_n_u64(uint64x1_t a) { 9452 return vshr_n_u64(a, 1); 9453 } 9454 9455 // CHECK: test_vshrq_n_s8 9456 // CHECK: vshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9457 int8x16_t test_vshrq_n_s8(int8x16_t a) { 9458 return vshrq_n_s8(a, 1); 9459 } 9460 9461 // CHECK: test_vshrq_n_s16 9462 // CHECK: vshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9463 int16x8_t test_vshrq_n_s16(int16x8_t a) { 9464 return vshrq_n_s16(a, 1); 9465 } 9466 9467 // CHECK: test_vshrq_n_s32 9468 // CHECK: vshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9469 int32x4_t test_vshrq_n_s32(int32x4_t a) { 9470 return vshrq_n_s32(a, 1); 9471 } 9472 9473 // CHECK: test_vshrq_n_s64 9474 // CHECK: vshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9475 int64x2_t test_vshrq_n_s64(int64x2_t a) { 9476 return vshrq_n_s64(a, 1); 9477 } 9478 9479 // CHECK: test_vshrq_n_u8 9480 // CHECK: vshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9481 uint8x16_t test_vshrq_n_u8(uint8x16_t a) { 9482 return vshrq_n_u8(a, 1); 9483 } 9484 9485 // CHECK: test_vshrq_n_u16 9486 // CHECK: vshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9487 uint16x8_t test_vshrq_n_u16(uint16x8_t a) { 9488 return vshrq_n_u16(a, 1); 9489 } 9490 9491 // CHECK: test_vshrq_n_u32 9492 // CHECK: vshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9493 uint32x4_t test_vshrq_n_u32(uint32x4_t a) { 9494 return vshrq_n_u32(a, 1); 9495 } 9496 9497 // CHECK: test_vshrq_n_u64 9498 // CHECK: vshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9499 uint64x2_t test_vshrq_n_u64(uint64x2_t a) { 9500 return vshrq_n_u64(a, 1); 9501 } 9502 9503 9504 // CHECK: test_vsli_n_s8 9505 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9506 int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) { 9507 return vsli_n_s8(a, b, 1); 9508 } 9509 9510 // CHECK: test_vsli_n_s16 9511 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9512 int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) { 9513 return vsli_n_s16(a, b, 1); 9514 } 9515 9516 // CHECK: test_vsli_n_s32 9517 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9518 int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) { 9519 return vsli_n_s32(a, b, 1); 9520 } 9521 9522 // CHECK: test_vsli_n_s64 9523 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9524 int64x1_t test_vsli_n_s64(int64x1_t a, int64x1_t b) { 9525 return vsli_n_s64(a, b, 1); 9526 } 9527 9528 // CHECK: test_vsli_n_u8 9529 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9530 uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) { 9531 return vsli_n_u8(a, b, 1); 9532 } 9533 9534 // CHECK: test_vsli_n_u16 9535 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9536 uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) { 9537 return vsli_n_u16(a, b, 1); 9538 } 9539 9540 // CHECK: test_vsli_n_u32 9541 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9542 uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) { 9543 return vsli_n_u32(a, b, 1); 9544 } 9545 9546 // CHECK: test_vsli_n_u64 9547 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9548 uint64x1_t test_vsli_n_u64(uint64x1_t a, uint64x1_t b) { 9549 return vsli_n_u64(a, b, 1); 9550 } 9551 9552 // CHECK: test_vsli_n_p8 9553 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9554 poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) { 9555 return vsli_n_p8(a, b, 1); 9556 } 9557 9558 // CHECK: test_vsli_n_p16 9559 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9560 poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) { 9561 return vsli_n_p16(a, b, 1); 9562 } 9563 9564 // CHECK: test_vsliq_n_s8 9565 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9566 int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) { 9567 return vsliq_n_s8(a, b, 1); 9568 } 9569 9570 // CHECK: test_vsliq_n_s16 9571 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9572 int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) { 9573 return vsliq_n_s16(a, b, 1); 9574 } 9575 9576 // CHECK: test_vsliq_n_s32 9577 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9578 int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) { 9579 return vsliq_n_s32(a, b, 1); 9580 } 9581 9582 // CHECK: test_vsliq_n_s64 9583 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9584 int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) { 9585 return vsliq_n_s64(a, b, 1); 9586 } 9587 9588 // CHECK: test_vsliq_n_u8 9589 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9590 uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) { 9591 return vsliq_n_u8(a, b, 1); 9592 } 9593 9594 // CHECK: test_vsliq_n_u16 9595 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9596 uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) { 9597 return vsliq_n_u16(a, b, 1); 9598 } 9599 9600 // CHECK: test_vsliq_n_u32 9601 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9602 uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) { 9603 return vsliq_n_u32(a, b, 1); 9604 } 9605 9606 // CHECK: test_vsliq_n_u64 9607 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9608 uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) { 9609 return vsliq_n_u64(a, b, 1); 9610 } 9611 9612 // CHECK: test_vsliq_n_p8 9613 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9614 poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) { 9615 return vsliq_n_p8(a, b, 1); 9616 } 9617 9618 // CHECK: test_vsliq_n_p16 9619 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9620 poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) { 9621 return vsliq_n_p16(a, b, 1); 9622 } 9623 9624 9625 // CHECK: test_vsra_n_s8 9626 // CHECK: vsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9627 int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) { 9628 return vsra_n_s8(a, b, 1); 9629 } 9630 9631 // CHECK: test_vsra_n_s16 9632 // CHECK: vsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9633 int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) { 9634 return vsra_n_s16(a, b, 1); 9635 } 9636 9637 // CHECK: test_vsra_n_s32 9638 // CHECK: vsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9639 int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) { 9640 return vsra_n_s32(a, b, 1); 9641 } 9642 9643 // CHECK: test_vsra_n_s64 9644 // CHECK: vsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9645 int64x1_t test_vsra_n_s64(int64x1_t a, int64x1_t b) { 9646 return vsra_n_s64(a, b, 1); 9647 } 9648 9649 // CHECK: test_vsra_n_u8 9650 // CHECK: vsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9651 uint8x8_t test_vsra_n_u8(uint8x8_t a, uint8x8_t b) { 9652 return vsra_n_u8(a, b, 1); 9653 } 9654 9655 // CHECK: test_vsra_n_u16 9656 // CHECK: vsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9657 uint16x4_t test_vsra_n_u16(uint16x4_t a, uint16x4_t b) { 9658 return vsra_n_u16(a, b, 1); 9659 } 9660 9661 // CHECK: test_vsra_n_u32 9662 // CHECK: vsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9663 uint32x2_t test_vsra_n_u32(uint32x2_t a, uint32x2_t b) { 9664 return vsra_n_u32(a, b, 1); 9665 } 9666 9667 // CHECK: test_vsra_n_u64 9668 // CHECK: vsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9669 uint64x1_t test_vsra_n_u64(uint64x1_t a, uint64x1_t b) { 9670 return vsra_n_u64(a, b, 1); 9671 } 9672 9673 // CHECK: test_vsraq_n_s8 9674 // CHECK: vsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9675 int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) { 9676 return vsraq_n_s8(a, b, 1); 9677 } 9678 9679 // CHECK: test_vsraq_n_s16 9680 // CHECK: vsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9681 int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) { 9682 return vsraq_n_s16(a, b, 1); 9683 } 9684 9685 // CHECK: test_vsraq_n_s32 9686 // CHECK: vsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9687 int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) { 9688 return vsraq_n_s32(a, b, 1); 9689 } 9690 9691 // CHECK: test_vsraq_n_s64 9692 // CHECK: vsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9693 int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) { 9694 return vsraq_n_s64(a, b, 1); 9695 } 9696 9697 // CHECK: test_vsraq_n_u8 9698 // CHECK: vsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9699 uint8x16_t test_vsraq_n_u8(uint8x16_t a, uint8x16_t b) { 9700 return vsraq_n_u8(a, b, 1); 9701 } 9702 9703 // CHECK: test_vsraq_n_u16 9704 // CHECK: vsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9705 uint16x8_t test_vsraq_n_u16(uint16x8_t a, uint16x8_t b) { 9706 return vsraq_n_u16(a, b, 1); 9707 } 9708 9709 // CHECK: test_vsraq_n_u32 9710 // CHECK: vsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9711 uint32x4_t test_vsraq_n_u32(uint32x4_t a, uint32x4_t b) { 9712 return vsraq_n_u32(a, b, 1); 9713 } 9714 9715 // CHECK: test_vsraq_n_u64 9716 // CHECK: vsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9717 uint64x2_t test_vsraq_n_u64(uint64x2_t a, uint64x2_t b) { 9718 return vsraq_n_u64(a, b, 1); 9719 } 9720 9721 9722 // CHECK: test_vsri_n_s8 9723 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9724 int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) { 9725 return vsri_n_s8(a, b, 1); 9726 } 9727 9728 // CHECK: test_vsri_n_s16 9729 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9730 int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) { 9731 return vsri_n_s16(a, b, 1); 9732 } 9733 9734 // CHECK: test_vsri_n_s32 9735 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9736 int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) { 9737 return vsri_n_s32(a, b, 1); 9738 } 9739 9740 // CHECK: test_vsri_n_s64 9741 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9742 int64x1_t test_vsri_n_s64(int64x1_t a, int64x1_t b) { 9743 return vsri_n_s64(a, b, 1); 9744 } 9745 9746 // CHECK: test_vsri_n_u8 9747 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9748 uint8x8_t test_vsri_n_u8(uint8x8_t a, uint8x8_t b) { 9749 return vsri_n_u8(a, b, 1); 9750 } 9751 9752 // CHECK: test_vsri_n_u16 9753 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9754 uint16x4_t test_vsri_n_u16(uint16x4_t a, uint16x4_t b) { 9755 return vsri_n_u16(a, b, 1); 9756 } 9757 9758 // CHECK: test_vsri_n_u32 9759 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9760 uint32x2_t test_vsri_n_u32(uint32x2_t a, uint32x2_t b) { 9761 return vsri_n_u32(a, b, 1); 9762 } 9763 9764 // CHECK: test_vsri_n_u64 9765 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9766 uint64x1_t test_vsri_n_u64(uint64x1_t a, uint64x1_t b) { 9767 return vsri_n_u64(a, b, 1); 9768 } 9769 9770 // CHECK: test_vsri_n_p8 9771 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9772 poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) { 9773 return vsri_n_p8(a, b, 1); 9774 } 9775 9776 // CHECK: test_vsri_n_p16 9777 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9778 poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) { 9779 return vsri_n_p16(a, b, 1); 9780 } 9781 9782 // CHECK: test_vsriq_n_s8 9783 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9784 int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) { 9785 return vsriq_n_s8(a, b, 1); 9786 } 9787 9788 // CHECK: test_vsriq_n_s16 9789 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9790 int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) { 9791 return vsriq_n_s16(a, b, 1); 9792 } 9793 9794 // CHECK: test_vsriq_n_s32 9795 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9796 int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) { 9797 return vsriq_n_s32(a, b, 1); 9798 } 9799 9800 // CHECK: test_vsriq_n_s64 9801 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9802 int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) { 9803 return vsriq_n_s64(a, b, 1); 9804 } 9805 9806 // CHECK: test_vsriq_n_u8 9807 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9808 uint8x16_t test_vsriq_n_u8(uint8x16_t a, uint8x16_t b) { 9809 return vsriq_n_u8(a, b, 1); 9810 } 9811 9812 // CHECK: test_vsriq_n_u16 9813 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9814 uint16x8_t test_vsriq_n_u16(uint16x8_t a, uint16x8_t b) { 9815 return vsriq_n_u16(a, b, 1); 9816 } 9817 9818 // CHECK: test_vsriq_n_u32 9819 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9820 uint32x4_t test_vsriq_n_u32(uint32x4_t a, uint32x4_t b) { 9821 return vsriq_n_u32(a, b, 1); 9822 } 9823 9824 // CHECK: test_vsriq_n_u64 9825 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9826 uint64x2_t test_vsriq_n_u64(uint64x2_t a, uint64x2_t b) { 9827 return vsriq_n_u64(a, b, 1); 9828 } 9829 9830 // CHECK: test_vsriq_n_p8 9831 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9832 poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) { 9833 return vsriq_n_p8(a, b, 1); 9834 } 9835 9836 // CHECK: test_vsriq_n_p16 9837 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9838 poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) { 9839 return vsriq_n_p16(a, b, 1); 9840 } 9841 9842 9843 // CHECK: test_vst1q_u8 9844 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9845 void test_vst1q_u8(uint8_t * a, uint8x16_t b) { 9846 vst1q_u8(a, b); 9847 } 9848 9849 // CHECK: test_vst1q_u16 9850 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9851 void test_vst1q_u16(uint16_t * a, uint16x8_t b) { 9852 vst1q_u16(a, b); 9853 } 9854 9855 // CHECK: test_vst1q_u32 9856 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9857 void test_vst1q_u32(uint32_t * a, uint32x4_t b) { 9858 vst1q_u32(a, b); 9859 } 9860 9861 // CHECK: test_vst1q_u64 9862 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9863 void test_vst1q_u64(uint64_t * a, uint64x2_t b) { 9864 vst1q_u64(a, b); 9865 } 9866 9867 // CHECK: test_vst1q_s8 9868 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9869 void test_vst1q_s8(int8_t * a, int8x16_t b) { 9870 vst1q_s8(a, b); 9871 } 9872 9873 // CHECK: test_vst1q_s16 9874 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9875 void test_vst1q_s16(int16_t * a, int16x8_t b) { 9876 vst1q_s16(a, b); 9877 } 9878 9879 // CHECK: test_vst1q_s32 9880 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9881 void test_vst1q_s32(int32_t * a, int32x4_t b) { 9882 vst1q_s32(a, b); 9883 } 9884 9885 // CHECK: test_vst1q_s64 9886 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9887 void test_vst1q_s64(int64_t * a, int64x2_t b) { 9888 vst1q_s64(a, b); 9889 } 9890 9891 // CHECK: test_vst1q_f16 9892 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9893 void test_vst1q_f16(float16_t * a, float16x8_t b) { 9894 vst1q_f16(a, b); 9895 } 9896 9897 // CHECK: test_vst1q_f32 9898 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9899 void test_vst1q_f32(float32_t * a, float32x4_t b) { 9900 vst1q_f32(a, b); 9901 } 9902 9903 // CHECK: test_vst1q_p8 9904 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9905 void test_vst1q_p8(poly8_t * a, poly8x16_t b) { 9906 vst1q_p8(a, b); 9907 } 9908 9909 // CHECK: test_vst1q_p16 9910 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9911 void test_vst1q_p16(poly16_t * a, poly16x8_t b) { 9912 vst1q_p16(a, b); 9913 } 9914 9915 // CHECK: test_vst1_u8 9916 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9917 void test_vst1_u8(uint8_t * a, uint8x8_t b) { 9918 vst1_u8(a, b); 9919 } 9920 9921 // CHECK: test_vst1_u16 9922 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9923 void test_vst1_u16(uint16_t * a, uint16x4_t b) { 9924 vst1_u16(a, b); 9925 } 9926 9927 // CHECK: test_vst1_u32 9928 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9929 void test_vst1_u32(uint32_t * a, uint32x2_t b) { 9930 vst1_u32(a, b); 9931 } 9932 9933 // CHECK: test_vst1_u64 9934 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9935 void test_vst1_u64(uint64_t * a, uint64x1_t b) { 9936 vst1_u64(a, b); 9937 } 9938 9939 // CHECK: test_vst1_s8 9940 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9941 void test_vst1_s8(int8_t * a, int8x8_t b) { 9942 vst1_s8(a, b); 9943 } 9944 9945 // CHECK: test_vst1_s16 9946 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9947 void test_vst1_s16(int16_t * a, int16x4_t b) { 9948 vst1_s16(a, b); 9949 } 9950 9951 // CHECK: test_vst1_s32 9952 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9953 void test_vst1_s32(int32_t * a, int32x2_t b) { 9954 vst1_s32(a, b); 9955 } 9956 9957 // CHECK: test_vst1_s64 9958 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9959 void test_vst1_s64(int64_t * a, int64x1_t b) { 9960 vst1_s64(a, b); 9961 } 9962 9963 // CHECK: test_vst1_f16 9964 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9965 void test_vst1_f16(float16_t * a, float16x4_t b) { 9966 vst1_f16(a, b); 9967 } 9968 9969 // CHECK: test_vst1_f32 9970 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9971 void test_vst1_f32(float32_t * a, float32x2_t b) { 9972 vst1_f32(a, b); 9973 } 9974 9975 // CHECK: test_vst1_p8 9976 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9977 void test_vst1_p8(poly8_t * a, poly8x8_t b) { 9978 vst1_p8(a, b); 9979 } 9980 9981 // CHECK: test_vst1_p16 9982 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9983 void test_vst1_p16(poly16_t * a, poly16x4_t b) { 9984 vst1_p16(a, b); 9985 } 9986 9987 9988 // CHECK: test_vst1q_lane_u8 9989 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 9990 void test_vst1q_lane_u8(uint8_t * a, uint8x16_t b) { 9991 vst1q_lane_u8(a, b, 15); 9992 } 9993 9994 // CHECK: test_vst1q_lane_u16 9995 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 9996 void test_vst1q_lane_u16(uint16_t * a, uint16x8_t b) { 9997 vst1q_lane_u16(a, b, 7); 9998 } 9999 10000 // CHECK: test_vst1q_lane_u32 10001 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10002 void test_vst1q_lane_u32(uint32_t * a, uint32x4_t b) { 10003 vst1q_lane_u32(a, b, 3); 10004 } 10005 10006 // CHECK: test_vst1q_lane_u64 10007 // CHECK: {{str|vstr|vmov}} 10008 void test_vst1q_lane_u64(uint64_t * a, uint64x2_t b) { 10009 vst1q_lane_u64(a, b, 1); 10010 } 10011 10012 // CHECK: test_vst1q_lane_s8 10013 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10014 void test_vst1q_lane_s8(int8_t * a, int8x16_t b) { 10015 vst1q_lane_s8(a, b, 15); 10016 } 10017 10018 // CHECK: test_vst1q_lane_s16 10019 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10020 void test_vst1q_lane_s16(int16_t * a, int16x8_t b) { 10021 vst1q_lane_s16(a, b, 7); 10022 } 10023 10024 // CHECK: test_vst1q_lane_s32 10025 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10026 void test_vst1q_lane_s32(int32_t * a, int32x4_t b) { 10027 vst1q_lane_s32(a, b, 3); 10028 } 10029 10030 // CHECK: test_vst1q_lane_s64 10031 // CHECK: {{str|vstr|vmov}} 10032 void test_vst1q_lane_s64(int64_t * a, int64x2_t b) { 10033 vst1q_lane_s64(a, b, 1); 10034 } 10035 10036 // CHECK: test_vst1q_lane_f16 10037 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10038 void test_vst1q_lane_f16(float16_t * a, float16x8_t b) { 10039 vst1q_lane_f16(a, b, 7); 10040 } 10041 10042 // CHECK: test_vst1q_lane_f32 10043 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10044 void test_vst1q_lane_f32(float32_t * a, float32x4_t b) { 10045 vst1q_lane_f32(a, b, 3); 10046 } 10047 10048 // CHECK: test_vst1q_lane_p8 10049 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10050 void test_vst1q_lane_p8(poly8_t * a, poly8x16_t b) { 10051 vst1q_lane_p8(a, b, 15); 10052 } 10053 10054 // CHECK: test_vst1q_lane_p16 10055 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10056 void test_vst1q_lane_p16(poly16_t * a, poly16x8_t b) { 10057 vst1q_lane_p16(a, b, 7); 10058 } 10059 10060 // CHECK: test_vst1_lane_u8 10061 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10062 void test_vst1_lane_u8(uint8_t * a, uint8x8_t b) { 10063 vst1_lane_u8(a, b, 7); 10064 } 10065 10066 // CHECK: test_vst1_lane_u16 10067 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10068 void test_vst1_lane_u16(uint16_t * a, uint16x4_t b) { 10069 vst1_lane_u16(a, b, 3); 10070 } 10071 10072 // CHECK: test_vst1_lane_u32 10073 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10074 void test_vst1_lane_u32(uint32_t * a, uint32x2_t b) { 10075 vst1_lane_u32(a, b, 1); 10076 } 10077 10078 // CHECK: test_vst1_lane_u64 10079 // CHECK: {{str|vstr|vmov}} 10080 void test_vst1_lane_u64(uint64_t * a, uint64x1_t b) { 10081 vst1_lane_u64(a, b, 0); 10082 } 10083 10084 // CHECK: test_vst1_lane_s8 10085 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10086 void test_vst1_lane_s8(int8_t * a, int8x8_t b) { 10087 vst1_lane_s8(a, b, 7); 10088 } 10089 10090 // CHECK: test_vst1_lane_s16 10091 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10092 void test_vst1_lane_s16(int16_t * a, int16x4_t b) { 10093 vst1_lane_s16(a, b, 3); 10094 } 10095 10096 // CHECK: test_vst1_lane_s32 10097 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10098 void test_vst1_lane_s32(int32_t * a, int32x2_t b) { 10099 vst1_lane_s32(a, b, 1); 10100 } 10101 10102 // CHECK: test_vst1_lane_s64 10103 // CHECK: {{str|vstr|vmov}} 10104 void test_vst1_lane_s64(int64_t * a, int64x1_t b) { 10105 vst1_lane_s64(a, b, 0); 10106 } 10107 10108 // CHECK: test_vst1_lane_f16 10109 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10110 void test_vst1_lane_f16(float16_t * a, float16x4_t b) { 10111 vst1_lane_f16(a, b, 3); 10112 } 10113 10114 // CHECK: test_vst1_lane_f32 10115 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10116 void test_vst1_lane_f32(float32_t * a, float32x2_t b) { 10117 vst1_lane_f32(a, b, 1); 10118 } 10119 10120 // CHECK: test_vst1_lane_p8 10121 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10122 void test_vst1_lane_p8(poly8_t * a, poly8x8_t b) { 10123 vst1_lane_p8(a, b, 7); 10124 } 10125 10126 // CHECK: test_vst1_lane_p16 10127 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10128 void test_vst1_lane_p16(poly16_t * a, poly16x4_t b) { 10129 vst1_lane_p16(a, b, 3); 10130 } 10131 10132 10133 // CHECK: test_vst2q_u8 10134 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10135 void test_vst2q_u8(uint8_t * a, uint8x16x2_t b) { 10136 vst2q_u8(a, b); 10137 } 10138 10139 // CHECK: test_vst2q_u16 10140 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10141 void test_vst2q_u16(uint16_t * a, uint16x8x2_t b) { 10142 vst2q_u16(a, b); 10143 } 10144 10145 // CHECK: test_vst2q_u32 10146 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10147 void test_vst2q_u32(uint32_t * a, uint32x4x2_t b) { 10148 vst2q_u32(a, b); 10149 } 10150 10151 // CHECK: test_vst2q_s8 10152 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10153 void test_vst2q_s8(int8_t * a, int8x16x2_t b) { 10154 vst2q_s8(a, b); 10155 } 10156 10157 // CHECK: test_vst2q_s16 10158 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10159 void test_vst2q_s16(int16_t * a, int16x8x2_t b) { 10160 vst2q_s16(a, b); 10161 } 10162 10163 // CHECK: test_vst2q_s32 10164 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10165 void test_vst2q_s32(int32_t * a, int32x4x2_t b) { 10166 vst2q_s32(a, b); 10167 } 10168 10169 // CHECK: test_vst2q_f16 10170 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10171 void test_vst2q_f16(float16_t * a, float16x8x2_t b) { 10172 vst2q_f16(a, b); 10173 } 10174 10175 // CHECK: test_vst2q_f32 10176 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10177 void test_vst2q_f32(float32_t * a, float32x4x2_t b) { 10178 vst2q_f32(a, b); 10179 } 10180 10181 // CHECK: test_vst2q_p8 10182 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10183 void test_vst2q_p8(poly8_t * a, poly8x16x2_t b) { 10184 vst2q_p8(a, b); 10185 } 10186 10187 // CHECK: test_vst2q_p16 10188 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10189 void test_vst2q_p16(poly16_t * a, poly16x8x2_t b) { 10190 vst2q_p16(a, b); 10191 } 10192 10193 // CHECK: test_vst2_u8 10194 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10195 void test_vst2_u8(uint8_t * a, uint8x8x2_t b) { 10196 vst2_u8(a, b); 10197 } 10198 10199 // CHECK: test_vst2_u16 10200 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10201 void test_vst2_u16(uint16_t * a, uint16x4x2_t b) { 10202 vst2_u16(a, b); 10203 } 10204 10205 // CHECK: test_vst2_u32 10206 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10207 void test_vst2_u32(uint32_t * a, uint32x2x2_t b) { 10208 vst2_u32(a, b); 10209 } 10210 10211 // CHECK: test_vst2_u64 10212 // CHECK: vst1.64 10213 void test_vst2_u64(uint64_t * a, uint64x1x2_t b) { 10214 vst2_u64(a, b); 10215 } 10216 10217 // CHECK: test_vst2_s8 10218 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10219 void test_vst2_s8(int8_t * a, int8x8x2_t b) { 10220 vst2_s8(a, b); 10221 } 10222 10223 // CHECK: test_vst2_s16 10224 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10225 void test_vst2_s16(int16_t * a, int16x4x2_t b) { 10226 vst2_s16(a, b); 10227 } 10228 10229 // CHECK: test_vst2_s32 10230 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10231 void test_vst2_s32(int32_t * a, int32x2x2_t b) { 10232 vst2_s32(a, b); 10233 } 10234 10235 // CHECK: test_vst2_s64 10236 // CHECK: vst1.64 10237 void test_vst2_s64(int64_t * a, int64x1x2_t b) { 10238 vst2_s64(a, b); 10239 } 10240 10241 // CHECK: test_vst2_f16 10242 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10243 void test_vst2_f16(float16_t * a, float16x4x2_t b) { 10244 vst2_f16(a, b); 10245 } 10246 10247 // CHECK: test_vst2_f32 10248 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10249 void test_vst2_f32(float32_t * a, float32x2x2_t b) { 10250 vst2_f32(a, b); 10251 } 10252 10253 // CHECK: test_vst2_p8 10254 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10255 void test_vst2_p8(poly8_t * a, poly8x8x2_t b) { 10256 vst2_p8(a, b); 10257 } 10258 10259 // CHECK: test_vst2_p16 10260 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10261 void test_vst2_p16(poly16_t * a, poly16x4x2_t b) { 10262 vst2_p16(a, b); 10263 } 10264 10265 10266 // CHECK: test_vst2q_lane_u16 10267 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10268 void test_vst2q_lane_u16(uint16_t * a, uint16x8x2_t b) { 10269 vst2q_lane_u16(a, b, 7); 10270 } 10271 10272 // CHECK: test_vst2q_lane_u32 10273 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10274 void test_vst2q_lane_u32(uint32_t * a, uint32x4x2_t b) { 10275 vst2q_lane_u32(a, b, 3); 10276 } 10277 10278 // CHECK: test_vst2q_lane_s16 10279 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10280 void test_vst2q_lane_s16(int16_t * a, int16x8x2_t b) { 10281 vst2q_lane_s16(a, b, 7); 10282 } 10283 10284 // CHECK: test_vst2q_lane_s32 10285 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10286 void test_vst2q_lane_s32(int32_t * a, int32x4x2_t b) { 10287 vst2q_lane_s32(a, b, 3); 10288 } 10289 10290 // CHECK: test_vst2q_lane_f16 10291 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10292 void test_vst2q_lane_f16(float16_t * a, float16x8x2_t b) { 10293 vst2q_lane_f16(a, b, 7); 10294 } 10295 10296 // CHECK: test_vst2q_lane_f32 10297 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10298 void test_vst2q_lane_f32(float32_t * a, float32x4x2_t b) { 10299 vst2q_lane_f32(a, b, 3); 10300 } 10301 10302 // CHECK: test_vst2q_lane_p16 10303 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10304 void test_vst2q_lane_p16(poly16_t * a, poly16x8x2_t b) { 10305 vst2q_lane_p16(a, b, 7); 10306 } 10307 10308 // CHECK: test_vst2_lane_u8 10309 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10310 void test_vst2_lane_u8(uint8_t * a, uint8x8x2_t b) { 10311 vst2_lane_u8(a, b, 7); 10312 } 10313 10314 // CHECK: test_vst2_lane_u16 10315 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10316 void test_vst2_lane_u16(uint16_t * a, uint16x4x2_t b) { 10317 vst2_lane_u16(a, b, 3); 10318 } 10319 10320 // CHECK: test_vst2_lane_u32 10321 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10322 void test_vst2_lane_u32(uint32_t * a, uint32x2x2_t b) { 10323 vst2_lane_u32(a, b, 1); 10324 } 10325 10326 // CHECK: test_vst2_lane_s8 10327 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10328 void test_vst2_lane_s8(int8_t * a, int8x8x2_t b) { 10329 vst2_lane_s8(a, b, 7); 10330 } 10331 10332 // CHECK: test_vst2_lane_s16 10333 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10334 void test_vst2_lane_s16(int16_t * a, int16x4x2_t b) { 10335 vst2_lane_s16(a, b, 3); 10336 } 10337 10338 // CHECK: test_vst2_lane_s32 10339 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10340 void test_vst2_lane_s32(int32_t * a, int32x2x2_t b) { 10341 vst2_lane_s32(a, b, 1); 10342 } 10343 10344 // CHECK: test_vst2_lane_f16 10345 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10346 void test_vst2_lane_f16(float16_t * a, float16x4x2_t b) { 10347 vst2_lane_f16(a, b, 3); 10348 } 10349 10350 // CHECK: test_vst2_lane_f32 10351 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10352 void test_vst2_lane_f32(float32_t * a, float32x2x2_t b) { 10353 vst2_lane_f32(a, b, 1); 10354 } 10355 10356 // CHECK: test_vst2_lane_p8 10357 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10358 void test_vst2_lane_p8(poly8_t * a, poly8x8x2_t b) { 10359 vst2_lane_p8(a, b, 7); 10360 } 10361 10362 // CHECK: test_vst2_lane_p16 10363 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10364 void test_vst2_lane_p16(poly16_t * a, poly16x4x2_t b) { 10365 vst2_lane_p16(a, b, 3); 10366 } 10367 10368 10369 // CHECK: test_vst3q_u8 10370 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10371 void test_vst3q_u8(uint8_t * a, uint8x16x3_t b) { 10372 vst3q_u8(a, b); 10373 } 10374 10375 // CHECK: test_vst3q_u16 10376 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10377 void test_vst3q_u16(uint16_t * a, uint16x8x3_t b) { 10378 vst3q_u16(a, b); 10379 } 10380 10381 // CHECK: test_vst3q_u32 10382 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10383 void test_vst3q_u32(uint32_t * a, uint32x4x3_t b) { 10384 vst3q_u32(a, b); 10385 } 10386 10387 // CHECK: test_vst3q_s8 10388 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10389 void test_vst3q_s8(int8_t * a, int8x16x3_t b) { 10390 vst3q_s8(a, b); 10391 } 10392 10393 // CHECK: test_vst3q_s16 10394 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10395 void test_vst3q_s16(int16_t * a, int16x8x3_t b) { 10396 vst3q_s16(a, b); 10397 } 10398 10399 // CHECK: test_vst3q_s32 10400 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10401 void test_vst3q_s32(int32_t * a, int32x4x3_t b) { 10402 vst3q_s32(a, b); 10403 } 10404 10405 // CHECK: test_vst3q_f16 10406 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10407 void test_vst3q_f16(float16_t * a, float16x8x3_t b) { 10408 vst3q_f16(a, b); 10409 } 10410 10411 // CHECK: test_vst3q_f32 10412 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10413 void test_vst3q_f32(float32_t * a, float32x4x3_t b) { 10414 vst3q_f32(a, b); 10415 } 10416 10417 // CHECK: test_vst3q_p8 10418 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10419 void test_vst3q_p8(poly8_t * a, poly8x16x3_t b) { 10420 vst3q_p8(a, b); 10421 } 10422 10423 // CHECK: test_vst3q_p16 10424 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10425 void test_vst3q_p16(poly16_t * a, poly16x8x3_t b) { 10426 vst3q_p16(a, b); 10427 } 10428 10429 // CHECK: test_vst3_u8 10430 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10431 void test_vst3_u8(uint8_t * a, uint8x8x3_t b) { 10432 vst3_u8(a, b); 10433 } 10434 10435 // CHECK: test_vst3_u16 10436 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10437 void test_vst3_u16(uint16_t * a, uint16x4x3_t b) { 10438 vst3_u16(a, b); 10439 } 10440 10441 // CHECK: test_vst3_u32 10442 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10443 void test_vst3_u32(uint32_t * a, uint32x2x3_t b) { 10444 vst3_u32(a, b); 10445 } 10446 10447 // CHECK: test_vst3_u64 10448 // CHECK: vst1.64 10449 void test_vst3_u64(uint64_t * a, uint64x1x3_t b) { 10450 vst3_u64(a, b); 10451 } 10452 10453 // CHECK: test_vst3_s8 10454 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10455 void test_vst3_s8(int8_t * a, int8x8x3_t b) { 10456 vst3_s8(a, b); 10457 } 10458 10459 // CHECK: test_vst3_s16 10460 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10461 void test_vst3_s16(int16_t * a, int16x4x3_t b) { 10462 vst3_s16(a, b); 10463 } 10464 10465 // CHECK: test_vst3_s32 10466 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10467 void test_vst3_s32(int32_t * a, int32x2x3_t b) { 10468 vst3_s32(a, b); 10469 } 10470 10471 // CHECK: test_vst3_s64 10472 // CHECK: vst1.64 10473 void test_vst3_s64(int64_t * a, int64x1x3_t b) { 10474 vst3_s64(a, b); 10475 } 10476 10477 // CHECK: test_vst3_f16 10478 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10479 void test_vst3_f16(float16_t * a, float16x4x3_t b) { 10480 vst3_f16(a, b); 10481 } 10482 10483 // CHECK: test_vst3_f32 10484 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10485 void test_vst3_f32(float32_t * a, float32x2x3_t b) { 10486 vst3_f32(a, b); 10487 } 10488 10489 // CHECK: test_vst3_p8 10490 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10491 void test_vst3_p8(poly8_t * a, poly8x8x3_t b) { 10492 vst3_p8(a, b); 10493 } 10494 10495 // CHECK: test_vst3_p16 10496 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10497 void test_vst3_p16(poly16_t * a, poly16x4x3_t b) { 10498 vst3_p16(a, b); 10499 } 10500 10501 10502 // CHECK: test_vst3q_lane_u16 10503 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10504 void test_vst3q_lane_u16(uint16_t * a, uint16x8x3_t b) { 10505 vst3q_lane_u16(a, b, 7); 10506 } 10507 10508 // CHECK: test_vst3q_lane_u32 10509 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10510 void test_vst3q_lane_u32(uint32_t * a, uint32x4x3_t b) { 10511 vst3q_lane_u32(a, b, 3); 10512 } 10513 10514 // CHECK: test_vst3q_lane_s16 10515 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10516 void test_vst3q_lane_s16(int16_t * a, int16x8x3_t b) { 10517 vst3q_lane_s16(a, b, 7); 10518 } 10519 10520 // CHECK: test_vst3q_lane_s32 10521 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10522 void test_vst3q_lane_s32(int32_t * a, int32x4x3_t b) { 10523 vst3q_lane_s32(a, b, 3); 10524 } 10525 10526 // CHECK: test_vst3q_lane_f16 10527 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10528 void test_vst3q_lane_f16(float16_t * a, float16x8x3_t b) { 10529 vst3q_lane_f16(a, b, 7); 10530 } 10531 10532 // CHECK: test_vst3q_lane_f32 10533 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10534 void test_vst3q_lane_f32(float32_t * a, float32x4x3_t b) { 10535 vst3q_lane_f32(a, b, 3); 10536 } 10537 10538 // CHECK: test_vst3q_lane_p16 10539 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10540 void test_vst3q_lane_p16(poly16_t * a, poly16x8x3_t b) { 10541 vst3q_lane_p16(a, b, 7); 10542 } 10543 10544 // CHECK: test_vst3_lane_u8 10545 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10546 void test_vst3_lane_u8(uint8_t * a, uint8x8x3_t b) { 10547 vst3_lane_u8(a, b, 7); 10548 } 10549 10550 // CHECK: test_vst3_lane_u16 10551 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10552 void test_vst3_lane_u16(uint16_t * a, uint16x4x3_t b) { 10553 vst3_lane_u16(a, b, 3); 10554 } 10555 10556 // CHECK: test_vst3_lane_u32 10557 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10558 void test_vst3_lane_u32(uint32_t * a, uint32x2x3_t b) { 10559 vst3_lane_u32(a, b, 1); 10560 } 10561 10562 // CHECK: test_vst3_lane_s8 10563 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10564 void test_vst3_lane_s8(int8_t * a, int8x8x3_t b) { 10565 vst3_lane_s8(a, b, 7); 10566 } 10567 10568 // CHECK: test_vst3_lane_s16 10569 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10570 void test_vst3_lane_s16(int16_t * a, int16x4x3_t b) { 10571 vst3_lane_s16(a, b, 3); 10572 } 10573 10574 // CHECK: test_vst3_lane_s32 10575 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10576 void test_vst3_lane_s32(int32_t * a, int32x2x3_t b) { 10577 vst3_lane_s32(a, b, 1); 10578 } 10579 10580 // CHECK: test_vst3_lane_f16 10581 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10582 void test_vst3_lane_f16(float16_t * a, float16x4x3_t b) { 10583 vst3_lane_f16(a, b, 3); 10584 } 10585 10586 // CHECK: test_vst3_lane_f32 10587 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10588 void test_vst3_lane_f32(float32_t * a, float32x2x3_t b) { 10589 vst3_lane_f32(a, b, 1); 10590 } 10591 10592 // CHECK: test_vst3_lane_p8 10593 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10594 void test_vst3_lane_p8(poly8_t * a, poly8x8x3_t b) { 10595 vst3_lane_p8(a, b, 7); 10596 } 10597 10598 // CHECK: test_vst3_lane_p16 10599 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10600 void test_vst3_lane_p16(poly16_t * a, poly16x4x3_t b) { 10601 vst3_lane_p16(a, b, 3); 10602 } 10603 10604 10605 // CHECK: test_vst4q_u8 10606 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10607 void test_vst4q_u8(uint8_t * a, uint8x16x4_t b) { 10608 vst4q_u8(a, b); 10609 } 10610 10611 // CHECK: test_vst4q_u16 10612 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10613 void test_vst4q_u16(uint16_t * a, uint16x8x4_t b) { 10614 vst4q_u16(a, b); 10615 } 10616 10617 // CHECK: test_vst4q_u32 10618 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10619 void test_vst4q_u32(uint32_t * a, uint32x4x4_t b) { 10620 vst4q_u32(a, b); 10621 } 10622 10623 // CHECK: test_vst4q_s8 10624 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10625 void test_vst4q_s8(int8_t * a, int8x16x4_t b) { 10626 vst4q_s8(a, b); 10627 } 10628 10629 // CHECK: test_vst4q_s16 10630 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10631 void test_vst4q_s16(int16_t * a, int16x8x4_t b) { 10632 vst4q_s16(a, b); 10633 } 10634 10635 // CHECK: test_vst4q_s32 10636 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10637 void test_vst4q_s32(int32_t * a, int32x4x4_t b) { 10638 vst4q_s32(a, b); 10639 } 10640 10641 // CHECK: test_vst4q_f16 10642 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10643 void test_vst4q_f16(float16_t * a, float16x8x4_t b) { 10644 vst4q_f16(a, b); 10645 } 10646 10647 // CHECK: test_vst4q_f32 10648 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10649 void test_vst4q_f32(float32_t * a, float32x4x4_t b) { 10650 vst4q_f32(a, b); 10651 } 10652 10653 // CHECK: test_vst4q_p8 10654 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10655 void test_vst4q_p8(poly8_t * a, poly8x16x4_t b) { 10656 vst4q_p8(a, b); 10657 } 10658 10659 // CHECK: test_vst4q_p16 10660 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10661 void test_vst4q_p16(poly16_t * a, poly16x8x4_t b) { 10662 vst4q_p16(a, b); 10663 } 10664 10665 // CHECK: test_vst4_u8 10666 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10667 void test_vst4_u8(uint8_t * a, uint8x8x4_t b) { 10668 vst4_u8(a, b); 10669 } 10670 10671 // CHECK: test_vst4_u16 10672 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10673 void test_vst4_u16(uint16_t * a, uint16x4x4_t b) { 10674 vst4_u16(a, b); 10675 } 10676 10677 // CHECK: test_vst4_u32 10678 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10679 void test_vst4_u32(uint32_t * a, uint32x2x4_t b) { 10680 vst4_u32(a, b); 10681 } 10682 10683 // CHECK: test_vst4_u64 10684 // CHECK: vst1.64 10685 void test_vst4_u64(uint64_t * a, uint64x1x4_t b) { 10686 vst4_u64(a, b); 10687 } 10688 10689 // CHECK: test_vst4_s8 10690 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10691 void test_vst4_s8(int8_t * a, int8x8x4_t b) { 10692 vst4_s8(a, b); 10693 } 10694 10695 // CHECK: test_vst4_s16 10696 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10697 void test_vst4_s16(int16_t * a, int16x4x4_t b) { 10698 vst4_s16(a, b); 10699 } 10700 10701 // CHECK: test_vst4_s32 10702 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10703 void test_vst4_s32(int32_t * a, int32x2x4_t b) { 10704 vst4_s32(a, b); 10705 } 10706 10707 // CHECK: test_vst4_s64 10708 // CHECK: vst1.64 10709 void test_vst4_s64(int64_t * a, int64x1x4_t b) { 10710 vst4_s64(a, b); 10711 } 10712 10713 // CHECK: test_vst4_f16 10714 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10715 void test_vst4_f16(float16_t * a, float16x4x4_t b) { 10716 vst4_f16(a, b); 10717 } 10718 10719 // CHECK: test_vst4_f32 10720 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10721 void test_vst4_f32(float32_t * a, float32x2x4_t b) { 10722 vst4_f32(a, b); 10723 } 10724 10725 // CHECK: test_vst4_p8 10726 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10727 void test_vst4_p8(poly8_t * a, poly8x8x4_t b) { 10728 vst4_p8(a, b); 10729 } 10730 10731 // CHECK: test_vst4_p16 10732 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10733 void test_vst4_p16(poly16_t * a, poly16x4x4_t b) { 10734 vst4_p16(a, b); 10735 } 10736 10737 10738 // CHECK: test_vst4q_lane_u16 10739 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10740 void test_vst4q_lane_u16(uint16_t * a, uint16x8x4_t b) { 10741 vst4q_lane_u16(a, b, 7); 10742 } 10743 10744 // CHECK: test_vst4q_lane_u32 10745 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10746 void test_vst4q_lane_u32(uint32_t * a, uint32x4x4_t b) { 10747 vst4q_lane_u32(a, b, 3); 10748 } 10749 10750 // CHECK: test_vst4q_lane_s16 10751 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10752 void test_vst4q_lane_s16(int16_t * a, int16x8x4_t b) { 10753 vst4q_lane_s16(a, b, 7); 10754 } 10755 10756 // CHECK: test_vst4q_lane_s32 10757 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10758 void test_vst4q_lane_s32(int32_t * a, int32x4x4_t b) { 10759 vst4q_lane_s32(a, b, 3); 10760 } 10761 10762 // CHECK: test_vst4q_lane_f16 10763 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10764 void test_vst4q_lane_f16(float16_t * a, float16x8x4_t b) { 10765 vst4q_lane_f16(a, b, 7); 10766 } 10767 10768 // CHECK: test_vst4q_lane_f32 10769 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10770 void test_vst4q_lane_f32(float32_t * a, float32x4x4_t b) { 10771 vst4q_lane_f32(a, b, 3); 10772 } 10773 10774 // CHECK: test_vst4q_lane_p16 10775 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10776 void test_vst4q_lane_p16(poly16_t * a, poly16x8x4_t b) { 10777 vst4q_lane_p16(a, b, 7); 10778 } 10779 10780 // CHECK: test_vst4_lane_u8 10781 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10782 void test_vst4_lane_u8(uint8_t * a, uint8x8x4_t b) { 10783 vst4_lane_u8(a, b, 7); 10784 } 10785 10786 // CHECK: test_vst4_lane_u16 10787 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10788 void test_vst4_lane_u16(uint16_t * a, uint16x4x4_t b) { 10789 vst4_lane_u16(a, b, 3); 10790 } 10791 10792 // CHECK: test_vst4_lane_u32 10793 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10794 void test_vst4_lane_u32(uint32_t * a, uint32x2x4_t b) { 10795 vst4_lane_u32(a, b, 1); 10796 } 10797 10798 // CHECK: test_vst4_lane_s8 10799 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10800 void test_vst4_lane_s8(int8_t * a, int8x8x4_t b) { 10801 vst4_lane_s8(a, b, 7); 10802 } 10803 10804 // CHECK: test_vst4_lane_s16 10805 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10806 void test_vst4_lane_s16(int16_t * a, int16x4x4_t b) { 10807 vst4_lane_s16(a, b, 3); 10808 } 10809 10810 // CHECK: test_vst4_lane_s32 10811 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10812 void test_vst4_lane_s32(int32_t * a, int32x2x4_t b) { 10813 vst4_lane_s32(a, b, 1); 10814 } 10815 10816 // CHECK: test_vst4_lane_f16 10817 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10818 void test_vst4_lane_f16(float16_t * a, float16x4x4_t b) { 10819 vst4_lane_f16(a, b, 3); 10820 } 10821 10822 // CHECK: test_vst4_lane_f32 10823 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10824 void test_vst4_lane_f32(float32_t * a, float32x2x4_t b) { 10825 vst4_lane_f32(a, b, 1); 10826 } 10827 10828 // CHECK: test_vst4_lane_p8 10829 // CHECK: vst4.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10830 void test_vst4_lane_p8(poly8_t * a, poly8x8x4_t b) { 10831 vst4_lane_p8(a, b, 7); 10832 } 10833 10834 // CHECK: test_vst4_lane_p16 10835 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10836 void test_vst4_lane_p16(poly16_t * a, poly16x4x4_t b) { 10837 vst4_lane_p16(a, b, 3); 10838 } 10839 10840 10841 // CHECK: test_vsub_s8 10842 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10843 int8x8_t test_vsub_s8(int8x8_t a, int8x8_t b) { 10844 return vsub_s8(a, b); 10845 } 10846 10847 // CHECK: test_vsub_s16 10848 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10849 int16x4_t test_vsub_s16(int16x4_t a, int16x4_t b) { 10850 return vsub_s16(a, b); 10851 } 10852 10853 // CHECK: test_vsub_s32 10854 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10855 int32x2_t test_vsub_s32(int32x2_t a, int32x2_t b) { 10856 return vsub_s32(a, b); 10857 } 10858 10859 // CHECK: test_vsub_s64 10860 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10861 int64x1_t test_vsub_s64(int64x1_t a, int64x1_t b) { 10862 return vsub_s64(a, b); 10863 } 10864 10865 // CHECK: test_vsub_f32 10866 // CHECK: vsub.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10867 float32x2_t test_vsub_f32(float32x2_t a, float32x2_t b) { 10868 return vsub_f32(a, b); 10869 } 10870 10871 // CHECK: test_vsub_u8 10872 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10873 uint8x8_t test_vsub_u8(uint8x8_t a, uint8x8_t b) { 10874 return vsub_u8(a, b); 10875 } 10876 10877 // CHECK: test_vsub_u16 10878 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10879 uint16x4_t test_vsub_u16(uint16x4_t a, uint16x4_t b) { 10880 return vsub_u16(a, b); 10881 } 10882 10883 // CHECK: test_vsub_u32 10884 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10885 uint32x2_t test_vsub_u32(uint32x2_t a, uint32x2_t b) { 10886 return vsub_u32(a, b); 10887 } 10888 10889 // CHECK: test_vsub_u64 10890 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10891 uint64x1_t test_vsub_u64(uint64x1_t a, uint64x1_t b) { 10892 return vsub_u64(a, b); 10893 } 10894 10895 // CHECK: test_vsubq_s8 10896 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10897 int8x16_t test_vsubq_s8(int8x16_t a, int8x16_t b) { 10898 return vsubq_s8(a, b); 10899 } 10900 10901 // CHECK: test_vsubq_s16 10902 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10903 int16x8_t test_vsubq_s16(int16x8_t a, int16x8_t b) { 10904 return vsubq_s16(a, b); 10905 } 10906 10907 // CHECK: test_vsubq_s32 10908 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10909 int32x4_t test_vsubq_s32(int32x4_t a, int32x4_t b) { 10910 return vsubq_s32(a, b); 10911 } 10912 10913 // CHECK: test_vsubq_s64 10914 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10915 int64x2_t test_vsubq_s64(int64x2_t a, int64x2_t b) { 10916 return vsubq_s64(a, b); 10917 } 10918 10919 // CHECK: test_vsubq_f32 10920 // CHECK: vsub.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10921 float32x4_t test_vsubq_f32(float32x4_t a, float32x4_t b) { 10922 return vsubq_f32(a, b); 10923 } 10924 10925 // CHECK: test_vsubq_u8 10926 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10927 uint8x16_t test_vsubq_u8(uint8x16_t a, uint8x16_t b) { 10928 return vsubq_u8(a, b); 10929 } 10930 10931 // CHECK: test_vsubq_u16 10932 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10933 uint16x8_t test_vsubq_u16(uint16x8_t a, uint16x8_t b) { 10934 return vsubq_u16(a, b); 10935 } 10936 10937 // CHECK: test_vsubq_u32 10938 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10939 uint32x4_t test_vsubq_u32(uint32x4_t a, uint32x4_t b) { 10940 return vsubq_u32(a, b); 10941 } 10942 10943 // CHECK: test_vsubq_u64 10944 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10945 uint64x2_t test_vsubq_u64(uint64x2_t a, uint64x2_t b) { 10946 return vsubq_u64(a, b); 10947 } 10948 10949 10950 // CHECK: test_vsubhn_s16 10951 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10952 int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) { 10953 return vsubhn_s16(a, b); 10954 } 10955 10956 // CHECK: test_vsubhn_s32 10957 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10958 int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) { 10959 return vsubhn_s32(a, b); 10960 } 10961 10962 // CHECK: test_vsubhn_s64 10963 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10964 int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) { 10965 return vsubhn_s64(a, b); 10966 } 10967 10968 // CHECK: test_vsubhn_u16 10969 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10970 uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) { 10971 return vsubhn_u16(a, b); 10972 } 10973 10974 // CHECK: test_vsubhn_u32 10975 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10976 uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) { 10977 return vsubhn_u32(a, b); 10978 } 10979 10980 // CHECK: test_vsubhn_u64 10981 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10982 uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) { 10983 return vsubhn_u64(a, b); 10984 } 10985 10986 10987 // CHECK: test_vsubl_s8 10988 // CHECK: vsubl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10989 int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) { 10990 return vsubl_s8(a, b); 10991 } 10992 10993 // CHECK: test_vsubl_s16 10994 // CHECK: vsubl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10995 int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) { 10996 return vsubl_s16(a, b); 10997 } 10998 10999 // CHECK: test_vsubl_s32 11000 // CHECK: vsubl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11001 int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) { 11002 return vsubl_s32(a, b); 11003 } 11004 11005 // CHECK: test_vsubl_u8 11006 // CHECK: vsubl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11007 uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) { 11008 return vsubl_u8(a, b); 11009 } 11010 11011 // CHECK: test_vsubl_u16 11012 // CHECK: vsubl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11013 uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) { 11014 return vsubl_u16(a, b); 11015 } 11016 11017 // CHECK: test_vsubl_u32 11018 // CHECK: vsubl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11019 uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) { 11020 return vsubl_u32(a, b); 11021 } 11022 11023 11024 // CHECK: test_vsubw_s8 11025 // CHECK: vsubw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11026 int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) { 11027 return vsubw_s8(a, b); 11028 } 11029 11030 // CHECK: test_vsubw_s16 11031 // CHECK: vsubw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11032 int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) { 11033 return vsubw_s16(a, b); 11034 } 11035 11036 // CHECK: test_vsubw_s32 11037 // CHECK: vsubw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11038 int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) { 11039 return vsubw_s32(a, b); 11040 } 11041 11042 // CHECK: test_vsubw_u8 11043 // CHECK: vsubw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11044 uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) { 11045 return vsubw_u8(a, b); 11046 } 11047 11048 // CHECK: test_vsubw_u16 11049 // CHECK: vsubw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11050 uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) { 11051 return vsubw_u16(a, b); 11052 } 11053 11054 // CHECK: test_vsubw_u32 11055 // CHECK: vsubw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11056 uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) { 11057 return vsubw_u32(a, b); 11058 } 11059 11060 11061 // CHECK: test_vtbl1_u8 11062 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11063 uint8x8_t test_vtbl1_u8(uint8x8_t a, uint8x8_t b) { 11064 return vtbl1_u8(a, b); 11065 } 11066 11067 // CHECK: test_vtbl1_s8 11068 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11069 int8x8_t test_vtbl1_s8(int8x8_t a, int8x8_t b) { 11070 return vtbl1_s8(a, b); 11071 } 11072 11073 // CHECK: test_vtbl1_p8 11074 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11075 poly8x8_t test_vtbl1_p8(poly8x8_t a, uint8x8_t b) { 11076 return vtbl1_p8(a, b); 11077 } 11078 11079 11080 // CHECK: test_vtbl2_u8 11081 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11082 uint8x8_t test_vtbl2_u8(uint8x8x2_t a, uint8x8_t b) { 11083 return vtbl2_u8(a, b); 11084 } 11085 11086 // CHECK: test_vtbl2_s8 11087 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11088 int8x8_t test_vtbl2_s8(int8x8x2_t a, int8x8_t b) { 11089 return vtbl2_s8(a, b); 11090 } 11091 11092 // CHECK: test_vtbl2_p8 11093 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11094 poly8x8_t test_vtbl2_p8(poly8x8x2_t a, uint8x8_t b) { 11095 return vtbl2_p8(a, b); 11096 } 11097 11098 11099 // CHECK: test_vtbl3_u8 11100 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11101 uint8x8_t test_vtbl3_u8(uint8x8x3_t a, uint8x8_t b) { 11102 return vtbl3_u8(a, b); 11103 } 11104 11105 // CHECK: test_vtbl3_s8 11106 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11107 int8x8_t test_vtbl3_s8(int8x8x3_t a, int8x8_t b) { 11108 return vtbl3_s8(a, b); 11109 } 11110 11111 // CHECK: test_vtbl3_p8 11112 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11113 poly8x8_t test_vtbl3_p8(poly8x8x3_t a, uint8x8_t b) { 11114 return vtbl3_p8(a, b); 11115 } 11116 11117 11118 // CHECK: test_vtbl4_u8 11119 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11120 uint8x8_t test_vtbl4_u8(uint8x8x4_t a, uint8x8_t b) { 11121 return vtbl4_u8(a, b); 11122 } 11123 11124 // CHECK: test_vtbl4_s8 11125 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11126 int8x8_t test_vtbl4_s8(int8x8x4_t a, int8x8_t b) { 11127 return vtbl4_s8(a, b); 11128 } 11129 11130 // CHECK: test_vtbl4_p8 11131 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11132 poly8x8_t test_vtbl4_p8(poly8x8x4_t a, uint8x8_t b) { 11133 return vtbl4_p8(a, b); 11134 } 11135 11136 11137 // CHECK: test_vtbx1_u8 11138 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11139 uint8x8_t test_vtbx1_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 11140 return vtbx1_u8(a, b, c); 11141 } 11142 11143 // CHECK: test_vtbx1_s8 11144 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11145 int8x8_t test_vtbx1_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 11146 return vtbx1_s8(a, b, c); 11147 } 11148 11149 // CHECK: test_vtbx1_p8 11150 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11151 poly8x8_t test_vtbx1_p8(poly8x8_t a, poly8x8_t b, uint8x8_t c) { 11152 return vtbx1_p8(a, b, c); 11153 } 11154 11155 11156 // CHECK: test_vtbx2_u8 11157 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11158 uint8x8_t test_vtbx2_u8(uint8x8_t a, uint8x8x2_t b, uint8x8_t c) { 11159 return vtbx2_u8(a, b, c); 11160 } 11161 11162 // CHECK: test_vtbx2_s8 11163 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11164 int8x8_t test_vtbx2_s8(int8x8_t a, int8x8x2_t b, int8x8_t c) { 11165 return vtbx2_s8(a, b, c); 11166 } 11167 11168 // CHECK: test_vtbx2_p8 11169 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11170 poly8x8_t test_vtbx2_p8(poly8x8_t a, poly8x8x2_t b, uint8x8_t c) { 11171 return vtbx2_p8(a, b, c); 11172 } 11173 11174 11175 // CHECK: test_vtbx3_u8 11176 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11177 uint8x8_t test_vtbx3_u8(uint8x8_t a, uint8x8x3_t b, uint8x8_t c) { 11178 return vtbx3_u8(a, b, c); 11179 } 11180 11181 // CHECK: test_vtbx3_s8 11182 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11183 int8x8_t test_vtbx3_s8(int8x8_t a, int8x8x3_t b, int8x8_t c) { 11184 return vtbx3_s8(a, b, c); 11185 } 11186 11187 // CHECK: test_vtbx3_p8 11188 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11189 poly8x8_t test_vtbx3_p8(poly8x8_t a, poly8x8x3_t b, uint8x8_t c) { 11190 return vtbx3_p8(a, b, c); 11191 } 11192 11193 11194 // CHECK: test_vtbx4_u8 11195 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11196 uint8x8_t test_vtbx4_u8(uint8x8_t a, uint8x8x4_t b, uint8x8_t c) { 11197 return vtbx4_u8(a, b, c); 11198 } 11199 11200 // CHECK: test_vtbx4_s8 11201 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11202 int8x8_t test_vtbx4_s8(int8x8_t a, int8x8x4_t b, int8x8_t c) { 11203 return vtbx4_s8(a, b, c); 11204 } 11205 11206 // CHECK: test_vtbx4_p8 11207 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11208 poly8x8_t test_vtbx4_p8(poly8x8_t a, poly8x8x4_t b, uint8x8_t c) { 11209 return vtbx4_p8(a, b, c); 11210 } 11211 11212 11213 // CHECK: test_vtrn_s8 11214 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11215 int8x8x2_t test_vtrn_s8(int8x8_t a, int8x8_t b) { 11216 return vtrn_s8(a, b); 11217 } 11218 11219 // CHECK: test_vtrn_s16 11220 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11221 int16x4x2_t test_vtrn_s16(int16x4_t a, int16x4_t b) { 11222 return vtrn_s16(a, b); 11223 } 11224 11225 // CHECK: test_vtrn_s32 11226 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11227 int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) { 11228 return vtrn_s32(a, b); 11229 } 11230 11231 // CHECK: test_vtrn_u8 11232 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11233 uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) { 11234 return vtrn_u8(a, b); 11235 } 11236 11237 // CHECK: test_vtrn_u16 11238 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11239 uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) { 11240 return vtrn_u16(a, b); 11241 } 11242 11243 // CHECK: test_vtrn_u32 11244 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11245 uint32x2x2_t test_vtrn_u32(uint32x2_t a, uint32x2_t b) { 11246 return vtrn_u32(a, b); 11247 } 11248 11249 // CHECK: test_vtrn_f32 11250 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11251 float32x2x2_t test_vtrn_f32(float32x2_t a, float32x2_t b) { 11252 return vtrn_f32(a, b); 11253 } 11254 11255 // CHECK: test_vtrn_p8 11256 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11257 poly8x8x2_t test_vtrn_p8(poly8x8_t a, poly8x8_t b) { 11258 return vtrn_p8(a, b); 11259 } 11260 11261 // CHECK: test_vtrn_p16 11262 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11263 poly16x4x2_t test_vtrn_p16(poly16x4_t a, poly16x4_t b) { 11264 return vtrn_p16(a, b); 11265 } 11266 11267 // CHECK: test_vtrnq_s8 11268 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11269 int8x16x2_t test_vtrnq_s8(int8x16_t a, int8x16_t b) { 11270 return vtrnq_s8(a, b); 11271 } 11272 11273 // CHECK: test_vtrnq_s16 11274 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11275 int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) { 11276 return vtrnq_s16(a, b); 11277 } 11278 11279 // CHECK: test_vtrnq_s32 11280 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11281 int32x4x2_t test_vtrnq_s32(int32x4_t a, int32x4_t b) { 11282 return vtrnq_s32(a, b); 11283 } 11284 11285 // CHECK: test_vtrnq_u8 11286 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11287 uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) { 11288 return vtrnq_u8(a, b); 11289 } 11290 11291 // CHECK: test_vtrnq_u16 11292 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11293 uint16x8x2_t test_vtrnq_u16(uint16x8_t a, uint16x8_t b) { 11294 return vtrnq_u16(a, b); 11295 } 11296 11297 // CHECK: test_vtrnq_u32 11298 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11299 uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) { 11300 return vtrnq_u32(a, b); 11301 } 11302 11303 // CHECK: test_vtrnq_f32 11304 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11305 float32x4x2_t test_vtrnq_f32(float32x4_t a, float32x4_t b) { 11306 return vtrnq_f32(a, b); 11307 } 11308 11309 // CHECK: test_vtrnq_p8 11310 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11311 poly8x16x2_t test_vtrnq_p8(poly8x16_t a, poly8x16_t b) { 11312 return vtrnq_p8(a, b); 11313 } 11314 11315 // CHECK: test_vtrnq_p16 11316 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11317 poly16x8x2_t test_vtrnq_p16(poly16x8_t a, poly16x8_t b) { 11318 return vtrnq_p16(a, b); 11319 } 11320 11321 11322 // CHECK: test_vtst_s8 11323 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11324 uint8x8_t test_vtst_s8(int8x8_t a, int8x8_t b) { 11325 return vtst_s8(a, b); 11326 } 11327 11328 // CHECK: test_vtst_s16 11329 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11330 uint16x4_t test_vtst_s16(int16x4_t a, int16x4_t b) { 11331 return vtst_s16(a, b); 11332 } 11333 11334 // CHECK: test_vtst_s32 11335 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11336 uint32x2_t test_vtst_s32(int32x2_t a, int32x2_t b) { 11337 return vtst_s32(a, b); 11338 } 11339 11340 // CHECK: test_vtst_u8 11341 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11342 uint8x8_t test_vtst_u8(uint8x8_t a, uint8x8_t b) { 11343 return vtst_u8(a, b); 11344 } 11345 11346 // CHECK: test_vtst_u16 11347 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11348 uint16x4_t test_vtst_u16(uint16x4_t a, uint16x4_t b) { 11349 return vtst_u16(a, b); 11350 } 11351 11352 // CHECK: test_vtst_u32 11353 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11354 uint32x2_t test_vtst_u32(uint32x2_t a, uint32x2_t b) { 11355 return vtst_u32(a, b); 11356 } 11357 11358 // CHECK: test_vtst_p8 11359 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11360 uint8x8_t test_vtst_p8(poly8x8_t a, poly8x8_t b) { 11361 return vtst_p8(a, b); 11362 } 11363 11364 // CHECK: test_vtstq_s8 11365 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11366 uint8x16_t test_vtstq_s8(int8x16_t a, int8x16_t b) { 11367 return vtstq_s8(a, b); 11368 } 11369 11370 // CHECK: test_vtstq_s16 11371 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11372 uint16x8_t test_vtstq_s16(int16x8_t a, int16x8_t b) { 11373 return vtstq_s16(a, b); 11374 } 11375 11376 // CHECK: test_vtstq_s32 11377 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11378 uint32x4_t test_vtstq_s32(int32x4_t a, int32x4_t b) { 11379 return vtstq_s32(a, b); 11380 } 11381 11382 // CHECK: test_vtstq_u8 11383 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11384 uint8x16_t test_vtstq_u8(uint8x16_t a, uint8x16_t b) { 11385 return vtstq_u8(a, b); 11386 } 11387 11388 // CHECK: test_vtstq_u16 11389 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11390 uint16x8_t test_vtstq_u16(uint16x8_t a, uint16x8_t b) { 11391 return vtstq_u16(a, b); 11392 } 11393 11394 // CHECK: test_vtstq_u32 11395 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11396 uint32x4_t test_vtstq_u32(uint32x4_t a, uint32x4_t b) { 11397 return vtstq_u32(a, b); 11398 } 11399 11400 // CHECK: test_vtstq_p8 11401 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11402 uint8x16_t test_vtstq_p8(poly8x16_t a, poly8x16_t b) { 11403 return vtstq_p8(a, b); 11404 } 11405 11406 11407 // CHECK: test_vuzp_s8 11408 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11409 int8x8x2_t test_vuzp_s8(int8x8_t a, int8x8_t b) { 11410 return vuzp_s8(a, b); 11411 } 11412 11413 // CHECK: test_vuzp_s16 11414 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11415 int16x4x2_t test_vuzp_s16(int16x4_t a, int16x4_t b) { 11416 return vuzp_s16(a, b); 11417 } 11418 11419 // CHECK: test_vuzp_s32 11420 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11421 int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) { 11422 return vuzp_s32(a, b); 11423 } 11424 11425 // CHECK: test_vuzp_u8 11426 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11427 uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) { 11428 return vuzp_u8(a, b); 11429 } 11430 11431 // CHECK: test_vuzp_u16 11432 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11433 uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) { 11434 return vuzp_u16(a, b); 11435 } 11436 11437 // CHECK: test_vuzp_u32 11438 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11439 uint32x2x2_t test_vuzp_u32(uint32x2_t a, uint32x2_t b) { 11440 return vuzp_u32(a, b); 11441 } 11442 11443 // CHECK: test_vuzp_f32 11444 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11445 float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) { 11446 return vuzp_f32(a, b); 11447 } 11448 11449 // CHECK: test_vuzp_p8 11450 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11451 poly8x8x2_t test_vuzp_p8(poly8x8_t a, poly8x8_t b) { 11452 return vuzp_p8(a, b); 11453 } 11454 11455 // CHECK: test_vuzp_p16 11456 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11457 poly16x4x2_t test_vuzp_p16(poly16x4_t a, poly16x4_t b) { 11458 return vuzp_p16(a, b); 11459 } 11460 11461 // CHECK: test_vuzpq_s8 11462 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11463 int8x16x2_t test_vuzpq_s8(int8x16_t a, int8x16_t b) { 11464 return vuzpq_s8(a, b); 11465 } 11466 11467 // CHECK: test_vuzpq_s16 11468 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11469 int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) { 11470 return vuzpq_s16(a, b); 11471 } 11472 11473 // CHECK: test_vuzpq_s32 11474 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11475 int32x4x2_t test_vuzpq_s32(int32x4_t a, int32x4_t b) { 11476 return vuzpq_s32(a, b); 11477 } 11478 11479 // CHECK: test_vuzpq_u8 11480 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11481 uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) { 11482 return vuzpq_u8(a, b); 11483 } 11484 11485 // CHECK: test_vuzpq_u16 11486 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11487 uint16x8x2_t test_vuzpq_u16(uint16x8_t a, uint16x8_t b) { 11488 return vuzpq_u16(a, b); 11489 } 11490 11491 // CHECK: test_vuzpq_u32 11492 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11493 uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) { 11494 return vuzpq_u32(a, b); 11495 } 11496 11497 // CHECK: test_vuzpq_f32 11498 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11499 float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) { 11500 return vuzpq_f32(a, b); 11501 } 11502 11503 // CHECK: test_vuzpq_p8 11504 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11505 poly8x16x2_t test_vuzpq_p8(poly8x16_t a, poly8x16_t b) { 11506 return vuzpq_p8(a, b); 11507 } 11508 11509 // CHECK: test_vuzpq_p16 11510 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11511 poly16x8x2_t test_vuzpq_p16(poly16x8_t a, poly16x8_t b) { 11512 return vuzpq_p16(a, b); 11513 } 11514 11515 11516 // CHECK: test_vzip_s8 11517 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11518 int8x8x2_t test_vzip_s8(int8x8_t a, int8x8_t b) { 11519 return vzip_s8(a, b); 11520 } 11521 11522 // CHECK: test_vzip_s16 11523 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11524 int16x4x2_t test_vzip_s16(int16x4_t a, int16x4_t b) { 11525 return vzip_s16(a, b); 11526 } 11527 11528 // CHECK: test_vzip_s32 11529 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11530 int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) { 11531 return vzip_s32(a, b); 11532 } 11533 11534 // CHECK: test_vzip_u8 11535 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11536 uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) { 11537 return vzip_u8(a, b); 11538 } 11539 11540 // CHECK: test_vzip_u16 11541 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11542 uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) { 11543 return vzip_u16(a, b); 11544 } 11545 11546 // CHECK: test_vzip_u32 11547 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11548 uint32x2x2_t test_vzip_u32(uint32x2_t a, uint32x2_t b) { 11549 return vzip_u32(a, b); 11550 } 11551 11552 // CHECK: test_vzip_f32 11553 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11554 float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) { 11555 return vzip_f32(a, b); 11556 } 11557 11558 // CHECK: test_vzip_p8 11559 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11560 poly8x8x2_t test_vzip_p8(poly8x8_t a, poly8x8_t b) { 11561 return vzip_p8(a, b); 11562 } 11563 11564 // CHECK: test_vzip_p16 11565 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11566 poly16x4x2_t test_vzip_p16(poly16x4_t a, poly16x4_t b) { 11567 return vzip_p16(a, b); 11568 } 11569 11570 // CHECK: test_vzipq_s8 11571 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11572 int8x16x2_t test_vzipq_s8(int8x16_t a, int8x16_t b) { 11573 return vzipq_s8(a, b); 11574 } 11575 11576 // CHECK: test_vzipq_s16 11577 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11578 int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) { 11579 return vzipq_s16(a, b); 11580 } 11581 11582 // CHECK: test_vzipq_s32 11583 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11584 int32x4x2_t test_vzipq_s32(int32x4_t a, int32x4_t b) { 11585 return vzipq_s32(a, b); 11586 } 11587 11588 // CHECK: test_vzipq_u8 11589 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11590 uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) { 11591 return vzipq_u8(a, b); 11592 } 11593 11594 // CHECK: test_vzipq_u16 11595 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11596 uint16x8x2_t test_vzipq_u16(uint16x8_t a, uint16x8_t b) { 11597 return vzipq_u16(a, b); 11598 } 11599 11600 // CHECK: test_vzipq_u32 11601 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11602 uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) { 11603 return vzipq_u32(a, b); 11604 } 11605 11606 // CHECK: test_vzipq_f32 11607 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11608 float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) { 11609 return vzipq_f32(a, b); 11610 } 11611 11612 // CHECK: test_vzipq_p8 11613 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11614 poly8x16x2_t test_vzipq_p8(poly8x16_t a, poly8x16_t b) { 11615 return vzipq_p8(a, b); 11616 } 11617 11618 // CHECK: test_vzipq_p16 11619 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11620 poly16x8x2_t test_vzipq_p16(poly16x8_t a, poly16x8_t b) { 11621 return vzipq_p16(a, b); 11622 } 11623 11624 11625
