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 --check-prefix=CHECK --check-prefix=CHECK-SWIFT 4 // RUN: %clang_cc1 -triple armv8-linux-gnu \ 5 // RUN: -target-cpu cortex-a57 -mfloat-abi soft -ffreestanding -Os -S -o - %s\ 6 // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-A57 7 8 // REQUIRES: long_tests 9 10 #include <arm_neon.h> 11 12 // CHECK-LABEL: test_vaba_s8 13 // CHECK: vaba.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 14 int8x8_t test_vaba_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 15 return vaba_s8(a, b, c); 16 } 17 18 // CHECK-LABEL: test_vaba_s16 19 // CHECK: vaba.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 20 int16x4_t test_vaba_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 21 return vaba_s16(a, b, c); 22 } 23 24 // CHECK-LABEL: test_vaba_s32 25 // CHECK: vaba.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 26 int32x2_t test_vaba_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 27 return vaba_s32(a, b, c); 28 } 29 30 // CHECK-LABEL: test_vaba_u8 31 // CHECK: vaba.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 32 uint8x8_t test_vaba_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 33 return vaba_u8(a, b, c); 34 } 35 36 // CHECK-LABEL: test_vaba_u16 37 // CHECK: vaba.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 38 uint16x4_t test_vaba_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 39 return vaba_u16(a, b, c); 40 } 41 42 // CHECK-LABEL: test_vaba_u32 43 // CHECK: vaba.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 44 uint32x2_t test_vaba_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 45 return vaba_u32(a, b, c); 46 } 47 48 // CHECK-LABEL: test_vabaq_s8 49 // CHECK: vaba.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 50 int8x16_t test_vabaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 51 return vabaq_s8(a, b, c); 52 } 53 54 // CHECK-LABEL: test_vabaq_s16 55 // CHECK: vaba.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 56 int16x8_t test_vabaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 57 return vabaq_s16(a, b, c); 58 } 59 60 // CHECK-LABEL: test_vabaq_s32 61 // CHECK: vaba.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 62 int32x4_t test_vabaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 63 return vabaq_s32(a, b, c); 64 } 65 66 // CHECK-LABEL: test_vabaq_u8 67 // CHECK: vaba.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 68 uint8x16_t test_vabaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 69 return vabaq_u8(a, b, c); 70 } 71 72 // CHECK-LABEL: test_vabaq_u16 73 // CHECK: vaba.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 74 uint16x8_t test_vabaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 75 return vabaq_u16(a, b, c); 76 } 77 78 // CHECK-LABEL: test_vabaq_u32 79 // CHECK: vaba.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 80 uint32x4_t test_vabaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 81 return vabaq_u32(a, b, c); 82 } 83 84 85 // CHECK-LABEL: test_vabal_s8 86 // CHECK: vabal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 87 int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 88 return vabal_s8(a, b, c); 89 } 90 91 // CHECK-LABEL: test_vabal_s16 92 // CHECK: vabal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 93 int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 94 return vabal_s16(a, b, c); 95 } 96 97 // CHECK-LABEL: test_vabal_s32 98 // CHECK: vabal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 99 int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 100 return vabal_s32(a, b, c); 101 } 102 103 // CHECK-LABEL: test_vabal_u8 104 // CHECK: vabal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 105 uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 106 return vabal_u8(a, b, c); 107 } 108 109 // CHECK-LABEL: test_vabal_u16 110 // CHECK: vabal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 111 uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 112 return vabal_u16(a, b, c); 113 } 114 115 // CHECK-LABEL: test_vabal_u32 116 // CHECK: vabal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 117 uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 118 return vabal_u32(a, b, c); 119 } 120 121 122 // CHECK-LABEL: test_vabd_s8 123 // CHECK: vabd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 124 int8x8_t test_vabd_s8(int8x8_t a, int8x8_t b) { 125 return vabd_s8(a, b); 126 } 127 128 // CHECK-LABEL: test_vabd_s16 129 // CHECK: vabd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 130 int16x4_t test_vabd_s16(int16x4_t a, int16x4_t b) { 131 return vabd_s16(a, b); 132 } 133 134 // CHECK-LABEL: test_vabd_s32 135 // CHECK: vabd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 136 int32x2_t test_vabd_s32(int32x2_t a, int32x2_t b) { 137 return vabd_s32(a, b); 138 } 139 140 // CHECK-LABEL: test_vabd_u8 141 // CHECK: vabd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 142 uint8x8_t test_vabd_u8(uint8x8_t a, uint8x8_t b) { 143 return vabd_u8(a, b); 144 } 145 146 // CHECK-LABEL: test_vabd_u16 147 // CHECK: vabd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 148 uint16x4_t test_vabd_u16(uint16x4_t a, uint16x4_t b) { 149 return vabd_u16(a, b); 150 } 151 152 // CHECK-LABEL: test_vabd_u32 153 // CHECK: vabd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 154 uint32x2_t test_vabd_u32(uint32x2_t a, uint32x2_t b) { 155 return vabd_u32(a, b); 156 } 157 158 // CHECK-LABEL: test_vabd_f32 159 // CHECK: vabd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 160 float32x2_t test_vabd_f32(float32x2_t a, float32x2_t b) { 161 return vabd_f32(a, b); 162 } 163 164 // CHECK-LABEL: test_vabdq_s8 165 // CHECK: vabd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 166 int8x16_t test_vabdq_s8(int8x16_t a, int8x16_t b) { 167 return vabdq_s8(a, b); 168 } 169 170 // CHECK-LABEL: test_vabdq_s16 171 // CHECK: vabd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 172 int16x8_t test_vabdq_s16(int16x8_t a, int16x8_t b) { 173 return vabdq_s16(a, b); 174 } 175 176 // CHECK-LABEL: test_vabdq_s32 177 // CHECK: vabd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 178 int32x4_t test_vabdq_s32(int32x4_t a, int32x4_t b) { 179 return vabdq_s32(a, b); 180 } 181 182 // CHECK-LABEL: test_vabdq_u8 183 // CHECK: vabd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 184 uint8x16_t test_vabdq_u8(uint8x16_t a, uint8x16_t b) { 185 return vabdq_u8(a, b); 186 } 187 188 // CHECK-LABEL: test_vabdq_u16 189 // CHECK: vabd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 190 uint16x8_t test_vabdq_u16(uint16x8_t a, uint16x8_t b) { 191 return vabdq_u16(a, b); 192 } 193 194 // CHECK-LABEL: test_vabdq_u32 195 // CHECK: vabd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 196 uint32x4_t test_vabdq_u32(uint32x4_t a, uint32x4_t b) { 197 return vabdq_u32(a, b); 198 } 199 200 // CHECK-LABEL: test_vabdq_f32 201 // CHECK: vabd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 202 float32x4_t test_vabdq_f32(float32x4_t a, float32x4_t b) { 203 return vabdq_f32(a, b); 204 } 205 206 207 // CHECK-LABEL: test_vabdl_s8 208 // CHECK: vabdl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 209 int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) { 210 return vabdl_s8(a, b); 211 } 212 213 // CHECK-LABEL: test_vabdl_s16 214 // CHECK: vabdl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 215 int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) { 216 return vabdl_s16(a, b); 217 } 218 219 // CHECK-LABEL: test_vabdl_s32 220 // CHECK: vabdl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 221 int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) { 222 return vabdl_s32(a, b); 223 } 224 225 // CHECK-LABEL: test_vabdl_u8 226 // CHECK: vabdl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 227 uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) { 228 return vabdl_u8(a, b); 229 } 230 231 // CHECK-LABEL: test_vabdl_u16 232 // CHECK: vabdl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 233 uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) { 234 return vabdl_u16(a, b); 235 } 236 237 // CHECK-LABEL: test_vabdl_u32 238 // CHECK: vabdl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 239 uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) { 240 return vabdl_u32(a, b); 241 } 242 243 244 // CHECK-LABEL: test_vabs_s8 245 // CHECK: vabs.s8 d{{[0-9]+}}, d{{[0-9]+}} 246 int8x8_t test_vabs_s8(int8x8_t a) { 247 return vabs_s8(a); 248 } 249 250 // CHECK-LABEL: test_vabs_s16 251 // CHECK: vabs.s16 d{{[0-9]+}}, d{{[0-9]+}} 252 int16x4_t test_vabs_s16(int16x4_t a) { 253 return vabs_s16(a); 254 } 255 256 // CHECK-LABEL: test_vabs_s32 257 // CHECK: vabs.s32 d{{[0-9]+}}, d{{[0-9]+}} 258 int32x2_t test_vabs_s32(int32x2_t a) { 259 return vabs_s32(a); 260 } 261 262 // CHECK-LABEL: test_vabs_f32 263 // CHECK: vabs.f32 d{{[0-9]+}}, d{{[0-9]+}} 264 float32x2_t test_vabs_f32(float32x2_t a) { 265 return vabs_f32(a); 266 } 267 268 // CHECK-LABEL: test_vabsq_s8 269 // CHECK: vabs.s8 q{{[0-9]+}}, q{{[0-9]+}} 270 int8x16_t test_vabsq_s8(int8x16_t a) { 271 return vabsq_s8(a); 272 } 273 274 // CHECK-LABEL: test_vabsq_s16 275 // CHECK: vabs.s16 q{{[0-9]+}}, q{{[0-9]+}} 276 int16x8_t test_vabsq_s16(int16x8_t a) { 277 return vabsq_s16(a); 278 } 279 280 // CHECK-LABEL: test_vabsq_s32 281 // CHECK: vabs.s32 q{{[0-9]+}}, q{{[0-9]+}} 282 int32x4_t test_vabsq_s32(int32x4_t a) { 283 return vabsq_s32(a); 284 } 285 286 // CHECK-LABEL: test_vabsq_f32 287 // CHECK: vabs.f32 q{{[0-9]+}}, q{{[0-9]+}} 288 float32x4_t test_vabsq_f32(float32x4_t a) { 289 return vabsq_f32(a); 290 } 291 292 293 // CHECK-LABEL: test_vadd_s8 294 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 295 int8x8_t test_vadd_s8(int8x8_t a, int8x8_t b) { 296 return vadd_s8(a, b); 297 } 298 299 // CHECK-LABEL: test_vadd_s16 300 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 301 int16x4_t test_vadd_s16(int16x4_t a, int16x4_t b) { 302 return vadd_s16(a, b); 303 } 304 305 // CHECK-LABEL: test_vadd_s32 306 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 307 int32x2_t test_vadd_s32(int32x2_t a, int32x2_t b) { 308 return vadd_s32(a, b); 309 } 310 311 // CHECK-LABEL: test_vadd_s64 312 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 313 int64x1_t test_vadd_s64(int64x1_t a, int64x1_t b) { 314 return vadd_s64(a, b); 315 } 316 317 // CHECK-LABEL: test_vadd_f32 318 // CHECK: vadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 319 float32x2_t test_vadd_f32(float32x2_t a, float32x2_t b) { 320 return vadd_f32(a, b); 321 } 322 323 // CHECK-LABEL: test_vadd_u8 324 // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 325 uint8x8_t test_vadd_u8(uint8x8_t a, uint8x8_t b) { 326 return vadd_u8(a, b); 327 } 328 329 // CHECK-LABEL: test_vadd_u16 330 // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 331 uint16x4_t test_vadd_u16(uint16x4_t a, uint16x4_t b) { 332 return vadd_u16(a, b); 333 } 334 335 // CHECK-LABEL: test_vadd_u32 336 // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 337 uint32x2_t test_vadd_u32(uint32x2_t a, uint32x2_t b) { 338 return vadd_u32(a, b); 339 } 340 341 // CHECK-LABEL: test_vadd_u64 342 // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 343 uint64x1_t test_vadd_u64(uint64x1_t a, uint64x1_t b) { 344 return vadd_u64(a, b); 345 } 346 347 // CHECK-LABEL: test_vaddq_s8 348 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 349 int8x16_t test_vaddq_s8(int8x16_t a, int8x16_t b) { 350 return vaddq_s8(a, b); 351 } 352 353 // CHECK-LABEL: test_vaddq_s16 354 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 355 int16x8_t test_vaddq_s16(int16x8_t a, int16x8_t b) { 356 return vaddq_s16(a, b); 357 } 358 359 // CHECK-LABEL: test_vaddq_s32 360 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 361 int32x4_t test_vaddq_s32(int32x4_t a, int32x4_t b) { 362 return vaddq_s32(a, b); 363 } 364 365 // CHECK-LABEL: test_vaddq_s64 366 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 367 int64x2_t test_vaddq_s64(int64x2_t a, int64x2_t b) { 368 return vaddq_s64(a, b); 369 } 370 371 // CHECK-LABEL: test_vaddq_f32 372 // CHECK: vadd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 373 float32x4_t test_vaddq_f32(float32x4_t a, float32x4_t b) { 374 return vaddq_f32(a, b); 375 } 376 377 // CHECK-LABEL: test_vaddq_u8 378 // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 379 uint8x16_t test_vaddq_u8(uint8x16_t a, uint8x16_t b) { 380 return vaddq_u8(a, b); 381 } 382 383 // CHECK-LABEL: test_vaddq_u16 384 // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 385 uint16x8_t test_vaddq_u16(uint16x8_t a, uint16x8_t b) { 386 return vaddq_u16(a, b); 387 } 388 389 // CHECK-LABEL: test_vaddq_u32 390 // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 391 uint32x4_t test_vaddq_u32(uint32x4_t a, uint32x4_t b) { 392 return vaddq_u32(a, b); 393 } 394 395 // CHECK-LABEL: test_vaddq_u64 396 // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 397 uint64x2_t test_vaddq_u64(uint64x2_t a, uint64x2_t b) { 398 return vaddq_u64(a, b); 399 } 400 401 402 // CHECK-LABEL: test_vaddhn_s16 403 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 404 int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) { 405 return vaddhn_s16(a, b); 406 } 407 408 // CHECK-LABEL: test_vaddhn_s32 409 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 410 int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) { 411 return vaddhn_s32(a, b); 412 } 413 414 // CHECK-LABEL: test_vaddhn_s64 415 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 416 int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) { 417 return vaddhn_s64(a, b); 418 } 419 420 // CHECK-LABEL: test_vaddhn_u16 421 // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 422 uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) { 423 return vaddhn_u16(a, b); 424 } 425 426 // CHECK-LABEL: test_vaddhn_u32 427 // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 428 uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) { 429 return vaddhn_u32(a, b); 430 } 431 432 // CHECK-LABEL: test_vaddhn_u64 433 // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 434 uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) { 435 return vaddhn_u64(a, b); 436 } 437 438 439 // CHECK-LABEL: test_vaddl_s8 440 // CHECK: vaddl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 441 int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) { 442 return vaddl_s8(a, b); 443 } 444 445 // CHECK-LABEL: test_vaddl_s16 446 // CHECK: vaddl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 447 int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) { 448 return vaddl_s16(a, b); 449 } 450 451 // CHECK-LABEL: test_vaddl_s32 452 // CHECK: vaddl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 453 int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) { 454 return vaddl_s32(a, b); 455 } 456 457 // CHECK-LABEL: test_vaddl_u8 458 // CHECK: vaddl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 459 uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) { 460 return vaddl_u8(a, b); 461 } 462 463 // CHECK-LABEL: test_vaddl_u16 464 // CHECK: vaddl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 465 uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) { 466 return vaddl_u16(a, b); 467 } 468 469 // CHECK-LABEL: test_vaddl_u32 470 // CHECK: vaddl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 471 uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) { 472 return vaddl_u32(a, b); 473 } 474 475 476 // CHECK-LABEL: test_vaddw_s8 477 // CHECK: vaddw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 478 int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) { 479 return vaddw_s8(a, b); 480 } 481 482 // CHECK-LABEL: test_vaddw_s16 483 // CHECK: vaddw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 484 int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) { 485 return vaddw_s16(a, b); 486 } 487 488 // CHECK-LABEL: test_vaddw_s32 489 // CHECK: vaddw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 490 int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) { 491 return vaddw_s32(a, b); 492 } 493 494 // CHECK-LABEL: test_vaddw_u8 495 // CHECK: vaddw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 496 uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) { 497 return vaddw_u8(a, b); 498 } 499 500 // CHECK-LABEL: test_vaddw_u16 501 // CHECK: vaddw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 502 uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) { 503 return vaddw_u16(a, b); 504 } 505 506 // CHECK-LABEL: test_vaddw_u32 507 // CHECK: vaddw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 508 uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) { 509 return vaddw_u32(a, b); 510 } 511 512 513 // CHECK-LABEL: test_vand_s8 514 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 515 int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) { 516 return vand_s8(a, b); 517 } 518 519 // CHECK-LABEL: test_vand_s16 520 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 521 int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) { 522 return vand_s16(a, b); 523 } 524 525 // CHECK-LABEL: test_vand_s32 526 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 527 int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) { 528 return vand_s32(a, b); 529 } 530 531 // CHECK-LABEL: test_vand_s64 532 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 533 int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) { 534 return vand_s64(a, b); 535 } 536 537 // CHECK-LABEL: test_vand_u8 538 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 539 uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) { 540 return vand_u8(a, b); 541 } 542 543 // CHECK-LABEL: test_vand_u16 544 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 545 uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) { 546 return vand_u16(a, b); 547 } 548 549 // CHECK-LABEL: test_vand_u32 550 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 551 uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) { 552 return vand_u32(a, b); 553 } 554 555 // CHECK-LABEL: test_vand_u64 556 // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 557 uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) { 558 return vand_u64(a, b); 559 } 560 561 // CHECK-LABEL: test_vandq_s8 562 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 563 int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) { 564 return vandq_s8(a, b); 565 } 566 567 // CHECK-LABEL: test_vandq_s16 568 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 569 int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) { 570 return vandq_s16(a, b); 571 } 572 573 // CHECK-LABEL: test_vandq_s32 574 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 575 int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) { 576 return vandq_s32(a, b); 577 } 578 579 // CHECK-LABEL: test_vandq_s64 580 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 581 int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) { 582 return vandq_s64(a, b); 583 } 584 585 // CHECK-LABEL: test_vandq_u8 586 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 587 uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) { 588 return vandq_u8(a, b); 589 } 590 591 // CHECK-LABEL: test_vandq_u16 592 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 593 uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) { 594 return vandq_u16(a, b); 595 } 596 597 // CHECK-LABEL: test_vandq_u32 598 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 599 uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) { 600 return vandq_u32(a, b); 601 } 602 603 // CHECK-LABEL: test_vandq_u64 604 // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 605 uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) { 606 return vandq_u64(a, b); 607 } 608 609 610 // CHECK-LABEL: test_vbic_s8 611 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 612 int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) { 613 return vbic_s8(a, b); 614 } 615 616 // CHECK-LABEL: test_vbic_s16 617 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 618 int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) { 619 return vbic_s16(a, b); 620 } 621 622 // CHECK-LABEL: test_vbic_s32 623 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 624 int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) { 625 return vbic_s32(a, b); 626 } 627 628 // CHECK-LABEL: test_vbic_s64 629 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 630 int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) { 631 return vbic_s64(a, b); 632 } 633 634 // CHECK-LABEL: test_vbic_u8 635 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 636 uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) { 637 return vbic_u8(a, b); 638 } 639 640 // CHECK-LABEL: test_vbic_u16 641 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 642 uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) { 643 return vbic_u16(a, b); 644 } 645 646 // CHECK-LABEL: test_vbic_u32 647 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 648 uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) { 649 return vbic_u32(a, b); 650 } 651 652 // CHECK-LABEL: test_vbic_u64 653 // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 654 uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) { 655 return vbic_u64(a, b); 656 } 657 658 // CHECK-LABEL: test_vbicq_s8 659 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 660 int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) { 661 return vbicq_s8(a, b); 662 } 663 664 // CHECK-LABEL: test_vbicq_s16 665 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 666 int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) { 667 return vbicq_s16(a, b); 668 } 669 670 // CHECK-LABEL: test_vbicq_s32 671 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 672 int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) { 673 return vbicq_s32(a, b); 674 } 675 676 // CHECK-LABEL: test_vbicq_s64 677 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 678 int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) { 679 return vbicq_s64(a, b); 680 } 681 682 // CHECK-LABEL: test_vbicq_u8 683 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 684 uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) { 685 return vbicq_u8(a, b); 686 } 687 688 // CHECK-LABEL: test_vbicq_u16 689 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 690 uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) { 691 return vbicq_u16(a, b); 692 } 693 694 // CHECK-LABEL: test_vbicq_u32 695 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 696 uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) { 697 return vbicq_u32(a, b); 698 } 699 700 // CHECK-LABEL: test_vbicq_u64 701 // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 702 uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) { 703 return vbicq_u64(a, b); 704 } 705 706 707 // CHECK-LABEL: test_vbsl_s8 708 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 709 int8x8_t test_vbsl_s8(uint8x8_t a, int8x8_t b, int8x8_t c) { 710 return vbsl_s8(a, b, c); 711 } 712 713 // CHECK-LABEL: test_vbsl_s16 714 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 715 int16x4_t test_vbsl_s16(uint16x4_t a, int16x4_t b, int16x4_t c) { 716 return vbsl_s16(a, b, c); 717 } 718 719 // CHECK-LABEL: test_vbsl_s32 720 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 721 int32x2_t test_vbsl_s32(uint32x2_t a, int32x2_t b, int32x2_t c) { 722 return vbsl_s32(a, b, c); 723 } 724 725 // CHECK-LABEL: test_vbsl_s64 726 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 727 int64x1_t test_vbsl_s64(uint64x1_t a, int64x1_t b, int64x1_t c) { 728 return vbsl_s64(a, b, c); 729 } 730 731 // CHECK-LABEL: test_vbsl_u8 732 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 733 uint8x8_t test_vbsl_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 734 return vbsl_u8(a, b, c); 735 } 736 737 // CHECK-LABEL: test_vbsl_u16 738 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 739 uint16x4_t test_vbsl_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 740 return vbsl_u16(a, b, c); 741 } 742 743 // CHECK-LABEL: test_vbsl_u32 744 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 745 uint32x2_t test_vbsl_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 746 return vbsl_u32(a, b, c); 747 } 748 749 // CHECK-LABEL: test_vbsl_u64 750 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 751 uint64x1_t test_vbsl_u64(uint64x1_t a, uint64x1_t b, uint64x1_t c) { 752 return vbsl_u64(a, b, c); 753 } 754 755 // CHECK-LABEL: test_vbsl_f32 756 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 757 float32x2_t test_vbsl_f32(uint32x2_t a, float32x2_t b, float32x2_t c) { 758 return vbsl_f32(a, b, c); 759 } 760 761 // CHECK-LABEL: test_vbsl_p8 762 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 763 poly8x8_t test_vbsl_p8(uint8x8_t a, poly8x8_t b, poly8x8_t c) { 764 return vbsl_p8(a, b, c); 765 } 766 767 // CHECK-LABEL: test_vbsl_p16 768 // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 769 poly16x4_t test_vbsl_p16(uint16x4_t a, poly16x4_t b, poly16x4_t c) { 770 return vbsl_p16(a, b, c); 771 } 772 773 // CHECK-LABEL: test_vbslq_s8 774 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 775 int8x16_t test_vbslq_s8(uint8x16_t a, int8x16_t b, int8x16_t c) { 776 return vbslq_s8(a, b, c); 777 } 778 779 // CHECK-LABEL: test_vbslq_s16 780 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 781 int16x8_t test_vbslq_s16(uint16x8_t a, int16x8_t b, int16x8_t c) { 782 return vbslq_s16(a, b, c); 783 } 784 785 // CHECK-LABEL: test_vbslq_s32 786 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 787 int32x4_t test_vbslq_s32(uint32x4_t a, int32x4_t b, int32x4_t c) { 788 return vbslq_s32(a, b, c); 789 } 790 791 // CHECK-LABEL: test_vbslq_s64 792 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 793 int64x2_t test_vbslq_s64(uint64x2_t a, int64x2_t b, int64x2_t c) { 794 return vbslq_s64(a, b, c); 795 } 796 797 // CHECK-LABEL: test_vbslq_u8 798 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 799 uint8x16_t test_vbslq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 800 return vbslq_u8(a, b, c); 801 } 802 803 // CHECK-LABEL: test_vbslq_u16 804 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 805 uint16x8_t test_vbslq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 806 return vbslq_u16(a, b, c); 807 } 808 809 // CHECK-LABEL: test_vbslq_u32 810 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 811 uint32x4_t test_vbslq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 812 return vbslq_u32(a, b, c); 813 } 814 815 // CHECK-LABEL: test_vbslq_u64 816 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 817 uint64x2_t test_vbslq_u64(uint64x2_t a, uint64x2_t b, uint64x2_t c) { 818 return vbslq_u64(a, b, c); 819 } 820 821 // CHECK-LABEL: test_vbslq_f32 822 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 823 float32x4_t test_vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) { 824 return vbslq_f32(a, b, c); 825 } 826 827 // CHECK-LABEL: test_vbslq_p8 828 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 829 poly8x16_t test_vbslq_p8(uint8x16_t a, poly8x16_t b, poly8x16_t c) { 830 return vbslq_p8(a, b, c); 831 } 832 833 // CHECK-LABEL: test_vbslq_p16 834 // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 835 poly16x8_t test_vbslq_p16(uint16x8_t a, poly16x8_t b, poly16x8_t c) { 836 return vbslq_p16(a, b, c); 837 } 838 839 840 // CHECK-LABEL: test_vcage_f32 841 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 842 uint32x2_t test_vcage_f32(float32x2_t a, float32x2_t b) { 843 return vcage_f32(a, b); 844 } 845 846 // CHECK-LABEL: test_vcageq_f32 847 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 848 uint32x4_t test_vcageq_f32(float32x4_t a, float32x4_t b) { 849 return vcageq_f32(a, b); 850 } 851 852 853 // CHECK-LABEL: test_vcagt_f32 854 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 855 uint32x2_t test_vcagt_f32(float32x2_t a, float32x2_t b) { 856 return vcagt_f32(a, b); 857 } 858 859 // CHECK-LABEL: test_vcagtq_f32 860 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 861 uint32x4_t test_vcagtq_f32(float32x4_t a, float32x4_t b) { 862 return vcagtq_f32(a, b); 863 } 864 865 866 // CHECK-LABEL: test_vcale_f32 867 // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 868 uint32x2_t test_vcale_f32(float32x2_t a, float32x2_t b) { 869 return vcale_f32(a, b); 870 } 871 872 // CHECK-LABEL: test_vcaleq_f32 873 // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 874 uint32x4_t test_vcaleq_f32(float32x4_t a, float32x4_t b) { 875 return vcaleq_f32(a, b); 876 } 877 878 879 // CHECK-LABEL: test_vcalt_f32 880 // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 881 uint32x2_t test_vcalt_f32(float32x2_t a, float32x2_t b) { 882 return vcalt_f32(a, b); 883 } 884 885 // CHECK-LABEL: test_vcaltq_f32 886 // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 887 uint32x4_t test_vcaltq_f32(float32x4_t a, float32x4_t b) { 888 return vcaltq_f32(a, b); 889 } 890 891 892 // CHECK-LABEL: test_vceq_s8 893 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 894 uint8x8_t test_vceq_s8(int8x8_t a, int8x8_t b) { 895 return vceq_s8(a, b); 896 } 897 898 // CHECK-LABEL: test_vceq_s16 899 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 900 uint16x4_t test_vceq_s16(int16x4_t a, int16x4_t b) { 901 return vceq_s16(a, b); 902 } 903 904 // CHECK-LABEL: test_vceq_s32 905 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 906 uint32x2_t test_vceq_s32(int32x2_t a, int32x2_t b) { 907 return vceq_s32(a, b); 908 } 909 910 // CHECK-LABEL: test_vceq_f32 911 // CHECK: vceq.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 912 uint32x2_t test_vceq_f32(float32x2_t a, float32x2_t b) { 913 return vceq_f32(a, b); 914 } 915 916 // CHECK-LABEL: test_vceq_u8 917 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 918 uint8x8_t test_vceq_u8(uint8x8_t a, uint8x8_t b) { 919 return vceq_u8(a, b); 920 } 921 922 // CHECK-LABEL: test_vceq_u16 923 // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 924 uint16x4_t test_vceq_u16(uint16x4_t a, uint16x4_t b) { 925 return vceq_u16(a, b); 926 } 927 928 // CHECK-LABEL: test_vceq_u32 929 // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 930 uint32x2_t test_vceq_u32(uint32x2_t a, uint32x2_t b) { 931 return vceq_u32(a, b); 932 } 933 934 // CHECK-LABEL: test_vceq_p8 935 // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 936 uint8x8_t test_vceq_p8(poly8x8_t a, poly8x8_t b) { 937 return vceq_p8(a, b); 938 } 939 940 // CHECK-LABEL: test_vceqq_s8 941 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 942 uint8x16_t test_vceqq_s8(int8x16_t a, int8x16_t b) { 943 return vceqq_s8(a, b); 944 } 945 946 // CHECK-LABEL: test_vceqq_s16 947 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 948 uint16x8_t test_vceqq_s16(int16x8_t a, int16x8_t b) { 949 return vceqq_s16(a, b); 950 } 951 952 // CHECK-LABEL: test_vceqq_s32 953 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 954 uint32x4_t test_vceqq_s32(int32x4_t a, int32x4_t b) { 955 return vceqq_s32(a, b); 956 } 957 958 // CHECK-LABEL: test_vceqq_f32 959 // CHECK: vceq.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 960 uint32x4_t test_vceqq_f32(float32x4_t a, float32x4_t b) { 961 return vceqq_f32(a, b); 962 } 963 964 // CHECK-LABEL: test_vceqq_u8 965 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 966 uint8x16_t test_vceqq_u8(uint8x16_t a, uint8x16_t b) { 967 return vceqq_u8(a, b); 968 } 969 970 // CHECK-LABEL: test_vceqq_u16 971 // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 972 uint16x8_t test_vceqq_u16(uint16x8_t a, uint16x8_t b) { 973 return vceqq_u16(a, b); 974 } 975 976 // CHECK-LABEL: test_vceqq_u32 977 // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 978 uint32x4_t test_vceqq_u32(uint32x4_t a, uint32x4_t b) { 979 return vceqq_u32(a, b); 980 } 981 982 // CHECK-LABEL: test_vceqq_p8 983 // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 984 uint8x16_t test_vceqq_p8(poly8x16_t a, poly8x16_t b) { 985 return vceqq_p8(a, b); 986 } 987 988 989 // CHECK-LABEL: test_vcge_s8 990 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 991 uint8x8_t test_vcge_s8(int8x8_t a, int8x8_t b) { 992 return vcge_s8(a, b); 993 } 994 995 // CHECK-LABEL: test_vcge_s16 996 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 997 uint16x4_t test_vcge_s16(int16x4_t a, int16x4_t b) { 998 return vcge_s16(a, b); 999 } 1000 1001 // CHECK-LABEL: test_vcge_s32 1002 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1003 uint32x2_t test_vcge_s32(int32x2_t a, int32x2_t b) { 1004 return vcge_s32(a, b); 1005 } 1006 1007 // CHECK-LABEL: test_vcge_f32 1008 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1009 uint32x2_t test_vcge_f32(float32x2_t a, float32x2_t b) { 1010 return vcge_f32(a, b); 1011 } 1012 1013 // CHECK-LABEL: test_vcge_u8 1014 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1015 uint8x8_t test_vcge_u8(uint8x8_t a, uint8x8_t b) { 1016 return vcge_u8(a, b); 1017 } 1018 1019 // CHECK-LABEL: test_vcge_u16 1020 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1021 uint16x4_t test_vcge_u16(uint16x4_t a, uint16x4_t b) { 1022 return vcge_u16(a, b); 1023 } 1024 1025 // CHECK-LABEL: test_vcge_u32 1026 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1027 uint32x2_t test_vcge_u32(uint32x2_t a, uint32x2_t b) { 1028 return vcge_u32(a, b); 1029 } 1030 1031 // CHECK-LABEL: test_vcgeq_s8 1032 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1033 uint8x16_t test_vcgeq_s8(int8x16_t a, int8x16_t b) { 1034 return vcgeq_s8(a, b); 1035 } 1036 1037 // CHECK-LABEL: test_vcgeq_s16 1038 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1039 uint16x8_t test_vcgeq_s16(int16x8_t a, int16x8_t b) { 1040 return vcgeq_s16(a, b); 1041 } 1042 1043 // CHECK-LABEL: test_vcgeq_s32 1044 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1045 uint32x4_t test_vcgeq_s32(int32x4_t a, int32x4_t b) { 1046 return vcgeq_s32(a, b); 1047 } 1048 1049 // CHECK-LABEL: test_vcgeq_f32 1050 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1051 uint32x4_t test_vcgeq_f32(float32x4_t a, float32x4_t b) { 1052 return vcgeq_f32(a, b); 1053 } 1054 1055 // CHECK-LABEL: test_vcgeq_u8 1056 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1057 uint8x16_t test_vcgeq_u8(uint8x16_t a, uint8x16_t b) { 1058 return vcgeq_u8(a, b); 1059 } 1060 1061 // CHECK-LABEL: test_vcgeq_u16 1062 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1063 uint16x8_t test_vcgeq_u16(uint16x8_t a, uint16x8_t b) { 1064 return vcgeq_u16(a, b); 1065 } 1066 1067 // CHECK-LABEL: test_vcgeq_u32 1068 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1069 uint32x4_t test_vcgeq_u32(uint32x4_t a, uint32x4_t b) { 1070 return vcgeq_u32(a, b); 1071 } 1072 1073 1074 // CHECK-LABEL: test_vcgt_s8 1075 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1076 uint8x8_t test_vcgt_s8(int8x8_t a, int8x8_t b) { 1077 return vcgt_s8(a, b); 1078 } 1079 1080 // CHECK-LABEL: test_vcgt_s16 1081 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1082 uint16x4_t test_vcgt_s16(int16x4_t a, int16x4_t b) { 1083 return vcgt_s16(a, b); 1084 } 1085 1086 // CHECK-LABEL: test_vcgt_s32 1087 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1088 uint32x2_t test_vcgt_s32(int32x2_t a, int32x2_t b) { 1089 return vcgt_s32(a, b); 1090 } 1091 1092 // CHECK-LABEL: test_vcgt_f32 1093 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1094 uint32x2_t test_vcgt_f32(float32x2_t a, float32x2_t b) { 1095 return vcgt_f32(a, b); 1096 } 1097 1098 // CHECK-LABEL: test_vcgt_u8 1099 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1100 uint8x8_t test_vcgt_u8(uint8x8_t a, uint8x8_t b) { 1101 return vcgt_u8(a, b); 1102 } 1103 1104 // CHECK-LABEL: test_vcgt_u16 1105 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1106 uint16x4_t test_vcgt_u16(uint16x4_t a, uint16x4_t b) { 1107 return vcgt_u16(a, b); 1108 } 1109 1110 // CHECK-LABEL: test_vcgt_u32 1111 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1112 uint32x2_t test_vcgt_u32(uint32x2_t a, uint32x2_t b) { 1113 return vcgt_u32(a, b); 1114 } 1115 1116 // CHECK-LABEL: test_vcgtq_s8 1117 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1118 uint8x16_t test_vcgtq_s8(int8x16_t a, int8x16_t b) { 1119 return vcgtq_s8(a, b); 1120 } 1121 1122 // CHECK-LABEL: test_vcgtq_s16 1123 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1124 uint16x8_t test_vcgtq_s16(int16x8_t a, int16x8_t b) { 1125 return vcgtq_s16(a, b); 1126 } 1127 1128 // CHECK-LABEL: test_vcgtq_s32 1129 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1130 uint32x4_t test_vcgtq_s32(int32x4_t a, int32x4_t b) { 1131 return vcgtq_s32(a, b); 1132 } 1133 1134 // CHECK-LABEL: test_vcgtq_f32 1135 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1136 uint32x4_t test_vcgtq_f32(float32x4_t a, float32x4_t b) { 1137 return vcgtq_f32(a, b); 1138 } 1139 1140 // CHECK-LABEL: test_vcgtq_u8 1141 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1142 uint8x16_t test_vcgtq_u8(uint8x16_t a, uint8x16_t b) { 1143 return vcgtq_u8(a, b); 1144 } 1145 1146 // CHECK-LABEL: test_vcgtq_u16 1147 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1148 uint16x8_t test_vcgtq_u16(uint16x8_t a, uint16x8_t b) { 1149 return vcgtq_u16(a, b); 1150 } 1151 1152 // CHECK-LABEL: test_vcgtq_u32 1153 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1154 uint32x4_t test_vcgtq_u32(uint32x4_t a, uint32x4_t b) { 1155 return vcgtq_u32(a, b); 1156 } 1157 1158 1159 // CHECK-LABEL: test_vcle_s8 1160 // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1161 uint8x8_t test_vcle_s8(int8x8_t a, int8x8_t b) { 1162 return vcle_s8(a, b); 1163 } 1164 1165 // CHECK-LABEL: test_vcle_s16 1166 // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1167 uint16x4_t test_vcle_s16(int16x4_t a, int16x4_t b) { 1168 return vcle_s16(a, b); 1169 } 1170 1171 // CHECK-LABEL: test_vcle_s32 1172 // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1173 uint32x2_t test_vcle_s32(int32x2_t a, int32x2_t b) { 1174 return vcle_s32(a, b); 1175 } 1176 1177 // CHECK-LABEL: test_vcle_f32 1178 // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1179 uint32x2_t test_vcle_f32(float32x2_t a, float32x2_t b) { 1180 return vcle_f32(a, b); 1181 } 1182 1183 // CHECK-LABEL: test_vcle_u8 1184 // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1185 uint8x8_t test_vcle_u8(uint8x8_t a, uint8x8_t b) { 1186 return vcle_u8(a, b); 1187 } 1188 1189 // CHECK-LABEL: test_vcle_u16 1190 // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1191 uint16x4_t test_vcle_u16(uint16x4_t a, uint16x4_t b) { 1192 return vcle_u16(a, b); 1193 } 1194 1195 // CHECK-LABEL: test_vcle_u32 1196 // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1197 uint32x2_t test_vcle_u32(uint32x2_t a, uint32x2_t b) { 1198 return vcle_u32(a, b); 1199 } 1200 1201 // CHECK-LABEL: test_vcleq_s8 1202 // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1203 uint8x16_t test_vcleq_s8(int8x16_t a, int8x16_t b) { 1204 return vcleq_s8(a, b); 1205 } 1206 1207 // CHECK-LABEL: test_vcleq_s16 1208 // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1209 uint16x8_t test_vcleq_s16(int16x8_t a, int16x8_t b) { 1210 return vcleq_s16(a, b); 1211 } 1212 1213 // CHECK-LABEL: test_vcleq_s32 1214 // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1215 uint32x4_t test_vcleq_s32(int32x4_t a, int32x4_t b) { 1216 return vcleq_s32(a, b); 1217 } 1218 1219 // CHECK-LABEL: test_vcleq_f32 1220 // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1221 uint32x4_t test_vcleq_f32(float32x4_t a, float32x4_t b) { 1222 return vcleq_f32(a, b); 1223 } 1224 1225 // CHECK-LABEL: test_vcleq_u8 1226 // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1227 uint8x16_t test_vcleq_u8(uint8x16_t a, uint8x16_t b) { 1228 return vcleq_u8(a, b); 1229 } 1230 1231 // CHECK-LABEL: test_vcleq_u16 1232 // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1233 uint16x8_t test_vcleq_u16(uint16x8_t a, uint16x8_t b) { 1234 return vcleq_u16(a, b); 1235 } 1236 1237 // CHECK-LABEL: test_vcleq_u32 1238 // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1239 uint32x4_t test_vcleq_u32(uint32x4_t a, uint32x4_t b) { 1240 return vcleq_u32(a, b); 1241 } 1242 1243 1244 // CHECK-LABEL: test_vcls_s8 1245 // CHECK: vcls.s8 d{{[0-9]+}}, d{{[0-9]+}} 1246 int8x8_t test_vcls_s8(int8x8_t a) { 1247 return vcls_s8(a); 1248 } 1249 1250 // CHECK-LABEL: test_vcls_s16 1251 // CHECK: vcls.s16 d{{[0-9]+}}, d{{[0-9]+}} 1252 int16x4_t test_vcls_s16(int16x4_t a) { 1253 return vcls_s16(a); 1254 } 1255 1256 // CHECK-LABEL: test_vcls_s32 1257 // CHECK: vcls.s32 d{{[0-9]+}}, d{{[0-9]+}} 1258 int32x2_t test_vcls_s32(int32x2_t a) { 1259 return vcls_s32(a); 1260 } 1261 1262 // CHECK-LABEL: test_vclsq_s8 1263 // CHECK: vcls.s8 q{{[0-9]+}}, q{{[0-9]+}} 1264 int8x16_t test_vclsq_s8(int8x16_t a) { 1265 return vclsq_s8(a); 1266 } 1267 1268 // CHECK-LABEL: test_vclsq_s16 1269 // CHECK: vcls.s16 q{{[0-9]+}}, q{{[0-9]+}} 1270 int16x8_t test_vclsq_s16(int16x8_t a) { 1271 return vclsq_s16(a); 1272 } 1273 1274 // CHECK-LABEL: test_vclsq_s32 1275 // CHECK: vcls.s32 q{{[0-9]+}}, q{{[0-9]+}} 1276 int32x4_t test_vclsq_s32(int32x4_t a) { 1277 return vclsq_s32(a); 1278 } 1279 1280 1281 // CHECK-LABEL: test_vclt_s8 1282 // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1283 uint8x8_t test_vclt_s8(int8x8_t a, int8x8_t b) { 1284 return vclt_s8(a, b); 1285 } 1286 1287 // CHECK-LABEL: test_vclt_s16 1288 // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1289 uint16x4_t test_vclt_s16(int16x4_t a, int16x4_t b) { 1290 return vclt_s16(a, b); 1291 } 1292 1293 // CHECK-LABEL: test_vclt_s32 1294 // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1295 uint32x2_t test_vclt_s32(int32x2_t a, int32x2_t b) { 1296 return vclt_s32(a, b); 1297 } 1298 1299 // CHECK-LABEL: test_vclt_f32 1300 // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1301 uint32x2_t test_vclt_f32(float32x2_t a, float32x2_t b) { 1302 return vclt_f32(a, b); 1303 } 1304 1305 // CHECK-LABEL: test_vclt_u8 1306 // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1307 uint8x8_t test_vclt_u8(uint8x8_t a, uint8x8_t b) { 1308 return vclt_u8(a, b); 1309 } 1310 1311 // CHECK-LABEL: test_vclt_u16 1312 // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1313 uint16x4_t test_vclt_u16(uint16x4_t a, uint16x4_t b) { 1314 return vclt_u16(a, b); 1315 } 1316 1317 // CHECK-LABEL: test_vclt_u32 1318 // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1319 uint32x2_t test_vclt_u32(uint32x2_t a, uint32x2_t b) { 1320 return vclt_u32(a, b); 1321 } 1322 1323 // CHECK-LABEL: test_vcltq_s8 1324 // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1325 uint8x16_t test_vcltq_s8(int8x16_t a, int8x16_t b) { 1326 return vcltq_s8(a, b); 1327 } 1328 1329 // CHECK-LABEL: test_vcltq_s16 1330 // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1331 uint16x8_t test_vcltq_s16(int16x8_t a, int16x8_t b) { 1332 return vcltq_s16(a, b); 1333 } 1334 1335 // CHECK-LABEL: test_vcltq_s32 1336 // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1337 uint32x4_t test_vcltq_s32(int32x4_t a, int32x4_t b) { 1338 return vcltq_s32(a, b); 1339 } 1340 1341 // CHECK-LABEL: test_vcltq_f32 1342 // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1343 uint32x4_t test_vcltq_f32(float32x4_t a, float32x4_t b) { 1344 return vcltq_f32(a, b); 1345 } 1346 1347 // CHECK-LABEL: test_vcltq_u8 1348 // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1349 uint8x16_t test_vcltq_u8(uint8x16_t a, uint8x16_t b) { 1350 return vcltq_u8(a, b); 1351 } 1352 1353 // CHECK-LABEL: test_vcltq_u16 1354 // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1355 uint16x8_t test_vcltq_u16(uint16x8_t a, uint16x8_t b) { 1356 return vcltq_u16(a, b); 1357 } 1358 1359 // CHECK-LABEL: test_vcltq_u32 1360 // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 1361 uint32x4_t test_vcltq_u32(uint32x4_t a, uint32x4_t b) { 1362 return vcltq_u32(a, b); 1363 } 1364 1365 1366 // CHECK-LABEL: test_vclz_s8 1367 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} 1368 int8x8_t test_vclz_s8(int8x8_t a) { 1369 return vclz_s8(a); 1370 } 1371 1372 // CHECK-LABEL: test_vclz_s16 1373 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} 1374 int16x4_t test_vclz_s16(int16x4_t a) { 1375 return vclz_s16(a); 1376 } 1377 1378 // CHECK-LABEL: test_vclz_s32 1379 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} 1380 int32x2_t test_vclz_s32(int32x2_t a) { 1381 return vclz_s32(a); 1382 } 1383 1384 // CHECK-LABEL: test_vclz_u8 1385 // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} 1386 uint8x8_t test_vclz_u8(uint8x8_t a) { 1387 return vclz_u8(a); 1388 } 1389 1390 // CHECK-LABEL: test_vclz_u16 1391 // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} 1392 uint16x4_t test_vclz_u16(uint16x4_t a) { 1393 return vclz_u16(a); 1394 } 1395 1396 // CHECK-LABEL: test_vclz_u32 1397 // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} 1398 uint32x2_t test_vclz_u32(uint32x2_t a) { 1399 return vclz_u32(a); 1400 } 1401 1402 // CHECK-LABEL: test_vclzq_s8 1403 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} 1404 int8x16_t test_vclzq_s8(int8x16_t a) { 1405 return vclzq_s8(a); 1406 } 1407 1408 // CHECK-LABEL: test_vclzq_s16 1409 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} 1410 int16x8_t test_vclzq_s16(int16x8_t a) { 1411 return vclzq_s16(a); 1412 } 1413 1414 // CHECK-LABEL: test_vclzq_s32 1415 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} 1416 int32x4_t test_vclzq_s32(int32x4_t a) { 1417 return vclzq_s32(a); 1418 } 1419 1420 // CHECK-LABEL: test_vclzq_u8 1421 // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} 1422 uint8x16_t test_vclzq_u8(uint8x16_t a) { 1423 return vclzq_u8(a); 1424 } 1425 1426 // CHECK-LABEL: test_vclzq_u16 1427 // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} 1428 uint16x8_t test_vclzq_u16(uint16x8_t a) { 1429 return vclzq_u16(a); 1430 } 1431 1432 // CHECK-LABEL: test_vclzq_u32 1433 // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} 1434 uint32x4_t test_vclzq_u32(uint32x4_t a) { 1435 return vclzq_u32(a); 1436 } 1437 1438 1439 // CHECK-LABEL: test_vcnt_u8 1440 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1441 uint8x8_t test_vcnt_u8(uint8x8_t a) { 1442 return vcnt_u8(a); 1443 } 1444 1445 // CHECK-LABEL: test_vcnt_s8 1446 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1447 int8x8_t test_vcnt_s8(int8x8_t a) { 1448 return vcnt_s8(a); 1449 } 1450 1451 // CHECK-LABEL: test_vcnt_p8 1452 // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} 1453 poly8x8_t test_vcnt_p8(poly8x8_t a) { 1454 return vcnt_p8(a); 1455 } 1456 1457 // CHECK-LABEL: test_vcntq_u8 1458 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1459 uint8x16_t test_vcntq_u8(uint8x16_t a) { 1460 return vcntq_u8(a); 1461 } 1462 1463 // CHECK-LABEL: test_vcntq_s8 1464 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1465 int8x16_t test_vcntq_s8(int8x16_t a) { 1466 return vcntq_s8(a); 1467 } 1468 1469 // CHECK-LABEL: test_vcntq_p8 1470 // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} 1471 poly8x16_t test_vcntq_p8(poly8x16_t a) { 1472 return vcntq_p8(a); 1473 } 1474 1475 1476 // CHECK-LABEL: test_vcombine_s8 1477 int8x16_t test_vcombine_s8(int8x8_t a, int8x8_t b) { 1478 return vcombine_s8(a, b); 1479 } 1480 1481 // CHECK-LABEL: test_vcombine_s16 1482 int16x8_t test_vcombine_s16(int16x4_t a, int16x4_t b) { 1483 return vcombine_s16(a, b); 1484 } 1485 1486 // CHECK-LABEL: test_vcombine_s32 1487 int32x4_t test_vcombine_s32(int32x2_t a, int32x2_t b) { 1488 return vcombine_s32(a, b); 1489 } 1490 1491 // CHECK-LABEL: test_vcombine_s64 1492 int64x2_t test_vcombine_s64(int64x1_t a, int64x1_t b) { 1493 return vcombine_s64(a, b); 1494 } 1495 1496 // CHECK-LABEL: test_vcombine_f16 1497 float16x8_t test_vcombine_f16(float16x4_t a, float16x4_t b) { 1498 return vcombine_f16(a, b); 1499 } 1500 1501 // CHECK-LABEL: test_vcombine_f32 1502 float32x4_t test_vcombine_f32(float32x2_t a, float32x2_t b) { 1503 return vcombine_f32(a, b); 1504 } 1505 1506 // CHECK-LABEL: test_vcombine_u8 1507 uint8x16_t test_vcombine_u8(uint8x8_t a, uint8x8_t b) { 1508 return vcombine_u8(a, b); 1509 } 1510 1511 // CHECK-LABEL: test_vcombine_u16 1512 uint16x8_t test_vcombine_u16(uint16x4_t a, uint16x4_t b) { 1513 return vcombine_u16(a, b); 1514 } 1515 1516 // CHECK-LABEL: test_vcombine_u32 1517 uint32x4_t test_vcombine_u32(uint32x2_t a, uint32x2_t b) { 1518 return vcombine_u32(a, b); 1519 } 1520 1521 // CHECK-LABEL: test_vcombine_u64 1522 uint64x2_t test_vcombine_u64(uint64x1_t a, uint64x1_t b) { 1523 return vcombine_u64(a, b); 1524 } 1525 1526 // CHECK-LABEL: test_vcombine_p8 1527 poly8x16_t test_vcombine_p8(poly8x8_t a, poly8x8_t b) { 1528 return vcombine_p8(a, b); 1529 } 1530 1531 // CHECK-LABEL: test_vcombine_p16 1532 poly16x8_t test_vcombine_p16(poly16x4_t a, poly16x4_t b) { 1533 return vcombine_p16(a, b); 1534 } 1535 1536 1537 // CHECK-LABEL: test_vcreate_s8 1538 int8x8_t test_vcreate_s8(uint64_t a) { 1539 return vcreate_s8(a); 1540 } 1541 1542 // CHECK-LABEL: test_vcreate_s16 1543 int16x4_t test_vcreate_s16(uint64_t a) { 1544 return vcreate_s16(a); 1545 } 1546 1547 // CHECK-LABEL: test_vcreate_s32 1548 int32x2_t test_vcreate_s32(uint64_t a) { 1549 return vcreate_s32(a); 1550 } 1551 1552 // CHECK-LABEL: test_vcreate_f16 1553 float16x4_t test_vcreate_f16(uint64_t a) { 1554 return vcreate_f16(a); 1555 } 1556 1557 // CHECK-LABEL: test_vcreate_f32 1558 float32x2_t test_vcreate_f32(uint64_t a) { 1559 return vcreate_f32(a); 1560 } 1561 1562 // CHECK-LABEL: test_vcreate_u8 1563 uint8x8_t test_vcreate_u8(uint64_t a) { 1564 return vcreate_u8(a); 1565 } 1566 1567 // CHECK-LABEL: test_vcreate_u16 1568 uint16x4_t test_vcreate_u16(uint64_t a) { 1569 return vcreate_u16(a); 1570 } 1571 1572 // CHECK-LABEL: test_vcreate_u32 1573 uint32x2_t test_vcreate_u32(uint64_t a) { 1574 return vcreate_u32(a); 1575 } 1576 1577 // CHECK-LABEL: test_vcreate_u64 1578 uint64x1_t test_vcreate_u64(uint64_t a) { 1579 return vcreate_u64(a); 1580 } 1581 1582 // CHECK-LABEL: test_vcreate_p8 1583 poly8x8_t test_vcreate_p8(uint64_t a) { 1584 return vcreate_p8(a); 1585 } 1586 1587 // CHECK-LABEL: test_vcreate_p16 1588 poly16x4_t test_vcreate_p16(uint64_t a) { 1589 return vcreate_p16(a); 1590 } 1591 1592 // CHECK-LABEL: test_vcreate_s64 1593 int64x1_t test_vcreate_s64(uint64_t a) { 1594 return vcreate_s64(a); 1595 } 1596 1597 1598 // CHECK-LABEL: test_vcvt_f16_f32 1599 // CHECK: vcvt.f16.f32 d{{[0-9]+}}, q{{[0-9]+}} 1600 float16x4_t test_vcvt_f16_f32(float32x4_t a) { 1601 return vcvt_f16_f32(a); 1602 } 1603 1604 1605 // CHECK-LABEL: test_vcvt_f32_s32 1606 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}} 1607 float32x2_t test_vcvt_f32_s32(int32x2_t a) { 1608 return vcvt_f32_s32(a); 1609 } 1610 1611 // CHECK-LABEL: test_vcvt_f32_u32 1612 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}} 1613 float32x2_t test_vcvt_f32_u32(uint32x2_t a) { 1614 return vcvt_f32_u32(a); 1615 } 1616 1617 // CHECK-LABEL: test_vcvtq_f32_s32 1618 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}} 1619 float32x4_t test_vcvtq_f32_s32(int32x4_t a) { 1620 return vcvtq_f32_s32(a); 1621 } 1622 1623 // CHECK-LABEL: test_vcvtq_f32_u32 1624 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}} 1625 float32x4_t test_vcvtq_f32_u32(uint32x4_t a) { 1626 return vcvtq_f32_u32(a); 1627 } 1628 1629 1630 // CHECK-LABEL: test_vcvt_f32_f16 1631 // CHECK: vcvt.f32.f16 1632 float32x4_t test_vcvt_f32_f16(float16x4_t a) { 1633 return vcvt_f32_f16(a); 1634 } 1635 1636 1637 // CHECK-LABEL: test_vcvt_n_f32_s32 1638 // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1639 float32x2_t test_vcvt_n_f32_s32(int32x2_t a) { 1640 return vcvt_n_f32_s32(a, 1); 1641 } 1642 1643 // CHECK-LABEL: test_vcvt_n_f32_u32 1644 // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1645 float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) { 1646 return vcvt_n_f32_u32(a, 1); 1647 } 1648 1649 // CHECK-LABEL: test_vcvtq_n_f32_s32 1650 // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1651 float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) { 1652 return vcvtq_n_f32_s32(a, 3); 1653 } 1654 1655 // CHECK-LABEL: test_vcvtq_n_f32_u32 1656 // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1657 float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) { 1658 return vcvtq_n_f32_u32(a, 3); 1659 } 1660 1661 1662 // CHECK-LABEL: test_vcvt_n_s32_f32 1663 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1664 int32x2_t test_vcvt_n_s32_f32(float32x2_t a) { 1665 return vcvt_n_s32_f32(a, 1); 1666 } 1667 1668 // CHECK-LABEL: test_vcvtq_n_s32_f32 1669 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1670 int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) { 1671 return vcvtq_n_s32_f32(a, 3); 1672 } 1673 1674 1675 // CHECK-LABEL: test_vcvt_n_u32_f32 1676 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 1677 uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) { 1678 return vcvt_n_u32_f32(a, 1); 1679 } 1680 1681 // CHECK-LABEL: test_vcvtq_n_u32_f32 1682 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 1683 uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) { 1684 return vcvtq_n_u32_f32(a, 3); 1685 } 1686 1687 1688 // CHECK-LABEL: test_vcvt_s32_f32 1689 // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}} 1690 int32x2_t test_vcvt_s32_f32(float32x2_t a) { 1691 return vcvt_s32_f32(a); 1692 } 1693 1694 // CHECK-LABEL: test_vcvtq_s32_f32 1695 // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}} 1696 int32x4_t test_vcvtq_s32_f32(float32x4_t a) { 1697 return vcvtq_s32_f32(a); 1698 } 1699 1700 1701 // CHECK-LABEL: test_vcvt_u32_f32 1702 // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}} 1703 uint32x2_t test_vcvt_u32_f32(float32x2_t a) { 1704 return vcvt_u32_f32(a); 1705 } 1706 1707 // CHECK-LABEL: test_vcvtq_u32_f32 1708 // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}} 1709 uint32x4_t test_vcvtq_u32_f32(float32x4_t a) { 1710 return vcvtq_u32_f32(a); 1711 } 1712 1713 1714 // CHECK-LABEL: test_vdup_lane_u8 1715 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1716 uint8x8_t test_vdup_lane_u8(uint8x8_t a) { 1717 return vdup_lane_u8(a, 7); 1718 } 1719 1720 // CHECK-LABEL: test_vdup_lane_u16 1721 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1722 uint16x4_t test_vdup_lane_u16(uint16x4_t a) { 1723 return vdup_lane_u16(a, 3); 1724 } 1725 1726 // CHECK-LABEL: test_vdup_lane_u32 1727 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1728 uint32x2_t test_vdup_lane_u32(uint32x2_t a) { 1729 return vdup_lane_u32(a, 1); 1730 } 1731 1732 // CHECK-LABEL: test_vdup_lane_s8 1733 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1734 int8x8_t test_vdup_lane_s8(int8x8_t a) { 1735 return vdup_lane_s8(a, 7); 1736 } 1737 1738 // CHECK-LABEL: test_vdup_lane_s16 1739 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1740 int16x4_t test_vdup_lane_s16(int16x4_t a) { 1741 return vdup_lane_s16(a, 3); 1742 } 1743 1744 // CHECK-LABEL: test_vdup_lane_s32 1745 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1746 int32x2_t test_vdup_lane_s32(int32x2_t a) { 1747 return vdup_lane_s32(a, 1); 1748 } 1749 1750 // CHECK-LABEL: test_vdup_lane_p8 1751 // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1752 poly8x8_t test_vdup_lane_p8(poly8x8_t a) { 1753 return vdup_lane_p8(a, 7); 1754 } 1755 1756 // CHECK-LABEL: test_vdup_lane_p16 1757 // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1758 poly16x4_t test_vdup_lane_p16(poly16x4_t a) { 1759 return vdup_lane_p16(a, 3); 1760 } 1761 1762 // CHECK-LABEL: test_vdup_lane_f32 1763 // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1764 float32x2_t test_vdup_lane_f32(float32x2_t a) { 1765 return vdup_lane_f32(a, 1); 1766 } 1767 1768 // CHECK-LABEL: test_vdupq_lane_u8 1769 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1770 uint8x16_t test_vdupq_lane_u8(uint8x8_t a) { 1771 return vdupq_lane_u8(a, 7); 1772 } 1773 1774 // CHECK-LABEL: test_vdupq_lane_u16 1775 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1776 uint16x8_t test_vdupq_lane_u16(uint16x4_t a) { 1777 return vdupq_lane_u16(a, 3); 1778 } 1779 1780 // CHECK-LABEL: test_vdupq_lane_u32 1781 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1782 uint32x4_t test_vdupq_lane_u32(uint32x2_t a) { 1783 return vdupq_lane_u32(a, 1); 1784 } 1785 1786 // CHECK-LABEL: test_vdupq_lane_s8 1787 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1788 int8x16_t test_vdupq_lane_s8(int8x8_t a) { 1789 return vdupq_lane_s8(a, 7); 1790 } 1791 1792 // CHECK-LABEL: test_vdupq_lane_s16 1793 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1794 int16x8_t test_vdupq_lane_s16(int16x4_t a) { 1795 return vdupq_lane_s16(a, 3); 1796 } 1797 1798 // CHECK-LABEL: test_vdupq_lane_s32 1799 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1800 int32x4_t test_vdupq_lane_s32(int32x2_t a) { 1801 return vdupq_lane_s32(a, 1); 1802 } 1803 1804 // CHECK-LABEL: test_vdupq_lane_p8 1805 // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1806 poly8x16_t test_vdupq_lane_p8(poly8x8_t a) { 1807 return vdupq_lane_p8(a, 7); 1808 } 1809 1810 // CHECK-LABEL: test_vdupq_lane_p16 1811 // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1812 poly16x8_t test_vdupq_lane_p16(poly16x4_t a) { 1813 return vdupq_lane_p16(a, 3); 1814 } 1815 1816 // CHECK-LABEL: test_vdupq_lane_f32 1817 // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 1818 float32x4_t test_vdupq_lane_f32(float32x2_t a) { 1819 return vdupq_lane_f32(a, 1); 1820 } 1821 1822 // CHECK-LABEL: test_vdup_lane_s64 1823 int64x1_t test_vdup_lane_s64(int64x1_t a) { 1824 return vdup_lane_s64(a, 0); 1825 } 1826 1827 // CHECK-LABEL: test_vdup_lane_u64 1828 uint64x1_t test_vdup_lane_u64(uint64x1_t a) { 1829 return vdup_lane_u64(a, 0); 1830 } 1831 1832 // CHECK-LABEL: test_vdupq_lane_s64 1833 // CHECK: {{vmov|vdup}} 1834 int64x2_t test_vdupq_lane_s64(int64x1_t a) { 1835 return vdupq_lane_s64(a, 0); 1836 } 1837 1838 // CHECK-LABEL: test_vdupq_lane_u64 1839 // CHECK: {{vmov|vdup}} 1840 uint64x2_t test_vdupq_lane_u64(uint64x1_t a) { 1841 return vdupq_lane_u64(a, 0); 1842 } 1843 1844 1845 // CHECK-LABEL: test_vdup_n_u8 1846 // CHECK: vmov 1847 uint8x8_t test_vdup_n_u8(uint8_t a) { 1848 return vdup_n_u8(a); 1849 } 1850 1851 // CHECK-LABEL: test_vdup_n_u16 1852 // CHECK: vmov 1853 uint16x4_t test_vdup_n_u16(uint16_t a) { 1854 return vdup_n_u16(a); 1855 } 1856 1857 // CHECK-LABEL: test_vdup_n_u32 1858 // CHECK: vmov 1859 uint32x2_t test_vdup_n_u32(uint32_t a) { 1860 return vdup_n_u32(a); 1861 } 1862 1863 // CHECK-LABEL: test_vdup_n_s8 1864 // CHECK: vmov 1865 int8x8_t test_vdup_n_s8(int8_t a) { 1866 return vdup_n_s8(a); 1867 } 1868 1869 // CHECK-LABEL: test_vdup_n_s16 1870 // CHECK: vmov 1871 int16x4_t test_vdup_n_s16(int16_t a) { 1872 return vdup_n_s16(a); 1873 } 1874 1875 // CHECK-LABEL: test_vdup_n_s32 1876 // CHECK: vmov 1877 int32x2_t test_vdup_n_s32(int32_t a) { 1878 return vdup_n_s32(a); 1879 } 1880 1881 // CHECK-LABEL: test_vdup_n_p8 1882 // CHECK: vmov 1883 poly8x8_t test_vdup_n_p8(poly8_t a) { 1884 return vdup_n_p8(a); 1885 } 1886 1887 // CHECK-LABEL: test_vdup_n_p16 1888 // CHECK: vmov 1889 poly16x4_t test_vdup_n_p16(poly16_t a) { 1890 return vdup_n_p16(a); 1891 } 1892 1893 // CHECK-LABEL: test_vdup_n_f16 1894 // CHECK: vld1.16 {{{d[0-9]+\[\]}}} 1895 float16x4_t test_vdup_n_f16(float16_t *a) { 1896 return vdup_n_f16(*a); 1897 } 1898 1899 // CHECK-LABEL: test_vdup_n_f32 1900 // CHECK: vmov 1901 float32x2_t test_vdup_n_f32(float32_t a) { 1902 return vdup_n_f32(a); 1903 } 1904 1905 // CHECK-LABEL: test_vdupq_n_u8 1906 // CHECK: vmov 1907 uint8x16_t test_vdupq_n_u8(uint8_t a) { 1908 return vdupq_n_u8(a); 1909 } 1910 1911 // CHECK-LABEL: test_vdupq_n_u16 1912 // CHECK: vmov 1913 uint16x8_t test_vdupq_n_u16(uint16_t a) { 1914 return vdupq_n_u16(a); 1915 } 1916 1917 // CHECK-LABEL: test_vdupq_n_u32 1918 // CHECK: vmov 1919 uint32x4_t test_vdupq_n_u32(uint32_t a) { 1920 return vdupq_n_u32(a); 1921 } 1922 1923 // CHECK-LABEL: test_vdupq_n_s8 1924 // CHECK: vmov 1925 int8x16_t test_vdupq_n_s8(int8_t a) { 1926 return vdupq_n_s8(a); 1927 } 1928 1929 // CHECK-LABEL: test_vdupq_n_s16 1930 // CHECK: vmov 1931 int16x8_t test_vdupq_n_s16(int16_t a) { 1932 return vdupq_n_s16(a); 1933 } 1934 1935 // CHECK-LABEL: test_vdupq_n_s32 1936 // CHECK: vmov 1937 int32x4_t test_vdupq_n_s32(int32_t a) { 1938 return vdupq_n_s32(a); 1939 } 1940 1941 // CHECK-LABEL: test_vdupq_n_p8 1942 // CHECK: vmov 1943 poly8x16_t test_vdupq_n_p8(poly8_t a) { 1944 return vdupq_n_p8(a); 1945 } 1946 1947 // CHECK-LABEL: test_vdupq_n_p16 1948 // CHECK: vmov 1949 poly16x8_t test_vdupq_n_p16(poly16_t a) { 1950 return vdupq_n_p16(a); 1951 } 1952 1953 // CHECK-LABEL: test_vdupq_n_f16 1954 // CHECK: vld1.16 {{{d[0-9]+\[\], d[0-9]+\[\]}}} 1955 float16x8_t test_vdupq_n_f16(float16_t *a) { 1956 return vdupq_n_f16(*a); 1957 } 1958 1959 // CHECK-LABEL: test_vdupq_n_f32 1960 // CHECK: vmov 1961 float32x4_t test_vdupq_n_f32(float32_t a) { 1962 return vdupq_n_f32(a); 1963 } 1964 1965 // CHECK-LABEL: test_vdup_n_s64 1966 // CHECK: vmov 1967 int64x1_t test_vdup_n_s64(int64_t a) { 1968 return vdup_n_s64(a); 1969 } 1970 1971 // CHECK-LABEL: test_vdup_n_u64 1972 // CHECK: vmov 1973 uint64x1_t test_vdup_n_u64(uint64_t a) { 1974 return vdup_n_u64(a); 1975 } 1976 1977 // CHECK-LABEL: test_vdupq_n_s64 1978 // CHECK: vmov 1979 int64x2_t test_vdupq_n_s64(int64_t a) { 1980 return vdupq_n_s64(a); 1981 } 1982 1983 // CHECK-LABEL: test_vdupq_n_u64 1984 // CHECK: vmov 1985 uint64x2_t test_vdupq_n_u64(uint64_t a) { 1986 return vdupq_n_u64(a); 1987 } 1988 1989 1990 // CHECK-LABEL: test_veor_s8 1991 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1992 int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) { 1993 return veor_s8(a, b); 1994 } 1995 1996 // CHECK-LABEL: test_veor_s16 1997 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 1998 int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) { 1999 return veor_s16(a, b); 2000 } 2001 2002 // CHECK-LABEL: test_veor_s32 2003 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2004 int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) { 2005 return veor_s32(a, b); 2006 } 2007 2008 // CHECK-LABEL: test_veor_s64 2009 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2010 int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) { 2011 return veor_s64(a, b); 2012 } 2013 2014 // CHECK-LABEL: test_veor_u8 2015 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2016 uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) { 2017 return veor_u8(a, b); 2018 } 2019 2020 // CHECK-LABEL: test_veor_u16 2021 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2022 uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) { 2023 return veor_u16(a, b); 2024 } 2025 2026 // CHECK-LABEL: test_veor_u32 2027 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2028 uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) { 2029 return veor_u32(a, b); 2030 } 2031 2032 // CHECK-LABEL: test_veor_u64 2033 // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2034 uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) { 2035 return veor_u64(a, b); 2036 } 2037 2038 // CHECK-LABEL: test_veorq_s8 2039 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2040 int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) { 2041 return veorq_s8(a, b); 2042 } 2043 2044 // CHECK-LABEL: test_veorq_s16 2045 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2046 int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) { 2047 return veorq_s16(a, b); 2048 } 2049 2050 // CHECK-LABEL: test_veorq_s32 2051 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2052 int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) { 2053 return veorq_s32(a, b); 2054 } 2055 2056 // CHECK-LABEL: test_veorq_s64 2057 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2058 int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) { 2059 return veorq_s64(a, b); 2060 } 2061 2062 // CHECK-LABEL: test_veorq_u8 2063 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2064 uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) { 2065 return veorq_u8(a, b); 2066 } 2067 2068 // CHECK-LABEL: test_veorq_u16 2069 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2070 uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) { 2071 return veorq_u16(a, b); 2072 } 2073 2074 // CHECK-LABEL: test_veorq_u32 2075 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2076 uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) { 2077 return veorq_u32(a, b); 2078 } 2079 2080 // CHECK-LABEL: test_veorq_u64 2081 // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2082 uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) { 2083 return veorq_u64(a, b); 2084 } 2085 2086 2087 // CHECK-LABEL: test_vext_s8 2088 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2089 int8x8_t test_vext_s8(int8x8_t a, int8x8_t b) { 2090 return vext_s8(a, b, 7); 2091 } 2092 2093 // CHECK-LABEL: test_vext_u8 2094 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2095 uint8x8_t test_vext_u8(uint8x8_t a, uint8x8_t b) { 2096 return vext_u8(a, b, 7); 2097 } 2098 2099 // CHECK-LABEL: test_vext_p8 2100 // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2101 poly8x8_t test_vext_p8(poly8x8_t a, poly8x8_t b) { 2102 return vext_p8(a, b, 7); 2103 } 2104 2105 // CHECK-LABEL: test_vext_s16 2106 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2107 int16x4_t test_vext_s16(int16x4_t a, int16x4_t b) { 2108 return vext_s16(a, b, 3); 2109 } 2110 2111 // CHECK-LABEL: test_vext_u16 2112 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2113 uint16x4_t test_vext_u16(uint16x4_t a, uint16x4_t b) { 2114 return vext_u16(a, b, 3); 2115 } 2116 2117 // CHECK-LABEL: test_vext_p16 2118 // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2119 poly16x4_t test_vext_p16(poly16x4_t a, poly16x4_t b) { 2120 return vext_p16(a, b, 3); 2121 } 2122 2123 // CHECK-LABEL: test_vext_s32 2124 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2125 int32x2_t test_vext_s32(int32x2_t a, int32x2_t b) { 2126 return vext_s32(a, b, 1); 2127 } 2128 2129 // CHECK-LABEL: test_vext_u32 2130 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2131 uint32x2_t test_vext_u32(uint32x2_t a, uint32x2_t b) { 2132 return vext_u32(a, b, 1); 2133 } 2134 2135 // CHECK-LABEL: test_vext_s64 2136 int64x1_t test_vext_s64(int64x1_t a, int64x1_t b) { 2137 return vext_s64(a, b, 0); 2138 } 2139 2140 // CHECK-LABEL: test_vext_u64 2141 uint64x1_t test_vext_u64(uint64x1_t a, uint64x1_t b) { 2142 return vext_u64(a, b, 0); 2143 } 2144 2145 // CHECK-LABEL: test_vext_f32 2146 // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 2147 float32x2_t test_vext_f32(float32x2_t a, float32x2_t b) { 2148 return vext_f32(a, b, 1); 2149 } 2150 2151 // CHECK-LABEL: test_vextq_s8 2152 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2153 int8x16_t test_vextq_s8(int8x16_t a, int8x16_t b) { 2154 return vextq_s8(a, b, 15); 2155 } 2156 2157 // CHECK-LABEL: test_vextq_u8 2158 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2159 uint8x16_t test_vextq_u8(uint8x16_t a, uint8x16_t b) { 2160 return vextq_u8(a, b, 15); 2161 } 2162 2163 // CHECK-LABEL: test_vextq_p8 2164 // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2165 poly8x16_t test_vextq_p8(poly8x16_t a, poly8x16_t b) { 2166 return vextq_p8(a, b, 15); 2167 } 2168 2169 // CHECK-LABEL: test_vextq_s16 2170 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2171 int16x8_t test_vextq_s16(int16x8_t a, int16x8_t b) { 2172 return vextq_s16(a, b, 7); 2173 } 2174 2175 // CHECK-LABEL: test_vextq_u16 2176 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2177 uint16x8_t test_vextq_u16(uint16x8_t a, uint16x8_t b) { 2178 return vextq_u16(a, b, 7); 2179 } 2180 2181 // CHECK-LABEL: test_vextq_p16 2182 // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2183 poly16x8_t test_vextq_p16(poly16x8_t a, poly16x8_t b) { 2184 return vextq_p16(a, b, 7); 2185 } 2186 2187 // CHECK-LABEL: test_vextq_s32 2188 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2189 int32x4_t test_vextq_s32(int32x4_t a, int32x4_t b) { 2190 return vextq_s32(a, b, 3); 2191 } 2192 2193 // CHECK-LABEL: test_vextq_u32 2194 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2195 uint32x4_t test_vextq_u32(uint32x4_t a, uint32x4_t b) { 2196 return vextq_u32(a, b, 3); 2197 } 2198 2199 // CHECK-LABEL: test_vextq_s64 2200 // CHECK: {{vmov|vdup}} 2201 int64x2_t test_vextq_s64(int64x2_t a, int64x2_t b) { 2202 return vextq_s64(a, b, 1); 2203 } 2204 2205 // CHECK-LABEL: test_vextq_u64 2206 // CHECK: {{vmov|vdup}} 2207 uint64x2_t test_vextq_u64(uint64x2_t a, uint64x2_t b) { 2208 return vextq_u64(a, b, 1); 2209 } 2210 2211 // CHECK-LABEL: test_vextq_f32 2212 // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 2213 float32x4_t test_vextq_f32(float32x4_t a, float32x4_t b) { 2214 return vextq_f32(a, b, 3); 2215 } 2216 2217 2218 // CHECK-LABEL: test_vfma_f32 2219 // CHECK: vfma.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2220 float32x2_t test_vfma_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 2221 return vfma_f32(a, b, c); 2222 } 2223 2224 // CHECK-LABEL: test_vfmaq_f32 2225 // CHECK: vfma.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2226 float32x4_t test_vfmaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 2227 return vfmaq_f32(a, b, c); 2228 } 2229 2230 2231 // CHECK-LABEL: test_vget_high_s8 2232 int8x8_t test_vget_high_s8(int8x16_t a) { 2233 return vget_high_s8(a); 2234 } 2235 2236 // CHECK-LABEL: test_vget_high_s16 2237 int16x4_t test_vget_high_s16(int16x8_t a) { 2238 return vget_high_s16(a); 2239 } 2240 2241 // CHECK-LABEL: test_vget_high_s32 2242 int32x2_t test_vget_high_s32(int32x4_t a) { 2243 return vget_high_s32(a); 2244 } 2245 2246 // CHECK-LABEL: test_vget_high_s64 2247 int64x1_t test_vget_high_s64(int64x2_t a) { 2248 return vget_high_s64(a); 2249 } 2250 2251 // CHECK-LABEL: test_vget_high_f16 2252 float16x4_t test_vget_high_f16(float16x8_t a) { 2253 return vget_high_f16(a); 2254 } 2255 2256 // CHECK-LABEL: test_vget_high_f32 2257 float32x2_t test_vget_high_f32(float32x4_t a) { 2258 return vget_high_f32(a); 2259 } 2260 2261 // CHECK-LABEL: test_vget_high_u8 2262 uint8x8_t test_vget_high_u8(uint8x16_t a) { 2263 return vget_high_u8(a); 2264 } 2265 2266 // CHECK-LABEL: test_vget_high_u16 2267 uint16x4_t test_vget_high_u16(uint16x8_t a) { 2268 return vget_high_u16(a); 2269 } 2270 2271 // CHECK-LABEL: test_vget_high_u32 2272 uint32x2_t test_vget_high_u32(uint32x4_t a) { 2273 return vget_high_u32(a); 2274 } 2275 2276 // CHECK-LABEL: test_vget_high_u64 2277 uint64x1_t test_vget_high_u64(uint64x2_t a) { 2278 return vget_high_u64(a); 2279 } 2280 2281 // CHECK-LABEL: test_vget_high_p8 2282 poly8x8_t test_vget_high_p8(poly8x16_t a) { 2283 return vget_high_p8(a); 2284 } 2285 2286 // CHECK-LABEL: test_vget_high_p16 2287 poly16x4_t test_vget_high_p16(poly16x8_t a) { 2288 return vget_high_p16(a); 2289 } 2290 2291 2292 // CHECK-LABEL: test_vget_lane_u8 2293 // CHECK: vmov 2294 uint8_t test_vget_lane_u8(uint8x8_t a) { 2295 return vget_lane_u8(a, 7); 2296 } 2297 2298 // CHECK-LABEL: test_vget_lane_u16 2299 // CHECK: vmov 2300 uint16_t test_vget_lane_u16(uint16x4_t a) { 2301 return vget_lane_u16(a, 3); 2302 } 2303 2304 // CHECK-LABEL: test_vget_lane_u32 2305 // CHECK: vmov 2306 uint32_t test_vget_lane_u32(uint32x2_t a) { 2307 return vget_lane_u32(a, 1); 2308 } 2309 2310 // CHECK-LABEL: test_vget_lane_s8 2311 // CHECK: vmov 2312 int8_t test_vget_lane_s8(int8x8_t a) { 2313 return vget_lane_s8(a, 7); 2314 } 2315 2316 // CHECK-LABEL: test_vget_lane_s16 2317 // CHECK: vmov 2318 int16_t test_vget_lane_s16(int16x4_t a) { 2319 return vget_lane_s16(a, 3); 2320 } 2321 2322 // CHECK-LABEL: test_vget_lane_s32 2323 // CHECK: vmov 2324 int32_t test_vget_lane_s32(int32x2_t a) { 2325 return vget_lane_s32(a, 1); 2326 } 2327 2328 // CHECK-LABEL: test_vget_lane_p8 2329 // CHECK: vmov 2330 poly8_t test_vget_lane_p8(poly8x8_t a) { 2331 return vget_lane_p8(a, 7); 2332 } 2333 2334 // CHECK-LABEL: test_vget_lane_p16 2335 // CHECK: vmov 2336 poly16_t test_vget_lane_p16(poly16x4_t a) { 2337 return vget_lane_p16(a, 3); 2338 } 2339 2340 // CHECK-LABEL: test_vget_lane_f32 2341 // CHECK: vmov 2342 float32_t test_vget_lane_f32(float32x2_t a) { 2343 return vget_lane_f32(a, 1); 2344 } 2345 2346 // CHECK-LABEL: test_vgetq_lane_u8 2347 // CHECK: vmov 2348 uint8_t test_vgetq_lane_u8(uint8x16_t a) { 2349 return vgetq_lane_u8(a, 15); 2350 } 2351 2352 // CHECK-LABEL: test_vgetq_lane_u16 2353 // CHECK: vmov 2354 uint16_t test_vgetq_lane_u16(uint16x8_t a) { 2355 return vgetq_lane_u16(a, 7); 2356 } 2357 2358 // CHECK-LABEL: test_vgetq_lane_u32 2359 // CHECK: vmov 2360 uint32_t test_vgetq_lane_u32(uint32x4_t a) { 2361 return vgetq_lane_u32(a, 3); 2362 } 2363 2364 // CHECK-LABEL: test_vgetq_lane_s8 2365 // CHECK: vmov 2366 int8_t test_vgetq_lane_s8(int8x16_t a) { 2367 return vgetq_lane_s8(a, 15); 2368 } 2369 2370 // CHECK-LABEL: test_vgetq_lane_s16 2371 // CHECK: vmov 2372 int16_t test_vgetq_lane_s16(int16x8_t a) { 2373 return vgetq_lane_s16(a, 7); 2374 } 2375 2376 // CHECK-LABEL: test_vgetq_lane_s32 2377 // CHECK: vmov 2378 int32_t test_vgetq_lane_s32(int32x4_t a) { 2379 return vgetq_lane_s32(a, 3); 2380 } 2381 2382 // CHECK-LABEL: test_vgetq_lane_p8 2383 // CHECK: vmov 2384 poly8_t test_vgetq_lane_p8(poly8x16_t a) { 2385 return vgetq_lane_p8(a, 15); 2386 } 2387 2388 // CHECK-LABEL: test_vgetq_lane_p16 2389 // CHECK: vmov 2390 poly16_t test_vgetq_lane_p16(poly16x8_t a) { 2391 return vgetq_lane_p16(a, 7); 2392 } 2393 2394 // CHECK-LABEL: test_vgetq_lane_f32 2395 // CHECK: vmov 2396 float32_t test_vgetq_lane_f32(float32x4_t a) { 2397 return vgetq_lane_f32(a, 3); 2398 } 2399 2400 // CHECK-LABEL: test_vget_lane_s64 2401 // CHECK: vmov 2402 int64_t test_vget_lane_s64(int64x1_t a) { 2403 return vget_lane_s64(a, 0); 2404 } 2405 2406 // CHECK-LABEL: test_vget_lane_u64 2407 // CHECK: vmov 2408 uint64_t test_vget_lane_u64(uint64x1_t a) { 2409 return vget_lane_u64(a, 0); 2410 } 2411 2412 // CHECK-LABEL: test_vgetq_lane_s64 2413 // CHECK: vmov 2414 int64_t test_vgetq_lane_s64(int64x2_t a) { 2415 return vgetq_lane_s64(a, 1); 2416 } 2417 2418 // CHECK-LABEL: test_vgetq_lane_u64 2419 // CHECK: vmov 2420 uint64_t test_vgetq_lane_u64(uint64x2_t a) { 2421 return vgetq_lane_u64(a, 1); 2422 } 2423 2424 2425 // CHECK-LABEL: test_vget_low_s8 2426 int8x8_t test_vget_low_s8(int8x16_t a) { 2427 return vget_low_s8(a); 2428 } 2429 2430 // CHECK-LABEL: test_vget_low_s16 2431 int16x4_t test_vget_low_s16(int16x8_t a) { 2432 return vget_low_s16(a); 2433 } 2434 2435 // CHECK-LABEL: test_vget_low_s32 2436 int32x2_t test_vget_low_s32(int32x4_t a) { 2437 return vget_low_s32(a); 2438 } 2439 2440 // CHECK-LABEL: test_vget_low_s64 2441 int64x1_t test_vget_low_s64(int64x2_t a) { 2442 return vget_low_s64(a); 2443 } 2444 2445 // CHECK-LABEL: test_vget_low_f16 2446 float16x4_t test_vget_low_f16(float16x8_t a) { 2447 return vget_low_f16(a); 2448 } 2449 2450 // CHECK-LABEL: test_vget_low_f32 2451 float32x2_t test_vget_low_f32(float32x4_t a) { 2452 return vget_low_f32(a); 2453 } 2454 2455 // CHECK-LABEL: test_vget_low_u8 2456 uint8x8_t test_vget_low_u8(uint8x16_t a) { 2457 return vget_low_u8(a); 2458 } 2459 2460 // CHECK-LABEL: test_vget_low_u16 2461 uint16x4_t test_vget_low_u16(uint16x8_t a) { 2462 return vget_low_u16(a); 2463 } 2464 2465 // CHECK-LABEL: test_vget_low_u32 2466 uint32x2_t test_vget_low_u32(uint32x4_t a) { 2467 return vget_low_u32(a); 2468 } 2469 2470 // CHECK-LABEL: test_vget_low_u64 2471 uint64x1_t test_vget_low_u64(uint64x2_t a) { 2472 return vget_low_u64(a); 2473 } 2474 2475 // CHECK-LABEL: test_vget_low_p8 2476 poly8x8_t test_vget_low_p8(poly8x16_t a) { 2477 return vget_low_p8(a); 2478 } 2479 2480 // CHECK-LABEL: test_vget_low_p16 2481 poly16x4_t test_vget_low_p16(poly16x8_t a) { 2482 return vget_low_p16(a); 2483 } 2484 2485 2486 // CHECK-LABEL: test_vhadd_s8 2487 // CHECK: vhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2488 int8x8_t test_vhadd_s8(int8x8_t a, int8x8_t b) { 2489 return vhadd_s8(a, b); 2490 } 2491 2492 // CHECK-LABEL: test_vhadd_s16 2493 // CHECK: vhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2494 int16x4_t test_vhadd_s16(int16x4_t a, int16x4_t b) { 2495 return vhadd_s16(a, b); 2496 } 2497 2498 // CHECK-LABEL: test_vhadd_s32 2499 // CHECK: vhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2500 int32x2_t test_vhadd_s32(int32x2_t a, int32x2_t b) { 2501 return vhadd_s32(a, b); 2502 } 2503 2504 // CHECK-LABEL: test_vhadd_u8 2505 // CHECK: vhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2506 uint8x8_t test_vhadd_u8(uint8x8_t a, uint8x8_t b) { 2507 return vhadd_u8(a, b); 2508 } 2509 2510 // CHECK-LABEL: test_vhadd_u16 2511 // CHECK: vhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2512 uint16x4_t test_vhadd_u16(uint16x4_t a, uint16x4_t b) { 2513 return vhadd_u16(a, b); 2514 } 2515 2516 // CHECK-LABEL: test_vhadd_u32 2517 // CHECK: vhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2518 uint32x2_t test_vhadd_u32(uint32x2_t a, uint32x2_t b) { 2519 return vhadd_u32(a, b); 2520 } 2521 2522 // CHECK-LABEL: test_vhaddq_s8 2523 // CHECK: vhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2524 int8x16_t test_vhaddq_s8(int8x16_t a, int8x16_t b) { 2525 return vhaddq_s8(a, b); 2526 } 2527 2528 // CHECK-LABEL: test_vhaddq_s16 2529 // CHECK: vhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2530 int16x8_t test_vhaddq_s16(int16x8_t a, int16x8_t b) { 2531 return vhaddq_s16(a, b); 2532 } 2533 2534 // CHECK-LABEL: test_vhaddq_s32 2535 // CHECK: vhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2536 int32x4_t test_vhaddq_s32(int32x4_t a, int32x4_t b) { 2537 return vhaddq_s32(a, b); 2538 } 2539 2540 // CHECK-LABEL: test_vhaddq_u8 2541 // CHECK: vhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2542 uint8x16_t test_vhaddq_u8(uint8x16_t a, uint8x16_t b) { 2543 return vhaddq_u8(a, b); 2544 } 2545 2546 // CHECK-LABEL: test_vhaddq_u16 2547 // CHECK: vhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2548 uint16x8_t test_vhaddq_u16(uint16x8_t a, uint16x8_t b) { 2549 return vhaddq_u16(a, b); 2550 } 2551 2552 // CHECK-LABEL: test_vhaddq_u32 2553 // CHECK: vhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2554 uint32x4_t test_vhaddq_u32(uint32x4_t a, uint32x4_t b) { 2555 return vhaddq_u32(a, b); 2556 } 2557 2558 2559 // CHECK-LABEL: test_vhsub_s8 2560 // CHECK: vhsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2561 int8x8_t test_vhsub_s8(int8x8_t a, int8x8_t b) { 2562 return vhsub_s8(a, b); 2563 } 2564 2565 // CHECK-LABEL: test_vhsub_s16 2566 // CHECK: vhsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2567 int16x4_t test_vhsub_s16(int16x4_t a, int16x4_t b) { 2568 return vhsub_s16(a, b); 2569 } 2570 2571 // CHECK-LABEL: test_vhsub_s32 2572 // CHECK: vhsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2573 int32x2_t test_vhsub_s32(int32x2_t a, int32x2_t b) { 2574 return vhsub_s32(a, b); 2575 } 2576 2577 // CHECK-LABEL: test_vhsub_u8 2578 // CHECK: vhsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2579 uint8x8_t test_vhsub_u8(uint8x8_t a, uint8x8_t b) { 2580 return vhsub_u8(a, b); 2581 } 2582 2583 // CHECK-LABEL: test_vhsub_u16 2584 // CHECK: vhsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2585 uint16x4_t test_vhsub_u16(uint16x4_t a, uint16x4_t b) { 2586 return vhsub_u16(a, b); 2587 } 2588 2589 // CHECK-LABEL: test_vhsub_u32 2590 // CHECK: vhsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 2591 uint32x2_t test_vhsub_u32(uint32x2_t a, uint32x2_t b) { 2592 return vhsub_u32(a, b); 2593 } 2594 2595 // CHECK-LABEL: test_vhsubq_s8 2596 // CHECK: vhsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2597 int8x16_t test_vhsubq_s8(int8x16_t a, int8x16_t b) { 2598 return vhsubq_s8(a, b); 2599 } 2600 2601 // CHECK-LABEL: test_vhsubq_s16 2602 // CHECK: vhsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2603 int16x8_t test_vhsubq_s16(int16x8_t a, int16x8_t b) { 2604 return vhsubq_s16(a, b); 2605 } 2606 2607 // CHECK-LABEL: test_vhsubq_s32 2608 // CHECK: vhsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2609 int32x4_t test_vhsubq_s32(int32x4_t a, int32x4_t b) { 2610 return vhsubq_s32(a, b); 2611 } 2612 2613 // CHECK-LABEL: test_vhsubq_u8 2614 // CHECK: vhsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2615 uint8x16_t test_vhsubq_u8(uint8x16_t a, uint8x16_t b) { 2616 return vhsubq_u8(a, b); 2617 } 2618 2619 // CHECK-LABEL: test_vhsubq_u16 2620 // CHECK: vhsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2621 uint16x8_t test_vhsubq_u16(uint16x8_t a, uint16x8_t b) { 2622 return vhsubq_u16(a, b); 2623 } 2624 2625 // CHECK-LABEL: test_vhsubq_u32 2626 // CHECK: vhsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 2627 uint32x4_t test_vhsubq_u32(uint32x4_t a, uint32x4_t b) { 2628 return vhsubq_u32(a, b); 2629 } 2630 2631 2632 // CHECK-LABEL: test_vld1q_u8 2633 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2634 uint8x16_t test_vld1q_u8(uint8_t const * a) { 2635 return vld1q_u8(a); 2636 } 2637 2638 // CHECK-LABEL: test_vld1q_u16 2639 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2640 uint16x8_t test_vld1q_u16(uint16_t const * a) { 2641 return vld1q_u16(a); 2642 } 2643 2644 // CHECK-LABEL: test_vld1q_u32 2645 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2646 uint32x4_t test_vld1q_u32(uint32_t const * a) { 2647 return vld1q_u32(a); 2648 } 2649 2650 // CHECK-LABEL: test_vld1q_u64 2651 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 2652 uint64x2_t test_vld1q_u64(uint64_t const * a) { 2653 return vld1q_u64(a); 2654 } 2655 2656 // CHECK-LABEL: test_vld1q_s8 2657 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2658 int8x16_t test_vld1q_s8(int8_t const * a) { 2659 return vld1q_s8(a); 2660 } 2661 2662 // CHECK-LABEL: test_vld1q_s16 2663 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2664 int16x8_t test_vld1q_s16(int16_t const * a) { 2665 return vld1q_s16(a); 2666 } 2667 2668 // CHECK-LABEL: test_vld1q_s32 2669 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2670 int32x4_t test_vld1q_s32(int32_t const * a) { 2671 return vld1q_s32(a); 2672 } 2673 2674 // CHECK-LABEL: test_vld1q_s64 2675 // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 2676 int64x2_t test_vld1q_s64(int64_t const * a) { 2677 return vld1q_s64(a); 2678 } 2679 2680 // CHECK-LABEL: test_vld1q_f16 2681 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2682 float16x8_t test_vld1q_f16(float16_t const * a) { 2683 return vld1q_f16(a); 2684 } 2685 2686 // CHECK-LABEL: test_vld1q_f32 2687 // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2688 float32x4_t test_vld1q_f32(float32_t const * a) { 2689 return vld1q_f32(a); 2690 } 2691 2692 // CHECK-LABEL: test_vld1q_p8 2693 // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2694 poly8x16_t test_vld1q_p8(poly8_t const * a) { 2695 return vld1q_p8(a); 2696 } 2697 2698 // CHECK-LABEL: test_vld1q_p16 2699 // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 2700 poly16x8_t test_vld1q_p16(poly16_t const * a) { 2701 return vld1q_p16(a); 2702 } 2703 2704 // CHECK-LABEL: test_vld1_u8 2705 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2706 uint8x8_t test_vld1_u8(uint8_t const * a) { 2707 return vld1_u8(a); 2708 } 2709 2710 // CHECK-LABEL: test_vld1_u16 2711 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2712 uint16x4_t test_vld1_u16(uint16_t const * a) { 2713 return vld1_u16(a); 2714 } 2715 2716 // CHECK-LABEL: test_vld1_u32 2717 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2718 uint32x2_t test_vld1_u32(uint32_t const * a) { 2719 return vld1_u32(a); 2720 } 2721 2722 // CHECK-LABEL: test_vld1_u64 2723 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 2724 uint64x1_t test_vld1_u64(uint64_t const * a) { 2725 return vld1_u64(a); 2726 } 2727 2728 // CHECK-LABEL: test_vld1_s8 2729 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2730 int8x8_t test_vld1_s8(int8_t const * a) { 2731 return vld1_s8(a); 2732 } 2733 2734 // CHECK-LABEL: test_vld1_s16 2735 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2736 int16x4_t test_vld1_s16(int16_t const * a) { 2737 return vld1_s16(a); 2738 } 2739 2740 // CHECK-LABEL: test_vld1_s32 2741 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2742 int32x2_t test_vld1_s32(int32_t const * a) { 2743 return vld1_s32(a); 2744 } 2745 2746 // CHECK-LABEL: test_vld1_s64 2747 // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 2748 int64x1_t test_vld1_s64(int64_t const * a) { 2749 return vld1_s64(a); 2750 } 2751 2752 // CHECK-LABEL: test_vld1_f16 2753 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2754 float16x4_t test_vld1_f16(float16_t const * a) { 2755 return vld1_f16(a); 2756 } 2757 2758 // CHECK-LABEL: test_vld1_f32 2759 // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2760 float32x2_t test_vld1_f32(float32_t const * a) { 2761 return vld1_f32(a); 2762 } 2763 2764 // CHECK-LABEL: test_vld1_p8 2765 // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2766 poly8x8_t test_vld1_p8(poly8_t const * a) { 2767 return vld1_p8(a); 2768 } 2769 2770 // CHECK-LABEL: test_vld1_p16 2771 // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 2772 poly16x4_t test_vld1_p16(poly16_t const * a) { 2773 return vld1_p16(a); 2774 } 2775 2776 2777 // CHECK-LABEL: test_vld1q_dup_u8 2778 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2779 uint8x16_t test_vld1q_dup_u8(uint8_t const * a) { 2780 return vld1q_dup_u8(a); 2781 } 2782 2783 // CHECK-LABEL: test_vld1q_dup_u16 2784 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2785 uint16x8_t test_vld1q_dup_u16(uint16_t const * a) { 2786 return vld1q_dup_u16(a); 2787 } 2788 2789 // CHECK-LABEL: test_vld1q_dup_u32 2790 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2791 uint32x4_t test_vld1q_dup_u32(uint32_t const * a) { 2792 return vld1q_dup_u32(a); 2793 } 2794 2795 // CHECK-LABEL: test_vld1q_dup_u64 2796 // CHECK: {{ldr|vldr|vmov}} 2797 uint64x2_t test_vld1q_dup_u64(uint64_t const * a) { 2798 return vld1q_dup_u64(a); 2799 } 2800 2801 // CHECK-LABEL: test_vld1q_dup_s8 2802 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2803 int8x16_t test_vld1q_dup_s8(int8_t const * a) { 2804 return vld1q_dup_s8(a); 2805 } 2806 2807 // CHECK-LABEL: test_vld1q_dup_s16 2808 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2809 int16x8_t test_vld1q_dup_s16(int16_t const * a) { 2810 return vld1q_dup_s16(a); 2811 } 2812 2813 // CHECK-LABEL: test_vld1q_dup_s32 2814 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2815 int32x4_t test_vld1q_dup_s32(int32_t const * a) { 2816 return vld1q_dup_s32(a); 2817 } 2818 2819 // CHECK-LABEL: test_vld1q_dup_s64 2820 // CHECK: {{ldr|vldr|vmov}} 2821 int64x2_t test_vld1q_dup_s64(int64_t const * a) { 2822 return vld1q_dup_s64(a); 2823 } 2824 2825 // CHECK-LABEL: test_vld1q_dup_f16 2826 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2827 float16x8_t test_vld1q_dup_f16(float16_t const * a) { 2828 return vld1q_dup_f16(a); 2829 } 2830 2831 // CHECK-LABEL: test_vld1q_dup_f32 2832 // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2833 float32x4_t test_vld1q_dup_f32(float32_t const * a) { 2834 return vld1q_dup_f32(a); 2835 } 2836 2837 // CHECK-LABEL: test_vld1q_dup_p8 2838 // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2839 poly8x16_t test_vld1q_dup_p8(poly8_t const * a) { 2840 return vld1q_dup_p8(a); 2841 } 2842 2843 // CHECK-LABEL: test_vld1q_dup_p16 2844 // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2845 poly16x8_t test_vld1q_dup_p16(poly16_t const * a) { 2846 return vld1q_dup_p16(a); 2847 } 2848 2849 // CHECK-LABEL: test_vld1_dup_u8 2850 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2851 uint8x8_t test_vld1_dup_u8(uint8_t const * a) { 2852 return vld1_dup_u8(a); 2853 } 2854 2855 // CHECK-LABEL: test_vld1_dup_u16 2856 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2857 uint16x4_t test_vld1_dup_u16(uint16_t const * a) { 2858 return vld1_dup_u16(a); 2859 } 2860 2861 // CHECK-LABEL: test_vld1_dup_u32 2862 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2863 uint32x2_t test_vld1_dup_u32(uint32_t const * a) { 2864 return vld1_dup_u32(a); 2865 } 2866 2867 // CHECK-LABEL: test_vld1_dup_u64 2868 // CHECK: {{ldr|vldr|vmov}} 2869 uint64x1_t test_vld1_dup_u64(uint64_t const * a) { 2870 return vld1_dup_u64(a); 2871 } 2872 2873 // CHECK-LABEL: test_vld1_dup_s8 2874 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2875 int8x8_t test_vld1_dup_s8(int8_t const * a) { 2876 return vld1_dup_s8(a); 2877 } 2878 2879 // CHECK-LABEL: test_vld1_dup_s16 2880 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2881 int16x4_t test_vld1_dup_s16(int16_t const * a) { 2882 return vld1_dup_s16(a); 2883 } 2884 2885 // CHECK-LABEL: test_vld1_dup_s32 2886 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2887 int32x2_t test_vld1_dup_s32(int32_t const * a) { 2888 return vld1_dup_s32(a); 2889 } 2890 2891 // CHECK-LABEL: test_vld1_dup_s64 2892 // CHECK: {{ldr|vldr|vmov}} 2893 int64x1_t test_vld1_dup_s64(int64_t const * a) { 2894 return vld1_dup_s64(a); 2895 } 2896 2897 // CHECK-LABEL: test_vld1_dup_f16 2898 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2899 float16x4_t test_vld1_dup_f16(float16_t const * a) { 2900 return vld1_dup_f16(a); 2901 } 2902 2903 // CHECK-LABEL: test_vld1_dup_f32 2904 // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] 2905 float32x2_t test_vld1_dup_f32(float32_t const * a) { 2906 return vld1_dup_f32(a); 2907 } 2908 2909 // CHECK-LABEL: test_vld1_dup_p8 2910 // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] 2911 poly8x8_t test_vld1_dup_p8(poly8_t const * a) { 2912 return vld1_dup_p8(a); 2913 } 2914 2915 // CHECK-LABEL: test_vld1_dup_p16 2916 // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] 2917 poly16x4_t test_vld1_dup_p16(poly16_t const * a) { 2918 return vld1_dup_p16(a); 2919 } 2920 2921 2922 // CHECK-LABEL: test_vld1q_lane_u8 2923 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2924 uint8x16_t test_vld1q_lane_u8(uint8_t const * a, uint8x16_t b) { 2925 return vld1q_lane_u8(a, b, 15); 2926 } 2927 2928 // CHECK-LABEL: test_vld1q_lane_u16 2929 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2930 uint16x8_t test_vld1q_lane_u16(uint16_t const * a, uint16x8_t b) { 2931 return vld1q_lane_u16(a, b, 7); 2932 } 2933 2934 // CHECK-LABEL: test_vld1q_lane_u32 2935 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2936 uint32x4_t test_vld1q_lane_u32(uint32_t const * a, uint32x4_t b) { 2937 return vld1q_lane_u32(a, b, 3); 2938 } 2939 2940 // CHECK-LABEL: test_vld1q_lane_u64 2941 // CHECK: {{ldr|vldr|vmov}} 2942 uint64x2_t test_vld1q_lane_u64(uint64_t const * a, uint64x2_t b) { 2943 return vld1q_lane_u64(a, b, 1); 2944 } 2945 2946 // CHECK-LABEL: test_vld1q_lane_s8 2947 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2948 int8x16_t test_vld1q_lane_s8(int8_t const * a, int8x16_t b) { 2949 return vld1q_lane_s8(a, b, 15); 2950 } 2951 2952 // CHECK-LABEL: test_vld1q_lane_s16 2953 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2954 int16x8_t test_vld1q_lane_s16(int16_t const * a, int16x8_t b) { 2955 return vld1q_lane_s16(a, b, 7); 2956 } 2957 2958 // CHECK-LABEL: test_vld1q_lane_s32 2959 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2960 int32x4_t test_vld1q_lane_s32(int32_t const * a, int32x4_t b) { 2961 return vld1q_lane_s32(a, b, 3); 2962 } 2963 2964 // CHECK-LABEL: test_vld1q_lane_s64 2965 // CHECK: {{ldr|vldr|vmov}} 2966 int64x2_t test_vld1q_lane_s64(int64_t const * a, int64x2_t b) { 2967 return vld1q_lane_s64(a, b, 1); 2968 } 2969 2970 // CHECK-LABEL: test_vld1q_lane_f16 2971 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2972 float16x8_t test_vld1q_lane_f16(float16_t const * a, float16x8_t b) { 2973 return vld1q_lane_f16(a, b, 7); 2974 } 2975 2976 // CHECK-LABEL: test_vld1q_lane_f32 2977 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 2978 float32x4_t test_vld1q_lane_f32(float32_t const * a, float32x4_t b) { 2979 return vld1q_lane_f32(a, b, 3); 2980 } 2981 2982 // CHECK-LABEL: test_vld1q_lane_p8 2983 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2984 poly8x16_t test_vld1q_lane_p8(poly8_t const * a, poly8x16_t b) { 2985 return vld1q_lane_p8(a, b, 15); 2986 } 2987 2988 // CHECK-LABEL: test_vld1q_lane_p16 2989 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 2990 poly16x8_t test_vld1q_lane_p16(poly16_t const * a, poly16x8_t b) { 2991 return vld1q_lane_p16(a, b, 7); 2992 } 2993 2994 // CHECK-LABEL: test_vld1_lane_u8 2995 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 2996 uint8x8_t test_vld1_lane_u8(uint8_t const * a, uint8x8_t b) { 2997 return vld1_lane_u8(a, b, 7); 2998 } 2999 3000 // CHECK-LABEL: test_vld1_lane_u16 3001 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3002 uint16x4_t test_vld1_lane_u16(uint16_t const * a, uint16x4_t b) { 3003 return vld1_lane_u16(a, b, 3); 3004 } 3005 3006 // CHECK-LABEL: test_vld1_lane_u32 3007 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 3008 uint32x2_t test_vld1_lane_u32(uint32_t const * a, uint32x2_t b) { 3009 return vld1_lane_u32(a, b, 1); 3010 } 3011 3012 // CHECK-LABEL: test_vld1_lane_u64 3013 // CHECK: {{ldr|vldr|vmov}} 3014 uint64x1_t test_vld1_lane_u64(uint64_t const * a, uint64x1_t b) { 3015 return vld1_lane_u64(a, b, 0); 3016 } 3017 3018 // CHECK-LABEL: test_vld1_lane_s8 3019 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3020 int8x8_t test_vld1_lane_s8(int8_t const * a, int8x8_t b) { 3021 return vld1_lane_s8(a, b, 7); 3022 } 3023 3024 // CHECK-LABEL: test_vld1_lane_s16 3025 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3026 int16x4_t test_vld1_lane_s16(int16_t const * a, int16x4_t b) { 3027 return vld1_lane_s16(a, b, 3); 3028 } 3029 3030 // CHECK-LABEL: test_vld1_lane_s32 3031 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 3032 int32x2_t test_vld1_lane_s32(int32_t const * a, int32x2_t b) { 3033 return vld1_lane_s32(a, b, 1); 3034 } 3035 3036 // CHECK-LABEL: test_vld1_lane_s64 3037 // CHECK: {{ldr|vldr|vmov}} 3038 int64x1_t test_vld1_lane_s64(int64_t const * a, int64x1_t b) { 3039 return vld1_lane_s64(a, b, 0); 3040 } 3041 3042 // CHECK-LABEL: test_vld1_lane_f16 3043 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3044 float16x4_t test_vld1_lane_f16(float16_t const * a, float16x4_t b) { 3045 return vld1_lane_f16(a, b, 3); 3046 } 3047 3048 // CHECK-LABEL: test_vld1_lane_f32 3049 // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 3050 float32x2_t test_vld1_lane_f32(float32_t const * a, float32x2_t b) { 3051 return vld1_lane_f32(a, b, 1); 3052 } 3053 3054 // CHECK-LABEL: test_vld1_lane_p8 3055 // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3056 poly8x8_t test_vld1_lane_p8(poly8_t const * a, poly8x8_t b) { 3057 return vld1_lane_p8(a, b, 7); 3058 } 3059 3060 // CHECK-LABEL: test_vld1_lane_p16 3061 // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 3062 poly16x4_t test_vld1_lane_p16(poly16_t const * a, poly16x4_t b) { 3063 return vld1_lane_p16(a, b, 3); 3064 } 3065 3066 3067 // CHECK-LABEL: test_vld2q_u8 3068 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3069 uint8x16x2_t test_vld2q_u8(uint8_t const * a) { 3070 return vld2q_u8(a); 3071 } 3072 3073 // CHECK-LABEL: test_vld2q_u16 3074 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3075 uint16x8x2_t test_vld2q_u16(uint16_t const * a) { 3076 return vld2q_u16(a); 3077 } 3078 3079 // CHECK-LABEL: test_vld2q_u32 3080 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3081 uint32x4x2_t test_vld2q_u32(uint32_t const * a) { 3082 return vld2q_u32(a); 3083 } 3084 3085 // CHECK-LABEL: test_vld2q_s8 3086 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3087 int8x16x2_t test_vld2q_s8(int8_t const * a) { 3088 return vld2q_s8(a); 3089 } 3090 3091 // CHECK-LABEL: test_vld2q_s16 3092 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3093 int16x8x2_t test_vld2q_s16(int16_t const * a) { 3094 return vld2q_s16(a); 3095 } 3096 3097 // CHECK-LABEL: test_vld2q_s32 3098 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3099 int32x4x2_t test_vld2q_s32(int32_t const * a) { 3100 return vld2q_s32(a); 3101 } 3102 3103 // CHECK-LABEL: test_vld2q_f16 3104 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3105 float16x8x2_t test_vld2q_f16(float16_t const * a) { 3106 return vld2q_f16(a); 3107 } 3108 3109 // CHECK-LABEL: test_vld2q_f32 3110 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3111 float32x4x2_t test_vld2q_f32(float32_t const * a) { 3112 return vld2q_f32(a); 3113 } 3114 3115 // CHECK-LABEL: test_vld2q_p8 3116 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3117 poly8x16x2_t test_vld2q_p8(poly8_t const * a) { 3118 return vld2q_p8(a); 3119 } 3120 3121 // CHECK-LABEL: test_vld2q_p16 3122 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3123 poly16x8x2_t test_vld2q_p16(poly16_t const * a) { 3124 return vld2q_p16(a); 3125 } 3126 3127 // CHECK-LABEL: test_vld2_u8 3128 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3129 uint8x8x2_t test_vld2_u8(uint8_t const * a) { 3130 return vld2_u8(a); 3131 } 3132 3133 // CHECK-LABEL: test_vld2_u16 3134 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3135 uint16x4x2_t test_vld2_u16(uint16_t const * a) { 3136 return vld2_u16(a); 3137 } 3138 3139 // CHECK-LABEL: test_vld2_u32 3140 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3141 uint32x2x2_t test_vld2_u32(uint32_t const * a) { 3142 return vld2_u32(a); 3143 } 3144 3145 // CHECK-LABEL: test_vld2_u64 3146 // CHECK: vld1.64 3147 uint64x1x2_t test_vld2_u64(uint64_t const * a) { 3148 return vld2_u64(a); 3149 } 3150 3151 // CHECK-LABEL: test_vld2_s8 3152 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3153 int8x8x2_t test_vld2_s8(int8_t const * a) { 3154 return vld2_s8(a); 3155 } 3156 3157 // CHECK-LABEL: test_vld2_s16 3158 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3159 int16x4x2_t test_vld2_s16(int16_t const * a) { 3160 return vld2_s16(a); 3161 } 3162 3163 // CHECK-LABEL: test_vld2_s32 3164 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3165 int32x2x2_t test_vld2_s32(int32_t const * a) { 3166 return vld2_s32(a); 3167 } 3168 3169 // CHECK-LABEL: test_vld2_s64 3170 // CHECK: vld1.64 3171 int64x1x2_t test_vld2_s64(int64_t const * a) { 3172 return vld2_s64(a); 3173 } 3174 3175 // CHECK-LABEL: test_vld2_f16 3176 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3177 float16x4x2_t test_vld2_f16(float16_t const * a) { 3178 return vld2_f16(a); 3179 } 3180 3181 // CHECK-LABEL: test_vld2_f32 3182 // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3183 float32x2x2_t test_vld2_f32(float32_t const * a) { 3184 return vld2_f32(a); 3185 } 3186 3187 // CHECK-LABEL: test_vld2_p8 3188 // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3189 poly8x8x2_t test_vld2_p8(poly8_t const * a) { 3190 return vld2_p8(a); 3191 } 3192 3193 // CHECK-LABEL: test_vld2_p16 3194 // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3195 poly16x4x2_t test_vld2_p16(poly16_t const * a) { 3196 return vld2_p16(a); 3197 } 3198 3199 3200 // CHECK-LABEL: test_vld2_dup_u8 3201 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3202 uint8x8x2_t test_vld2_dup_u8(uint8_t const * a) { 3203 return vld2_dup_u8(a); 3204 } 3205 3206 // CHECK-LABEL: test_vld2_dup_u16 3207 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3208 uint16x4x2_t test_vld2_dup_u16(uint16_t const * a) { 3209 return vld2_dup_u16(a); 3210 } 3211 3212 // CHECK-LABEL: test_vld2_dup_u32 3213 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3214 uint32x2x2_t test_vld2_dup_u32(uint32_t const * a) { 3215 return vld2_dup_u32(a); 3216 } 3217 3218 // CHECK-LABEL: test_vld2_dup_u64 3219 // CHECK: vld1.64 3220 uint64x1x2_t test_vld2_dup_u64(uint64_t const * a) { 3221 return vld2_dup_u64(a); 3222 } 3223 3224 // CHECK-LABEL: test_vld2_dup_s8 3225 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3226 int8x8x2_t test_vld2_dup_s8(int8_t const * a) { 3227 return vld2_dup_s8(a); 3228 } 3229 3230 // CHECK-LABEL: test_vld2_dup_s16 3231 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3232 int16x4x2_t test_vld2_dup_s16(int16_t const * a) { 3233 return vld2_dup_s16(a); 3234 } 3235 3236 // CHECK-LABEL: test_vld2_dup_s32 3237 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3238 int32x2x2_t test_vld2_dup_s32(int32_t const * a) { 3239 return vld2_dup_s32(a); 3240 } 3241 3242 // CHECK-LABEL: test_vld2_dup_s64 3243 // CHECK: vld1.64 3244 int64x1x2_t test_vld2_dup_s64(int64_t const * a) { 3245 return vld2_dup_s64(a); 3246 } 3247 3248 // CHECK-LABEL: test_vld2_dup_f16 3249 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3250 float16x4x2_t test_vld2_dup_f16(float16_t const * a) { 3251 return vld2_dup_f16(a); 3252 } 3253 3254 // CHECK-LABEL: test_vld2_dup_f32 3255 // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3256 float32x2x2_t test_vld2_dup_f32(float32_t const * a) { 3257 return vld2_dup_f32(a); 3258 } 3259 3260 // CHECK-LABEL: test_vld2_dup_p8 3261 // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3262 poly8x8x2_t test_vld2_dup_p8(poly8_t const * a) { 3263 return vld2_dup_p8(a); 3264 } 3265 3266 // CHECK-LABEL: test_vld2_dup_p16 3267 // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3268 poly16x4x2_t test_vld2_dup_p16(poly16_t const * a) { 3269 return vld2_dup_p16(a); 3270 } 3271 3272 3273 // CHECK-LABEL: test_vld2q_lane_u16 3274 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3275 uint16x8x2_t test_vld2q_lane_u16(uint16_t const * a, uint16x8x2_t b) { 3276 return vld2q_lane_u16(a, b, 7); 3277 } 3278 3279 // CHECK-LABEL: test_vld2q_lane_u32 3280 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3281 uint32x4x2_t test_vld2q_lane_u32(uint32_t const * a, uint32x4x2_t b) { 3282 return vld2q_lane_u32(a, b, 3); 3283 } 3284 3285 // CHECK-LABEL: test_vld2q_lane_s16 3286 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3287 int16x8x2_t test_vld2q_lane_s16(int16_t const * a, int16x8x2_t b) { 3288 return vld2q_lane_s16(a, b, 7); 3289 } 3290 3291 // CHECK-LABEL: test_vld2q_lane_s32 3292 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3293 int32x4x2_t test_vld2q_lane_s32(int32_t const * a, int32x4x2_t b) { 3294 return vld2q_lane_s32(a, b, 3); 3295 } 3296 3297 // CHECK-LABEL: test_vld2q_lane_f16 3298 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3299 float16x8x2_t test_vld2q_lane_f16(float16_t const * a, float16x8x2_t b) { 3300 return vld2q_lane_f16(a, b, 7); 3301 } 3302 3303 // CHECK-LABEL: test_vld2q_lane_f32 3304 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3305 float32x4x2_t test_vld2q_lane_f32(float32_t const * a, float32x4x2_t b) { 3306 return vld2q_lane_f32(a, b, 3); 3307 } 3308 3309 // CHECK-LABEL: test_vld2q_lane_p16 3310 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3311 poly16x8x2_t test_vld2q_lane_p16(poly16_t const * a, poly16x8x2_t b) { 3312 return vld2q_lane_p16(a, b, 7); 3313 } 3314 3315 // CHECK-LABEL: test_vld2_lane_u8 3316 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3317 uint8x8x2_t test_vld2_lane_u8(uint8_t const * a, uint8x8x2_t b) { 3318 return vld2_lane_u8(a, b, 7); 3319 } 3320 3321 // CHECK-LABEL: test_vld2_lane_u16 3322 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3323 uint16x4x2_t test_vld2_lane_u16(uint16_t const * a, uint16x4x2_t b) { 3324 return vld2_lane_u16(a, b, 3); 3325 } 3326 3327 // CHECK-LABEL: test_vld2_lane_u32 3328 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3329 uint32x2x2_t test_vld2_lane_u32(uint32_t const * a, uint32x2x2_t b) { 3330 return vld2_lane_u32(a, b, 1); 3331 } 3332 3333 // CHECK-LABEL: test_vld2_lane_s8 3334 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3335 int8x8x2_t test_vld2_lane_s8(int8_t const * a, int8x8x2_t b) { 3336 return vld2_lane_s8(a, b, 7); 3337 } 3338 3339 // CHECK-LABEL: test_vld2_lane_s16 3340 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3341 int16x4x2_t test_vld2_lane_s16(int16_t const * a, int16x4x2_t b) { 3342 return vld2_lane_s16(a, b, 3); 3343 } 3344 3345 // CHECK-LABEL: test_vld2_lane_s32 3346 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3347 int32x2x2_t test_vld2_lane_s32(int32_t const * a, int32x2x2_t b) { 3348 return vld2_lane_s32(a, b, 1); 3349 } 3350 3351 // CHECK-LABEL: test_vld2_lane_f16 3352 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3353 float16x4x2_t test_vld2_lane_f16(float16_t const * a, float16x4x2_t b) { 3354 return vld2_lane_f16(a, b, 3); 3355 } 3356 3357 // CHECK-LABEL: test_vld2_lane_f32 3358 // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3359 float32x2x2_t test_vld2_lane_f32(float32_t const * a, float32x2x2_t b) { 3360 return vld2_lane_f32(a, b, 1); 3361 } 3362 3363 // CHECK-LABEL: test_vld2_lane_p8 3364 // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3365 poly8x8x2_t test_vld2_lane_p8(poly8_t const * a, poly8x8x2_t b) { 3366 return vld2_lane_p8(a, b, 7); 3367 } 3368 3369 // CHECK-LABEL: test_vld2_lane_p16 3370 // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3371 poly16x4x2_t test_vld2_lane_p16(poly16_t const * a, poly16x4x2_t b) { 3372 return vld2_lane_p16(a, b, 3); 3373 } 3374 3375 3376 // CHECK-LABEL: test_vld3q_u8 3377 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3378 uint8x16x3_t test_vld3q_u8(uint8_t const * a) { 3379 return vld3q_u8(a); 3380 } 3381 3382 // CHECK-LABEL: test_vld3q_u16 3383 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3384 uint16x8x3_t test_vld3q_u16(uint16_t const * a) { 3385 return vld3q_u16(a); 3386 } 3387 3388 // CHECK-LABEL: test_vld3q_u32 3389 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3390 uint32x4x3_t test_vld3q_u32(uint32_t const * a) { 3391 return vld3q_u32(a); 3392 } 3393 3394 // CHECK-LABEL: test_vld3q_s8 3395 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3396 int8x16x3_t test_vld3q_s8(int8_t const * a) { 3397 return vld3q_s8(a); 3398 } 3399 3400 // CHECK-LABEL: test_vld3q_s16 3401 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3402 int16x8x3_t test_vld3q_s16(int16_t const * a) { 3403 return vld3q_s16(a); 3404 } 3405 3406 // CHECK-LABEL: test_vld3q_s32 3407 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3408 int32x4x3_t test_vld3q_s32(int32_t const * a) { 3409 return vld3q_s32(a); 3410 } 3411 3412 // CHECK-LABEL: test_vld3q_f16 3413 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3414 float16x8x3_t test_vld3q_f16(float16_t const * a) { 3415 return vld3q_f16(a); 3416 } 3417 3418 // CHECK-LABEL: test_vld3q_f32 3419 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3420 float32x4x3_t test_vld3q_f32(float32_t const * a) { 3421 return vld3q_f32(a); 3422 } 3423 3424 // CHECK-LABEL: test_vld3q_p8 3425 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3426 poly8x16x3_t test_vld3q_p8(poly8_t const * a) { 3427 return vld3q_p8(a); 3428 } 3429 3430 // CHECK-LABEL: test_vld3q_p16 3431 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3432 poly16x8x3_t test_vld3q_p16(poly16_t const * a) { 3433 return vld3q_p16(a); 3434 } 3435 3436 // CHECK-LABEL: test_vld3_u8 3437 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3438 uint8x8x3_t test_vld3_u8(uint8_t const * a) { 3439 return vld3_u8(a); 3440 } 3441 3442 // CHECK-LABEL: test_vld3_u16 3443 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3444 uint16x4x3_t test_vld3_u16(uint16_t const * a) { 3445 return vld3_u16(a); 3446 } 3447 3448 // CHECK-LABEL: test_vld3_u32 3449 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3450 uint32x2x3_t test_vld3_u32(uint32_t const * a) { 3451 return vld3_u32(a); 3452 } 3453 3454 // CHECK-LABEL: test_vld3_u64 3455 // CHECK: vld1.64 3456 uint64x1x3_t test_vld3_u64(uint64_t const * a) { 3457 return vld3_u64(a); 3458 } 3459 3460 // CHECK-LABEL: test_vld3_s8 3461 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3462 int8x8x3_t test_vld3_s8(int8_t const * a) { 3463 return vld3_s8(a); 3464 } 3465 3466 // CHECK-LABEL: test_vld3_s16 3467 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3468 int16x4x3_t test_vld3_s16(int16_t const * a) { 3469 return vld3_s16(a); 3470 } 3471 3472 // CHECK-LABEL: test_vld3_s32 3473 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3474 int32x2x3_t test_vld3_s32(int32_t const * a) { 3475 return vld3_s32(a); 3476 } 3477 3478 // CHECK-LABEL: test_vld3_s64 3479 // CHECK: vld1.64 3480 int64x1x3_t test_vld3_s64(int64_t const * a) { 3481 return vld3_s64(a); 3482 } 3483 3484 // CHECK-LABEL: test_vld3_f16 3485 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3486 float16x4x3_t test_vld3_f16(float16_t const * a) { 3487 return vld3_f16(a); 3488 } 3489 3490 // CHECK-LABEL: test_vld3_f32 3491 // CHECK: vld3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3492 float32x2x3_t test_vld3_f32(float32_t const * a) { 3493 return vld3_f32(a); 3494 } 3495 3496 // CHECK-LABEL: test_vld3_p8 3497 // CHECK: vld3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3498 poly8x8x3_t test_vld3_p8(poly8_t const * a) { 3499 return vld3_p8(a); 3500 } 3501 3502 // CHECK-LABEL: test_vld3_p16 3503 // CHECK: vld3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3504 poly16x4x3_t test_vld3_p16(poly16_t const * a) { 3505 return vld3_p16(a); 3506 } 3507 3508 3509 // CHECK-LABEL: test_vld3_dup_u8 3510 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3511 uint8x8x3_t test_vld3_dup_u8(uint8_t const * a) { 3512 return vld3_dup_u8(a); 3513 } 3514 3515 // CHECK-LABEL: test_vld3_dup_u16 3516 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3517 uint16x4x3_t test_vld3_dup_u16(uint16_t const * a) { 3518 return vld3_dup_u16(a); 3519 } 3520 3521 // CHECK-LABEL: test_vld3_dup_u32 3522 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3523 uint32x2x3_t test_vld3_dup_u32(uint32_t const * a) { 3524 return vld3_dup_u32(a); 3525 } 3526 3527 // CHECK-LABEL: test_vld3_dup_u64 3528 // CHECK: vld1.64 3529 uint64x1x3_t test_vld3_dup_u64(uint64_t const * a) { 3530 return vld3_dup_u64(a); 3531 } 3532 3533 // CHECK-LABEL: test_vld3_dup_s8 3534 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3535 int8x8x3_t test_vld3_dup_s8(int8_t const * a) { 3536 return vld3_dup_s8(a); 3537 } 3538 3539 // CHECK-LABEL: test_vld3_dup_s16 3540 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3541 int16x4x3_t test_vld3_dup_s16(int16_t const * a) { 3542 return vld3_dup_s16(a); 3543 } 3544 3545 // CHECK-LABEL: test_vld3_dup_s32 3546 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3547 int32x2x3_t test_vld3_dup_s32(int32_t const * a) { 3548 return vld3_dup_s32(a); 3549 } 3550 3551 // CHECK-LABEL: test_vld3_dup_s64 3552 // CHECK: vld1.64 3553 int64x1x3_t test_vld3_dup_s64(int64_t const * a) { 3554 return vld3_dup_s64(a); 3555 } 3556 3557 // CHECK-LABEL: test_vld3_dup_f16 3558 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3559 float16x4x3_t test_vld3_dup_f16(float16_t const * a) { 3560 return vld3_dup_f16(a); 3561 } 3562 3563 // CHECK-LABEL: test_vld3_dup_f32 3564 // CHECK: vld3.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3565 float32x2x3_t test_vld3_dup_f32(float32_t const * a) { 3566 return vld3_dup_f32(a); 3567 } 3568 3569 // CHECK-LABEL: test_vld3_dup_p8 3570 // CHECK: vld3.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3571 poly8x8x3_t test_vld3_dup_p8(poly8_t const * a) { 3572 return vld3_dup_p8(a); 3573 } 3574 3575 // CHECK-LABEL: test_vld3_dup_p16 3576 // CHECK: vld3.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3577 poly16x4x3_t test_vld3_dup_p16(poly16_t const * a) { 3578 return vld3_dup_p16(a); 3579 } 3580 3581 3582 // CHECK-LABEL: test_vld3q_lane_u16 3583 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3584 uint16x8x3_t test_vld3q_lane_u16(uint16_t const * a, uint16x8x3_t b) { 3585 return vld3q_lane_u16(a, b, 7); 3586 } 3587 3588 // CHECK-LABEL: test_vld3q_lane_u32 3589 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3590 uint32x4x3_t test_vld3q_lane_u32(uint32_t const * a, uint32x4x3_t b) { 3591 return vld3q_lane_u32(a, b, 3); 3592 } 3593 3594 // CHECK-LABEL: test_vld3q_lane_s16 3595 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3596 int16x8x3_t test_vld3q_lane_s16(int16_t const * a, int16x8x3_t b) { 3597 return vld3q_lane_s16(a, b, 7); 3598 } 3599 3600 // CHECK-LABEL: test_vld3q_lane_s32 3601 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3602 int32x4x3_t test_vld3q_lane_s32(int32_t const * a, int32x4x3_t b) { 3603 return vld3q_lane_s32(a, b, 3); 3604 } 3605 3606 // CHECK-LABEL: test_vld3q_lane_f16 3607 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3608 float16x8x3_t test_vld3q_lane_f16(float16_t const * a, float16x8x3_t b) { 3609 return vld3q_lane_f16(a, b, 7); 3610 } 3611 3612 // CHECK-LABEL: test_vld3q_lane_f32 3613 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3614 float32x4x3_t test_vld3q_lane_f32(float32_t const * a, float32x4x3_t b) { 3615 return vld3q_lane_f32(a, b, 3); 3616 } 3617 3618 // CHECK-LABEL: test_vld3q_lane_p16 3619 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3620 poly16x8x3_t test_vld3q_lane_p16(poly16_t const * a, poly16x8x3_t b) { 3621 return vld3q_lane_p16(a, b, 7); 3622 } 3623 3624 // CHECK-LABEL: test_vld3_lane_u8 3625 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3626 uint8x8x3_t test_vld3_lane_u8(uint8_t const * a, uint8x8x3_t b) { 3627 return vld3_lane_u8(a, b, 7); 3628 } 3629 3630 // CHECK-LABEL: test_vld3_lane_u16 3631 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3632 uint16x4x3_t test_vld3_lane_u16(uint16_t const * a, uint16x4x3_t b) { 3633 return vld3_lane_u16(a, b, 3); 3634 } 3635 3636 // CHECK-LABEL: test_vld3_lane_u32 3637 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3638 uint32x2x3_t test_vld3_lane_u32(uint32_t const * a, uint32x2x3_t b) { 3639 return vld3_lane_u32(a, b, 1); 3640 } 3641 3642 // CHECK-LABEL: test_vld3_lane_s8 3643 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3644 int8x8x3_t test_vld3_lane_s8(int8_t const * a, int8x8x3_t b) { 3645 return vld3_lane_s8(a, b, 7); 3646 } 3647 3648 // CHECK-LABEL: test_vld3_lane_s16 3649 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3650 int16x4x3_t test_vld3_lane_s16(int16_t const * a, int16x4x3_t b) { 3651 return vld3_lane_s16(a, b, 3); 3652 } 3653 3654 // CHECK-LABEL: test_vld3_lane_s32 3655 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3656 int32x2x3_t test_vld3_lane_s32(int32_t const * a, int32x2x3_t b) { 3657 return vld3_lane_s32(a, b, 1); 3658 } 3659 3660 // CHECK-LABEL: test_vld3_lane_f16 3661 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3662 float16x4x3_t test_vld3_lane_f16(float16_t const * a, float16x4x3_t b) { 3663 return vld3_lane_f16(a, b, 3); 3664 } 3665 3666 // CHECK-LABEL: test_vld3_lane_f32 3667 // CHECK: vld3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3668 float32x2x3_t test_vld3_lane_f32(float32_t const * a, float32x2x3_t b) { 3669 return vld3_lane_f32(a, b, 1); 3670 } 3671 3672 // CHECK-LABEL: test_vld3_lane_p8 3673 // CHECK: vld3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3674 poly8x8x3_t test_vld3_lane_p8(poly8_t const * a, poly8x8x3_t b) { 3675 return vld3_lane_p8(a, b, 7); 3676 } 3677 3678 // CHECK-LABEL: test_vld3_lane_p16 3679 // CHECK: vld3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 3680 poly16x4x3_t test_vld3_lane_p16(poly16_t const * a, poly16x4x3_t b) { 3681 return vld3_lane_p16(a, b, 3); 3682 } 3683 3684 3685 // CHECK-LABEL: test_vld4q_u8 3686 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3687 uint8x16x4_t test_vld4q_u8(uint8_t const * a) { 3688 return vld4q_u8(a); 3689 } 3690 3691 // CHECK-LABEL: test_vld4q_u16 3692 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3693 uint16x8x4_t test_vld4q_u16(uint16_t const * a) { 3694 return vld4q_u16(a); 3695 } 3696 3697 // CHECK-LABEL: test_vld4q_u32 3698 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3699 uint32x4x4_t test_vld4q_u32(uint32_t const * a) { 3700 return vld4q_u32(a); 3701 } 3702 3703 // CHECK-LABEL: test_vld4q_s8 3704 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3705 int8x16x4_t test_vld4q_s8(int8_t const * a) { 3706 return vld4q_s8(a); 3707 } 3708 3709 // CHECK-LABEL: test_vld4q_s16 3710 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3711 int16x8x4_t test_vld4q_s16(int16_t const * a) { 3712 return vld4q_s16(a); 3713 } 3714 3715 // CHECK-LABEL: test_vld4q_s32 3716 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3717 int32x4x4_t test_vld4q_s32(int32_t const * a) { 3718 return vld4q_s32(a); 3719 } 3720 3721 // CHECK-LABEL: test_vld4q_f16 3722 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3723 float16x8x4_t test_vld4q_f16(float16_t const * a) { 3724 return vld4q_f16(a); 3725 } 3726 3727 // CHECK-LABEL: test_vld4q_f32 3728 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3729 float32x4x4_t test_vld4q_f32(float32_t const * a) { 3730 return vld4q_f32(a); 3731 } 3732 3733 // CHECK-LABEL: test_vld4q_p8 3734 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3735 poly8x16x4_t test_vld4q_p8(poly8_t const * a) { 3736 return vld4q_p8(a); 3737 } 3738 3739 // CHECK-LABEL: test_vld4q_p16 3740 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 3741 poly16x8x4_t test_vld4q_p16(poly16_t const * a) { 3742 return vld4q_p16(a); 3743 } 3744 3745 // CHECK-LABEL: test_vld4_u8 3746 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3747 uint8x8x4_t test_vld4_u8(uint8_t const * a) { 3748 return vld4_u8(a); 3749 } 3750 3751 // CHECK-LABEL: test_vld4_u16 3752 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3753 uint16x4x4_t test_vld4_u16(uint16_t const * a) { 3754 return vld4_u16(a); 3755 } 3756 3757 // CHECK-LABEL: test_vld4_u32 3758 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3759 uint32x2x4_t test_vld4_u32(uint32_t const * a) { 3760 return vld4_u32(a); 3761 } 3762 3763 // CHECK-LABEL: test_vld4_u64 3764 // CHECK: vld1.64 3765 uint64x1x4_t test_vld4_u64(uint64_t const * a) { 3766 return vld4_u64(a); 3767 } 3768 3769 // CHECK-LABEL: test_vld4_s8 3770 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3771 int8x8x4_t test_vld4_s8(int8_t const * a) { 3772 return vld4_s8(a); 3773 } 3774 3775 // CHECK-LABEL: test_vld4_s16 3776 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3777 int16x4x4_t test_vld4_s16(int16_t const * a) { 3778 return vld4_s16(a); 3779 } 3780 3781 // CHECK-LABEL: test_vld4_s32 3782 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3783 int32x2x4_t test_vld4_s32(int32_t const * a) { 3784 return vld4_s32(a); 3785 } 3786 3787 // CHECK-LABEL: test_vld4_s64 3788 // CHECK: vld1.64 3789 int64x1x4_t test_vld4_s64(int64_t const * a) { 3790 return vld4_s64(a); 3791 } 3792 3793 // CHECK-LABEL: test_vld4_f16 3794 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3795 float16x4x4_t test_vld4_f16(float16_t const * a) { 3796 return vld4_f16(a); 3797 } 3798 3799 // CHECK-LABEL: test_vld4_f32 3800 // CHECK: vld4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3801 float32x2x4_t test_vld4_f32(float32_t const * a) { 3802 return vld4_f32(a); 3803 } 3804 3805 // CHECK-LABEL: test_vld4_p8 3806 // CHECK: vld4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3807 poly8x8x4_t test_vld4_p8(poly8_t const * a) { 3808 return vld4_p8(a); 3809 } 3810 3811 // CHECK-LABEL: test_vld4_p16 3812 // CHECK: vld4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 3813 poly16x4x4_t test_vld4_p16(poly16_t const * a) { 3814 return vld4_p16(a); 3815 } 3816 3817 3818 // CHECK-LABEL: test_vld4_dup_u8 3819 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3820 uint8x8x4_t test_vld4_dup_u8(uint8_t const * a) { 3821 return vld4_dup_u8(a); 3822 } 3823 3824 // CHECK-LABEL: test_vld4_dup_u16 3825 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3826 uint16x4x4_t test_vld4_dup_u16(uint16_t const * a) { 3827 return vld4_dup_u16(a); 3828 } 3829 3830 // CHECK-LABEL: test_vld4_dup_u32 3831 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3832 uint32x2x4_t test_vld4_dup_u32(uint32_t const * a) { 3833 return vld4_dup_u32(a); 3834 } 3835 3836 // CHECK-LABEL: test_vld4_dup_u64 3837 // CHECK: vld1.64 3838 uint64x1x4_t test_vld4_dup_u64(uint64_t const * a) { 3839 return vld4_dup_u64(a); 3840 } 3841 3842 // CHECK-LABEL: test_vld4_dup_s8 3843 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3844 int8x8x4_t test_vld4_dup_s8(int8_t const * a) { 3845 return vld4_dup_s8(a); 3846 } 3847 3848 // CHECK-LABEL: test_vld4_dup_s16 3849 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3850 int16x4x4_t test_vld4_dup_s16(int16_t const * a) { 3851 return vld4_dup_s16(a); 3852 } 3853 3854 // CHECK-LABEL: test_vld4_dup_s32 3855 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3856 int32x2x4_t test_vld4_dup_s32(int32_t const * a) { 3857 return vld4_dup_s32(a); 3858 } 3859 3860 // CHECK-LABEL: test_vld4_dup_s64 3861 // CHECK: vld1.64 3862 int64x1x4_t test_vld4_dup_s64(int64_t const * a) { 3863 return vld4_dup_s64(a); 3864 } 3865 3866 // CHECK-LABEL: test_vld4_dup_f16 3867 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3868 float16x4x4_t test_vld4_dup_f16(float16_t const * a) { 3869 return vld4_dup_f16(a); 3870 } 3871 3872 // CHECK-LABEL: test_vld4_dup_f32 3873 // CHECK: vld4.32 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3874 float32x2x4_t test_vld4_dup_f32(float32_t const * a) { 3875 return vld4_dup_f32(a); 3876 } 3877 3878 // CHECK-LABEL: test_vld4_dup_p8 3879 // CHECK: vld4.8 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3880 poly8x8x4_t test_vld4_dup_p8(poly8_t const * a) { 3881 return vld4_dup_p8(a); 3882 } 3883 3884 // CHECK-LABEL: test_vld4_dup_p16 3885 // CHECK: vld4.16 {d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] 3886 poly16x4x4_t test_vld4_dup_p16(poly16_t const * a) { 3887 return vld4_dup_p16(a); 3888 } 3889 3890 3891 // CHECK-LABEL: test_vld4q_lane_u16 3892 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3893 uint16x8x4_t test_vld4q_lane_u16(uint16_t const * a, uint16x8x4_t b) { 3894 return vld4q_lane_u16(a, b, 7); 3895 } 3896 3897 // CHECK-LABEL: test_vld4q_lane_u32 3898 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3899 uint32x4x4_t test_vld4q_lane_u32(uint32_t const * a, uint32x4x4_t b) { 3900 return vld4q_lane_u32(a, b, 3); 3901 } 3902 3903 // CHECK-LABEL: test_vld4q_lane_s16 3904 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3905 int16x8x4_t test_vld4q_lane_s16(int16_t const * a, int16x8x4_t b) { 3906 return vld4q_lane_s16(a, b, 7); 3907 } 3908 3909 // CHECK-LABEL: test_vld4q_lane_s32 3910 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3911 int32x4x4_t test_vld4q_lane_s32(int32_t const * a, int32x4x4_t b) { 3912 return vld4q_lane_s32(a, b, 3); 3913 } 3914 3915 // CHECK-LABEL: test_vld4q_lane_f16 3916 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3917 float16x8x4_t test_vld4q_lane_f16(float16_t const * a, float16x8x4_t b) { 3918 return vld4q_lane_f16(a, b, 7); 3919 } 3920 3921 // CHECK-LABEL: test_vld4q_lane_f32 3922 // CHECK: vld4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3923 float32x4x4_t test_vld4q_lane_f32(float32_t const * a, float32x4x4_t b) { 3924 return vld4q_lane_f32(a, b, 3); 3925 } 3926 3927 // CHECK-LABEL: test_vld4q_lane_p16 3928 // CHECK: vld4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 3929 poly16x8x4_t test_vld4q_lane_p16(poly16_t const * a, poly16x8x4_t b) { 3930 return vld4q_lane_p16(a, b, 7); 3931 } 3932 3933 // CHECK-LABEL: test_vld4_lane_u8 3934 // 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]+}}] 3935 uint8x8x4_t test_vld4_lane_u8(uint8_t const * a, uint8x8x4_t b) { 3936 return vld4_lane_u8(a, b, 7); 3937 } 3938 3939 // CHECK-LABEL: test_vld4_lane_u16 3940 // 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]+}}] 3941 uint16x4x4_t test_vld4_lane_u16(uint16_t const * a, uint16x4x4_t b) { 3942 return vld4_lane_u16(a, b, 3); 3943 } 3944 3945 // CHECK-LABEL: test_vld4_lane_u32 3946 // 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]+}}] 3947 uint32x2x4_t test_vld4_lane_u32(uint32_t const * a, uint32x2x4_t b) { 3948 return vld4_lane_u32(a, b, 1); 3949 } 3950 3951 // CHECK-LABEL: test_vld4_lane_s8 3952 // 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]+}}] 3953 int8x8x4_t test_vld4_lane_s8(int8_t const * a, int8x8x4_t b) { 3954 return vld4_lane_s8(a, b, 7); 3955 } 3956 3957 // CHECK-LABEL: test_vld4_lane_s16 3958 // 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]+}}] 3959 int16x4x4_t test_vld4_lane_s16(int16_t const * a, int16x4x4_t b) { 3960 return vld4_lane_s16(a, b, 3); 3961 } 3962 3963 // CHECK-LABEL: test_vld4_lane_s32 3964 // 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]+}}] 3965 int32x2x4_t test_vld4_lane_s32(int32_t const * a, int32x2x4_t b) { 3966 return vld4_lane_s32(a, b, 1); 3967 } 3968 3969 // CHECK-LABEL: test_vld4_lane_f16 3970 // 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]+}}] 3971 float16x4x4_t test_vld4_lane_f16(float16_t const * a, float16x4x4_t b) { 3972 return vld4_lane_f16(a, b, 3); 3973 } 3974 3975 // CHECK-LABEL: test_vld4_lane_f32 3976 // 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]+}}] 3977 float32x2x4_t test_vld4_lane_f32(float32_t const * a, float32x2x4_t b) { 3978 return vld4_lane_f32(a, b, 1); 3979 } 3980 3981 // CHECK-LABEL: test_vld4_lane_p8 3982 // 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]+}}] 3983 poly8x8x4_t test_vld4_lane_p8(poly8_t const * a, poly8x8x4_t b) { 3984 return vld4_lane_p8(a, b, 7); 3985 } 3986 3987 // CHECK-LABEL: test_vld4_lane_p16 3988 // 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]+}}] 3989 poly16x4x4_t test_vld4_lane_p16(poly16_t const * a, poly16x4x4_t b) { 3990 return vld4_lane_p16(a, b, 3); 3991 } 3992 3993 3994 // CHECK-LABEL: test_vmax_s8 3995 // CHECK: vmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 3996 int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) { 3997 return vmax_s8(a, b); 3998 } 3999 4000 // CHECK-LABEL: test_vmax_s16 4001 // CHECK: vmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4002 int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) { 4003 return vmax_s16(a, b); 4004 } 4005 4006 // CHECK-LABEL: test_vmax_s32 4007 // CHECK: vmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4008 int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) { 4009 return vmax_s32(a, b); 4010 } 4011 4012 // CHECK-LABEL: test_vmax_u8 4013 // CHECK: vmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4014 uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) { 4015 return vmax_u8(a, b); 4016 } 4017 4018 // CHECK-LABEL: test_vmax_u16 4019 // CHECK: vmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4020 uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) { 4021 return vmax_u16(a, b); 4022 } 4023 4024 // CHECK-LABEL: test_vmax_u32 4025 // CHECK: vmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4026 uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) { 4027 return vmax_u32(a, b); 4028 } 4029 4030 // CHECK-LABEL: test_vmax_f32 4031 // CHECK: vmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4032 float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) { 4033 return vmax_f32(a, b); 4034 } 4035 4036 // CHECK-LABEL: test_vmaxq_s8 4037 // CHECK: vmax.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4038 int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) { 4039 return vmaxq_s8(a, b); 4040 } 4041 4042 // CHECK-LABEL: test_vmaxq_s16 4043 // CHECK: vmax.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4044 int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) { 4045 return vmaxq_s16(a, b); 4046 } 4047 4048 // CHECK-LABEL: test_vmaxq_s32 4049 // CHECK: vmax.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4050 int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) { 4051 return vmaxq_s32(a, b); 4052 } 4053 4054 // CHECK-LABEL: test_vmaxq_u8 4055 // CHECK: vmax.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4056 uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) { 4057 return vmaxq_u8(a, b); 4058 } 4059 4060 // CHECK-LABEL: test_vmaxq_u16 4061 // CHECK: vmax.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4062 uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) { 4063 return vmaxq_u16(a, b); 4064 } 4065 4066 // CHECK-LABEL: test_vmaxq_u32 4067 // CHECK: vmax.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4068 uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) { 4069 return vmaxq_u32(a, b); 4070 } 4071 4072 // CHECK-LABEL: test_vmaxq_f32 4073 // CHECK: vmax.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4074 float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) { 4075 return vmaxq_f32(a, b); 4076 } 4077 4078 4079 // CHECK-LABEL: test_vmin_s8 4080 // CHECK: vmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4081 int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) { 4082 return vmin_s8(a, b); 4083 } 4084 4085 // CHECK-LABEL: test_vmin_s16 4086 // CHECK: vmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4087 int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) { 4088 return vmin_s16(a, b); 4089 } 4090 4091 // CHECK-LABEL: test_vmin_s32 4092 // CHECK: vmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4093 int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) { 4094 return vmin_s32(a, b); 4095 } 4096 4097 // CHECK-LABEL: test_vmin_u8 4098 // CHECK: vmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4099 uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) { 4100 return vmin_u8(a, b); 4101 } 4102 4103 // CHECK-LABEL: test_vmin_u16 4104 // CHECK: vmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4105 uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) { 4106 return vmin_u16(a, b); 4107 } 4108 4109 // CHECK-LABEL: test_vmin_u32 4110 // CHECK: vmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4111 uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) { 4112 return vmin_u32(a, b); 4113 } 4114 4115 // CHECK-LABEL: test_vmin_f32 4116 // CHECK: vmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4117 float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) { 4118 return vmin_f32(a, b); 4119 } 4120 4121 // CHECK-LABEL: test_vminq_s8 4122 // CHECK: vmin.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4123 int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) { 4124 return vminq_s8(a, b); 4125 } 4126 4127 // CHECK-LABEL: test_vminq_s16 4128 // CHECK: vmin.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4129 int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) { 4130 return vminq_s16(a, b); 4131 } 4132 4133 // CHECK-LABEL: test_vminq_s32 4134 // CHECK: vmin.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4135 int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) { 4136 return vminq_s32(a, b); 4137 } 4138 4139 // CHECK-LABEL: test_vminq_u8 4140 // CHECK: vmin.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4141 uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) { 4142 return vminq_u8(a, b); 4143 } 4144 4145 // CHECK-LABEL: test_vminq_u16 4146 // CHECK: vmin.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4147 uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) { 4148 return vminq_u16(a, b); 4149 } 4150 4151 // CHECK-LABEL: test_vminq_u32 4152 // CHECK: vmin.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4153 uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) { 4154 return vminq_u32(a, b); 4155 } 4156 4157 // CHECK-LABEL: test_vminq_f32 4158 // CHECK: vmin.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4159 float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) { 4160 return vminq_f32(a, b); 4161 } 4162 4163 4164 // CHECK-LABEL: test_vmla_s8 4165 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4166 int8x8_t test_vmla_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 4167 return vmla_s8(a, b, c); 4168 } 4169 4170 // CHECK-LABEL: test_vmla_s16 4171 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4172 int16x4_t test_vmla_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4173 return vmla_s16(a, b, c); 4174 } 4175 4176 // CHECK-LABEL: test_vmla_s32 4177 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4178 int32x2_t test_vmla_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4179 return vmla_s32(a, b, c); 4180 } 4181 4182 // CHECK-LABEL: test_vmla_f32 4183 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4184 // CHECK-SWIFT: vadd.f32 4185 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4186 float32x2_t test_vmla_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4187 return vmla_f32(a, b, c); 4188 } 4189 4190 // CHECK-LABEL: test_vmla_u8 4191 // CHECK: vmla.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4192 uint8x8_t test_vmla_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 4193 return vmla_u8(a, b, c); 4194 } 4195 4196 // CHECK-LABEL: test_vmla_u16 4197 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4198 uint16x4_t test_vmla_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4199 return vmla_u16(a, b, c); 4200 } 4201 4202 // CHECK-LABEL: test_vmla_u32 4203 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4204 uint32x2_t test_vmla_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4205 return vmla_u32(a, b, c); 4206 } 4207 4208 // CHECK-LABEL: test_vmlaq_s8 4209 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4210 int8x16_t test_vmlaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 4211 return vmlaq_s8(a, b, c); 4212 } 4213 4214 // CHECK-LABEL: test_vmlaq_s16 4215 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4216 int16x8_t test_vmlaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 4217 return vmlaq_s16(a, b, c); 4218 } 4219 4220 // CHECK-LABEL: test_vmlaq_s32 4221 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4222 int32x4_t test_vmlaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 4223 return vmlaq_s32(a, b, c); 4224 } 4225 4226 // CHECK-LABEL: test_vmlaq_f32 4227 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4228 // CHECK-SWIFT: vadd.f32 4229 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4230 float32x4_t test_vmlaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 4231 return vmlaq_f32(a, b, c); 4232 } 4233 4234 // CHECK-LABEL: test_vmlaq_u8 4235 // CHECK: vmla.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4236 uint8x16_t test_vmlaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 4237 return vmlaq_u8(a, b, c); 4238 } 4239 4240 // CHECK-LABEL: test_vmlaq_u16 4241 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4242 uint16x8_t test_vmlaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 4243 return vmlaq_u16(a, b, c); 4244 } 4245 4246 // CHECK-LABEL: test_vmlaq_u32 4247 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4248 uint32x4_t test_vmlaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 4249 return vmlaq_u32(a, b, c); 4250 } 4251 4252 4253 // CHECK-LABEL: test_vmlal_s8 4254 // CHECK: vmlal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4255 int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 4256 return vmlal_s8(a, b, c); 4257 } 4258 4259 // CHECK-LABEL: test_vmlal_s16 4260 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4261 int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4262 return vmlal_s16(a, b, c); 4263 } 4264 4265 // CHECK-LABEL: test_vmlal_s32 4266 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4267 int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4268 return vmlal_s32(a, b, c); 4269 } 4270 4271 // CHECK-LABEL: test_vmlal_u8 4272 // CHECK: vmlal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4273 uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 4274 return vmlal_u8(a, b, c); 4275 } 4276 4277 // CHECK-LABEL: test_vmlal_u16 4278 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4279 uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4280 return vmlal_u16(a, b, c); 4281 } 4282 4283 // CHECK-LABEL: test_vmlal_u32 4284 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4285 uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4286 return vmlal_u32(a, b, c); 4287 } 4288 4289 4290 // CHECK-LABEL: test_vmlal_lane_s16 4291 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4292 int32x4_t test_vmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4293 return vmlal_lane_s16(a, b, c, 3); 4294 } 4295 4296 // CHECK-LABEL: test_vmlal_lane_s32 4297 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4298 int64x2_t test_vmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4299 return vmlal_lane_s32(a, b, c, 1); 4300 } 4301 4302 // CHECK-LABEL: test_vmlal_lane_u16 4303 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4304 uint32x4_t test_vmlal_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4305 return vmlal_lane_u16(a, b, c, 3); 4306 } 4307 4308 // CHECK-LABEL: test_vmlal_lane_u32 4309 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4310 uint64x2_t test_vmlal_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4311 return vmlal_lane_u32(a, b, c, 1); 4312 } 4313 4314 4315 // CHECK-LABEL: test_vmlal_n_s16 4316 // CHECK: vmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4317 int32x4_t test_vmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 4318 return vmlal_n_s16(a, b, c); 4319 } 4320 4321 // CHECK-LABEL: test_vmlal_n_s32 4322 // CHECK: vmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4323 int64x2_t test_vmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 4324 return vmlal_n_s32(a, b, c); 4325 } 4326 4327 // CHECK-LABEL: test_vmlal_n_u16 4328 // CHECK: vmlal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4329 uint32x4_t test_vmlal_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) { 4330 return vmlal_n_u16(a, b, c); 4331 } 4332 4333 // CHECK-LABEL: test_vmlal_n_u32 4334 // CHECK: vmlal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4335 uint64x2_t test_vmlal_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) { 4336 return vmlal_n_u32(a, b, c); 4337 } 4338 4339 4340 // CHECK-LABEL: test_vmla_lane_s16 4341 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4342 int16x4_t test_vmla_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4343 return vmla_lane_s16(a, b, c, 3); 4344 } 4345 4346 // CHECK-LABEL: test_vmla_lane_s32 4347 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4348 int32x2_t test_vmla_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4349 return vmla_lane_s32(a, b, c, 1); 4350 } 4351 4352 // CHECK-LABEL: test_vmla_lane_u16 4353 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4354 uint16x4_t test_vmla_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4355 return vmla_lane_u16(a, b, c, 3); 4356 } 4357 4358 // CHECK-LABEL: test_vmla_lane_u32 4359 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4360 uint32x2_t test_vmla_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4361 return vmla_lane_u32(a, b, c, 1); 4362 } 4363 4364 // CHECK-LABEL: test_vmla_lane_f32 4365 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4366 // CHECK-SWIFT: vadd.f32 4367 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4368 float32x2_t test_vmla_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4369 return vmla_lane_f32(a, b, c, 1); 4370 } 4371 4372 // CHECK-LABEL: test_vmlaq_lane_s16 4373 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4374 int16x8_t test_vmlaq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) { 4375 return vmlaq_lane_s16(a, b, c, 3); 4376 } 4377 4378 // CHECK-LABEL: test_vmlaq_lane_s32 4379 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4380 int32x4_t test_vmlaq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) { 4381 return vmlaq_lane_s32(a, b, c, 1); 4382 } 4383 4384 // CHECK-LABEL: test_vmlaq_lane_u16 4385 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4386 uint16x8_t test_vmlaq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) { 4387 return vmlaq_lane_u16(a, b, c, 3); 4388 } 4389 4390 // CHECK-LABEL: test_vmlaq_lane_u32 4391 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4392 uint32x4_t test_vmlaq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) { 4393 return vmlaq_lane_u32(a, b, c, 1); 4394 } 4395 4396 // CHECK-LABEL: test_vmlaq_lane_f32 4397 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4398 // CHECK-SWIFT: vadd.f32 4399 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4400 float32x4_t test_vmlaq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) { 4401 return vmlaq_lane_f32(a, b, c, 1); 4402 } 4403 4404 4405 // CHECK-LABEL: test_vmla_n_s16 4406 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4407 int16x4_t test_vmla_n_s16(int16x4_t a, int16x4_t b, int16_t c) { 4408 return vmla_n_s16(a, b, c); 4409 } 4410 4411 // CHECK-LABEL: test_vmla_n_s32 4412 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4413 int32x2_t test_vmla_n_s32(int32x2_t a, int32x2_t b, int32_t c) { 4414 return vmla_n_s32(a, b, c); 4415 } 4416 4417 // CHECK-LABEL: test_vmla_n_u16 4418 // CHECK: vmla.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4419 uint16x4_t test_vmla_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) { 4420 return vmla_n_u16(a, b, c); 4421 } 4422 4423 // CHECK-LABEL: test_vmla_n_u32 4424 // CHECK: vmla.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4425 uint32x2_t test_vmla_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) { 4426 return vmla_n_u32(a, b, c); 4427 } 4428 4429 // CHECK-LABEL: test_vmla_n_f32 4430 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4431 // CHECK-SWIFT: vadd.f32 4432 // CHECK-A57: vmla.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4433 float32x2_t test_vmla_n_f32(float32x2_t a, float32x2_t b, float32_t c) { 4434 return vmla_n_f32(a, b, c); 4435 } 4436 4437 // CHECK-LABEL: test_vmlaq_n_s16 4438 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4439 int16x8_t test_vmlaq_n_s16(int16x8_t a, int16x8_t b, int16_t c) { 4440 return vmlaq_n_s16(a, b, c); 4441 } 4442 4443 // CHECK-LABEL: test_vmlaq_n_s32 4444 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4445 int32x4_t test_vmlaq_n_s32(int32x4_t a, int32x4_t b, int32_t c) { 4446 return vmlaq_n_s32(a, b, c); 4447 } 4448 4449 // CHECK-LABEL: test_vmlaq_n_u16 4450 // CHECK: vmla.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4451 uint16x8_t test_vmlaq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) { 4452 return vmlaq_n_u16(a, b, c); 4453 } 4454 4455 // CHECK-LABEL: test_vmlaq_n_u32 4456 // CHECK: vmla.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4457 uint32x4_t test_vmlaq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) { 4458 return vmlaq_n_u32(a, b, c); 4459 } 4460 4461 // CHECK-LABEL: test_vmlaq_n_f32 4462 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0] 4463 // CHECK-SWIFT: vadd.f32 4464 // CHECK-A57: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, 4465 // CHECK-A57: vmla.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4466 float32x4_t test_vmlaq_n_f32(float32x4_t a, float32x4_t b, float32_t c) { 4467 return vmlaq_n_f32(a, b, c); 4468 } 4469 4470 4471 // CHECK-LABEL: test_vmls_s8 4472 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4473 int8x8_t test_vmls_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 4474 return vmls_s8(a, b, c); 4475 } 4476 4477 // CHECK-LABEL: test_vmls_s16 4478 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4479 int16x4_t test_vmls_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4480 return vmls_s16(a, b, c); 4481 } 4482 4483 // CHECK-LABEL: test_vmls_s32 4484 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4485 int32x2_t test_vmls_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4486 return vmls_s32(a, b, c); 4487 } 4488 4489 // CHECK-LABEL: test_vmls_f32 4490 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4491 // CHECK-SWIFT: vsub.f32 4492 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4493 float32x2_t test_vmls_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4494 return vmls_f32(a, b, c); 4495 } 4496 4497 // CHECK-LABEL: test_vmls_u8 4498 // CHECK: vmls.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4499 uint8x8_t test_vmls_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 4500 return vmls_u8(a, b, c); 4501 } 4502 4503 // CHECK-LABEL: test_vmls_u16 4504 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4505 uint16x4_t test_vmls_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4506 return vmls_u16(a, b, c); 4507 } 4508 4509 // CHECK-LABEL: test_vmls_u32 4510 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4511 uint32x2_t test_vmls_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4512 return vmls_u32(a, b, c); 4513 } 4514 4515 // CHECK-LABEL: test_vmlsq_s8 4516 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4517 int8x16_t test_vmlsq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { 4518 return vmlsq_s8(a, b, c); 4519 } 4520 4521 // CHECK-LABEL: test_vmlsq_s16 4522 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4523 int16x8_t test_vmlsq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { 4524 return vmlsq_s16(a, b, c); 4525 } 4526 4527 // CHECK-LABEL: test_vmlsq_s32 4528 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4529 int32x4_t test_vmlsq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { 4530 return vmlsq_s32(a, b, c); 4531 } 4532 4533 // CHECK-LABEL: test_vmlsq_f32 4534 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4535 // CHECK-SWIFT: vsub.f32 4536 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4537 float32x4_t test_vmlsq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { 4538 return vmlsq_f32(a, b, c); 4539 } 4540 4541 // CHECK-LABEL: test_vmlsq_u8 4542 // CHECK: vmls.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4543 uint8x16_t test_vmlsq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { 4544 return vmlsq_u8(a, b, c); 4545 } 4546 4547 // CHECK-LABEL: test_vmlsq_u16 4548 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4549 uint16x8_t test_vmlsq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { 4550 return vmlsq_u16(a, b, c); 4551 } 4552 4553 // CHECK-LABEL: test_vmlsq_u32 4554 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4555 uint32x4_t test_vmlsq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { 4556 return vmlsq_u32(a, b, c); 4557 } 4558 4559 4560 // CHECK-LABEL: test_vmlsl_s8 4561 // CHECK: vmlsl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4562 int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 4563 return vmlsl_s8(a, b, c); 4564 } 4565 4566 // CHECK-LABEL: test_vmlsl_s16 4567 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4568 int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4569 return vmlsl_s16(a, b, c); 4570 } 4571 4572 // CHECK-LABEL: test_vmlsl_s32 4573 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4574 int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4575 return vmlsl_s32(a, b, c); 4576 } 4577 4578 // CHECK-LABEL: test_vmlsl_u8 4579 // CHECK: vmlsl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4580 uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 4581 return vmlsl_u8(a, b, c); 4582 } 4583 4584 // CHECK-LABEL: test_vmlsl_u16 4585 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4586 uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4587 return vmlsl_u16(a, b, c); 4588 } 4589 4590 // CHECK-LABEL: test_vmlsl_u32 4591 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4592 uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4593 return vmlsl_u32(a, b, c); 4594 } 4595 4596 4597 // CHECK-LABEL: test_vmlsl_lane_s16 4598 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4599 int32x4_t test_vmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4600 return vmlsl_lane_s16(a, b, c, 3); 4601 } 4602 4603 // CHECK-LABEL: test_vmlsl_lane_s32 4604 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4605 int64x2_t test_vmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4606 return vmlsl_lane_s32(a, b, c, 1); 4607 } 4608 4609 // CHECK-LABEL: test_vmlsl_lane_u16 4610 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4611 uint32x4_t test_vmlsl_lane_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4612 return vmlsl_lane_u16(a, b, c, 3); 4613 } 4614 4615 // CHECK-LABEL: test_vmlsl_lane_u32 4616 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4617 uint64x2_t test_vmlsl_lane_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4618 return vmlsl_lane_u32(a, b, c, 1); 4619 } 4620 4621 4622 // CHECK-LABEL: test_vmlsl_n_s16 4623 // CHECK: vmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4624 int32x4_t test_vmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 4625 return vmlsl_n_s16(a, b, c); 4626 } 4627 4628 // CHECK-LABEL: test_vmlsl_n_s32 4629 // CHECK: vmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4630 int64x2_t test_vmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 4631 return vmlsl_n_s32(a, b, c); 4632 } 4633 4634 // CHECK-LABEL: test_vmlsl_n_u16 4635 // CHECK: vmlsl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4636 uint32x4_t test_vmlsl_n_u16(uint32x4_t a, uint16x4_t b, uint16_t c) { 4637 return vmlsl_n_u16(a, b, c); 4638 } 4639 4640 // CHECK-LABEL: test_vmlsl_n_u32 4641 // CHECK: vmlsl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4642 uint64x2_t test_vmlsl_n_u32(uint64x2_t a, uint32x2_t b, uint32_t c) { 4643 return vmlsl_n_u32(a, b, c); 4644 } 4645 4646 4647 // CHECK-LABEL: test_vmls_lane_s16 4648 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4649 int16x4_t test_vmls_lane_s16(int16x4_t a, int16x4_t b, int16x4_t c) { 4650 return vmls_lane_s16(a, b, c, 3); 4651 } 4652 4653 // CHECK-LABEL: test_vmls_lane_s32 4654 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4655 int32x2_t test_vmls_lane_s32(int32x2_t a, int32x2_t b, int32x2_t c) { 4656 return vmls_lane_s32(a, b, c, 1); 4657 } 4658 4659 // CHECK-LABEL: test_vmls_lane_u16 4660 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4661 uint16x4_t test_vmls_lane_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { 4662 return vmls_lane_u16(a, b, c, 3); 4663 } 4664 4665 // CHECK-LABEL: test_vmls_lane_u32 4666 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4667 uint32x2_t test_vmls_lane_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { 4668 return vmls_lane_u32(a, b, c, 1); 4669 } 4670 4671 // CHECK-LABEL: test_vmls_lane_f32 4672 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4673 // CHECK-SWIFT: vsub.f32 4674 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4675 float32x2_t test_vmls_lane_f32(float32x2_t a, float32x2_t b, float32x2_t c) { 4676 return vmls_lane_f32(a, b, c, 1); 4677 } 4678 4679 // CHECK-LABEL: test_vmlsq_lane_s16 4680 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4681 int16x8_t test_vmlsq_lane_s16(int16x8_t a, int16x8_t b, int16x4_t c) { 4682 return vmlsq_lane_s16(a, b, c, 3); 4683 } 4684 4685 // CHECK-LABEL: test_vmlsq_lane_s32 4686 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4687 int32x4_t test_vmlsq_lane_s32(int32x4_t a, int32x4_t b, int32x2_t c) { 4688 return vmlsq_lane_s32(a, b, c, 1); 4689 } 4690 4691 // CHECK-LABEL: test_vmlsq_lane_u16 4692 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4693 uint16x8_t test_vmlsq_lane_u16(uint16x8_t a, uint16x8_t b, uint16x4_t c) { 4694 return vmlsq_lane_u16(a, b, c, 3); 4695 } 4696 4697 // CHECK-LABEL: test_vmlsq_lane_u32 4698 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4699 uint32x4_t test_vmlsq_lane_u32(uint32x4_t a, uint32x4_t b, uint32x2_t c) { 4700 return vmlsq_lane_u32(a, b, c, 1); 4701 } 4702 4703 // CHECK-LABEL: test_vmlsq_lane_f32 4704 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4705 // CHECK-SWIFT: vsub.f32 4706 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 4707 float32x4_t test_vmlsq_lane_f32(float32x4_t a, float32x4_t b, float32x2_t c) { 4708 return vmlsq_lane_f32(a, b, c, 1); 4709 } 4710 4711 4712 // CHECK-LABEL: test_vmls_n_s16 4713 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4714 int16x4_t test_vmls_n_s16(int16x4_t a, int16x4_t b, int16_t c) { 4715 return vmls_n_s16(a, b, c); 4716 } 4717 4718 // CHECK-LABEL: test_vmls_n_s32 4719 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4720 int32x2_t test_vmls_n_s32(int32x2_t a, int32x2_t b, int32_t c) { 4721 return vmls_n_s32(a, b, c); 4722 } 4723 4724 // CHECK-LABEL: test_vmls_n_u16 4725 // CHECK: vmls.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4726 uint16x4_t test_vmls_n_u16(uint16x4_t a, uint16x4_t b, uint16_t c) { 4727 return vmls_n_u16(a, b, c); 4728 } 4729 4730 // CHECK-LABEL: test_vmls_n_u32 4731 // CHECK: vmls.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4732 uint32x2_t test_vmls_n_u32(uint32x2_t a, uint32x2_t b, uint32_t c) { 4733 return vmls_n_u32(a, b, c); 4734 } 4735 4736 // CHECK-LABEL: test_vmls_n_f32 4737 // CHECK-SWIFT: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4738 // CHECK-SWIFT: vsub.f32 4739 // CHECK-A57: vmls.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4740 float32x2_t test_vmls_n_f32(float32x2_t a, float32x2_t b, float32_t c) { 4741 return vmls_n_f32(a, b, c); 4742 } 4743 4744 // CHECK-LABEL: test_vmlsq_n_s16 4745 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4746 int16x8_t test_vmlsq_n_s16(int16x8_t a, int16x8_t b, int16_t c) { 4747 return vmlsq_n_s16(a, b, c); 4748 } 4749 4750 // CHECK-LABEL: test_vmlsq_n_s32 4751 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4752 int32x4_t test_vmlsq_n_s32(int32x4_t a, int32x4_t b, int32_t c) { 4753 return vmlsq_n_s32(a, b, c); 4754 } 4755 4756 // CHECK-LABEL: test_vmlsq_n_u16 4757 // CHECK: vmls.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4758 uint16x8_t test_vmlsq_n_u16(uint16x8_t a, uint16x8_t b, uint16_t c) { 4759 return vmlsq_n_u16(a, b, c); 4760 } 4761 4762 // CHECK-LABEL: test_vmlsq_n_u32 4763 // CHECK: vmls.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4764 uint32x4_t test_vmlsq_n_u32(uint32x4_t a, uint32x4_t b, uint32_t c) { 4765 return vmlsq_n_u32(a, b, c); 4766 } 4767 4768 // CHECK-LABEL: test_vmlsq_n_f32 4769 // CHECK-SWIFT: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0] 4770 // CHECK-SWIFT: vsub.f32 4771 // CHECK-A57: vmls.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 4772 float32x4_t test_vmlsq_n_f32(float32x4_t a, float32x4_t b, float32_t c) { 4773 return vmlsq_n_f32(a, b, c); 4774 } 4775 4776 4777 // CHECK-LABEL: test_vmovl_s8 4778 // CHECK: vmovl.s8 q{{[0-9]+}}, d{{[0-9]+}} 4779 int16x8_t test_vmovl_s8(int8x8_t a) { 4780 return vmovl_s8(a); 4781 } 4782 4783 // CHECK-LABEL: test_vmovl_s16 4784 // CHECK: vmovl.s16 q{{[0-9]+}}, d{{[0-9]+}} 4785 int32x4_t test_vmovl_s16(int16x4_t a) { 4786 return vmovl_s16(a); 4787 } 4788 4789 // CHECK-LABEL: test_vmovl_s32 4790 // CHECK: vmovl.s32 q{{[0-9]+}}, d{{[0-9]+}} 4791 int64x2_t test_vmovl_s32(int32x2_t a) { 4792 return vmovl_s32(a); 4793 } 4794 4795 // CHECK-LABEL: test_vmovl_u8 4796 // CHECK: vmovl.u8 q{{[0-9]+}}, d{{[0-9]+}} 4797 uint16x8_t test_vmovl_u8(uint8x8_t a) { 4798 return vmovl_u8(a); 4799 } 4800 4801 // CHECK-LABEL: test_vmovl_u16 4802 // CHECK: vmovl.u16 q{{[0-9]+}}, d{{[0-9]+}} 4803 uint32x4_t test_vmovl_u16(uint16x4_t a) { 4804 return vmovl_u16(a); 4805 } 4806 4807 // CHECK-LABEL: test_vmovl_u32 4808 // CHECK: vmovl.u32 q{{[0-9]+}}, d{{[0-9]+}} 4809 uint64x2_t test_vmovl_u32(uint32x2_t a) { 4810 return vmovl_u32(a); 4811 } 4812 4813 4814 // CHECK-LABEL: test_vmovn_s16 4815 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}} 4816 int8x8_t test_vmovn_s16(int16x8_t a) { 4817 return vmovn_s16(a); 4818 } 4819 4820 // CHECK-LABEL: test_vmovn_s32 4821 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}} 4822 int16x4_t test_vmovn_s32(int32x4_t a) { 4823 return vmovn_s32(a); 4824 } 4825 4826 // CHECK-LABEL: test_vmovn_s64 4827 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}} 4828 int32x2_t test_vmovn_s64(int64x2_t a) { 4829 return vmovn_s64(a); 4830 } 4831 4832 // CHECK-LABEL: test_vmovn_u16 4833 // CHECK: vmovn.i16 d{{[0-9]+}}, q{{[0-9]+}} 4834 uint8x8_t test_vmovn_u16(uint16x8_t a) { 4835 return vmovn_u16(a); 4836 } 4837 4838 // CHECK-LABEL: test_vmovn_u32 4839 // CHECK: vmovn.i32 d{{[0-9]+}}, q{{[0-9]+}} 4840 uint16x4_t test_vmovn_u32(uint32x4_t a) { 4841 return vmovn_u32(a); 4842 } 4843 4844 // CHECK-LABEL: test_vmovn_u64 4845 // CHECK: vmovn.i64 d{{[0-9]+}}, q{{[0-9]+}} 4846 uint32x2_t test_vmovn_u64(uint64x2_t a) { 4847 return vmovn_u64(a); 4848 } 4849 4850 4851 // CHECK-LABEL: test_vmov_n_u8 4852 // CHECK: vmov 4853 uint8x8_t test_vmov_n_u8(uint8_t a) { 4854 return vmov_n_u8(a); 4855 } 4856 4857 // CHECK-LABEL: test_vmov_n_u16 4858 // CHECK: vmov 4859 uint16x4_t test_vmov_n_u16(uint16_t a) { 4860 return vmov_n_u16(a); 4861 } 4862 4863 // CHECK-LABEL: test_vmov_n_u32 4864 // CHECK: vmov 4865 uint32x2_t test_vmov_n_u32(uint32_t a) { 4866 return vmov_n_u32(a); 4867 } 4868 4869 // CHECK-LABEL: test_vmov_n_s8 4870 // CHECK: vmov 4871 int8x8_t test_vmov_n_s8(int8_t a) { 4872 return vmov_n_s8(a); 4873 } 4874 4875 // CHECK-LABEL: test_vmov_n_s16 4876 // CHECK: vmov 4877 int16x4_t test_vmov_n_s16(int16_t a) { 4878 return vmov_n_s16(a); 4879 } 4880 4881 // CHECK-LABEL: test_vmov_n_s32 4882 // CHECK: vmov 4883 int32x2_t test_vmov_n_s32(int32_t a) { 4884 return vmov_n_s32(a); 4885 } 4886 4887 // CHECK-LABEL: test_vmov_n_p8 4888 // CHECK: vmov 4889 poly8x8_t test_vmov_n_p8(poly8_t a) { 4890 return vmov_n_p8(a); 4891 } 4892 4893 // CHECK-LABEL: test_vmov_n_p16 4894 // CHECK: vmov 4895 poly16x4_t test_vmov_n_p16(poly16_t a) { 4896 return vmov_n_p16(a); 4897 } 4898 4899 // CHECK-LABEL: test_vmov_n_f16 4900 // CHECK: vld1.16 {{{d[0-9]+\[\]}}} 4901 float16x4_t test_vmov_n_f16(float16_t *a) { 4902 return vmov_n_f16(*a); 4903 } 4904 4905 // CHECK-LABEL: test_vmov_n_f32 4906 // CHECK: vmov 4907 float32x2_t test_vmov_n_f32(float32_t a) { 4908 return vmov_n_f32(a); 4909 } 4910 4911 // CHECK-LABEL: test_vmovq_n_u8 4912 // CHECK: vmov 4913 uint8x16_t test_vmovq_n_u8(uint8_t a) { 4914 return vmovq_n_u8(a); 4915 } 4916 4917 // CHECK-LABEL: test_vmovq_n_u16 4918 // CHECK: vmov 4919 uint16x8_t test_vmovq_n_u16(uint16_t a) { 4920 return vmovq_n_u16(a); 4921 } 4922 4923 // CHECK-LABEL: test_vmovq_n_u32 4924 // CHECK: vmov 4925 uint32x4_t test_vmovq_n_u32(uint32_t a) { 4926 return vmovq_n_u32(a); 4927 } 4928 4929 // CHECK-LABEL: test_vmovq_n_s8 4930 // CHECK: vmov 4931 int8x16_t test_vmovq_n_s8(int8_t a) { 4932 return vmovq_n_s8(a); 4933 } 4934 4935 // CHECK-LABEL: test_vmovq_n_s16 4936 // CHECK: vmov 4937 int16x8_t test_vmovq_n_s16(int16_t a) { 4938 return vmovq_n_s16(a); 4939 } 4940 4941 // CHECK-LABEL: test_vmovq_n_s32 4942 // CHECK: vmov 4943 int32x4_t test_vmovq_n_s32(int32_t a) { 4944 return vmovq_n_s32(a); 4945 } 4946 4947 // CHECK-LABEL: test_vmovq_n_p8 4948 // CHECK: vmov 4949 poly8x16_t test_vmovq_n_p8(poly8_t a) { 4950 return vmovq_n_p8(a); 4951 } 4952 4953 // CHECK-LABEL: test_vmovq_n_p16 4954 // CHECK: vmov 4955 poly16x8_t test_vmovq_n_p16(poly16_t a) { 4956 return vmovq_n_p16(a); 4957 } 4958 4959 // CHECK-LABEL: test_vmovq_n_f16 4960 // CHECK: vld1.16 {{{d[0-9]+\[\], d[0-9]+\[\]}}} 4961 float16x8_t test_vmovq_n_f16(float16_t *a) { 4962 return vmovq_n_f16(*a); 4963 } 4964 4965 // CHECK-LABEL: test_vmovq_n_f32 4966 // CHECK: vmov 4967 float32x4_t test_vmovq_n_f32(float32_t a) { 4968 return vmovq_n_f32(a); 4969 } 4970 4971 // CHECK-LABEL: test_vmov_n_s64 4972 // CHECK: vmov 4973 int64x1_t test_vmov_n_s64(int64_t a) { 4974 return vmov_n_s64(a); 4975 } 4976 4977 // CHECK-LABEL: test_vmov_n_u64 4978 // CHECK: vmov 4979 uint64x1_t test_vmov_n_u64(uint64_t a) { 4980 return vmov_n_u64(a); 4981 } 4982 4983 // CHECK-LABEL: test_vmovq_n_s64 4984 // CHECK: vmov 4985 int64x2_t test_vmovq_n_s64(int64_t a) { 4986 return vmovq_n_s64(a); 4987 } 4988 4989 // CHECK-LABEL: test_vmovq_n_u64 4990 // CHECK: vmov 4991 uint64x2_t test_vmovq_n_u64(uint64_t a) { 4992 return vmovq_n_u64(a); 4993 } 4994 4995 4996 // CHECK-LABEL: test_vmul_s8 4997 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 4998 int8x8_t test_vmul_s8(int8x8_t a, int8x8_t b) { 4999 return vmul_s8(a, b); 5000 } 5001 5002 // CHECK-LABEL: test_vmul_s16 5003 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5004 int16x4_t test_vmul_s16(int16x4_t a, int16x4_t b) { 5005 return vmul_s16(a, b); 5006 } 5007 5008 // CHECK-LABEL: test_vmul_s32 5009 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5010 int32x2_t test_vmul_s32(int32x2_t a, int32x2_t b) { 5011 return vmul_s32(a, b); 5012 } 5013 5014 // CHECK-LABEL: test_vmul_f32 5015 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5016 float32x2_t test_vmul_f32(float32x2_t a, float32x2_t b) { 5017 return vmul_f32(a, b); 5018 } 5019 5020 // CHECK-LABEL: test_vmul_u8 5021 // CHECK: vmul.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5022 uint8x8_t test_vmul_u8(uint8x8_t a, uint8x8_t b) { 5023 return vmul_u8(a, b); 5024 } 5025 5026 // CHECK-LABEL: test_vmul_u16 5027 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5028 uint16x4_t test_vmul_u16(uint16x4_t a, uint16x4_t b) { 5029 return vmul_u16(a, b); 5030 } 5031 5032 // CHECK-LABEL: test_vmul_u32 5033 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5034 uint32x2_t test_vmul_u32(uint32x2_t a, uint32x2_t b) { 5035 return vmul_u32(a, b); 5036 } 5037 5038 // CHECK-LABEL: test_vmulq_s8 5039 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5040 int8x16_t test_vmulq_s8(int8x16_t a, int8x16_t b) { 5041 return vmulq_s8(a, b); 5042 } 5043 5044 // CHECK-LABEL: test_vmulq_s16 5045 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5046 int16x8_t test_vmulq_s16(int16x8_t a, int16x8_t b) { 5047 return vmulq_s16(a, b); 5048 } 5049 5050 // CHECK-LABEL: test_vmulq_s32 5051 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5052 int32x4_t test_vmulq_s32(int32x4_t a, int32x4_t b) { 5053 return vmulq_s32(a, b); 5054 } 5055 5056 // CHECK-LABEL: test_vmulq_f32 5057 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5058 float32x4_t test_vmulq_f32(float32x4_t a, float32x4_t b) { 5059 return vmulq_f32(a, b); 5060 } 5061 5062 // CHECK-LABEL: test_vmulq_u8 5063 // CHECK: vmul.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5064 uint8x16_t test_vmulq_u8(uint8x16_t a, uint8x16_t b) { 5065 return vmulq_u8(a, b); 5066 } 5067 5068 // CHECK-LABEL: test_vmulq_u16 5069 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5070 uint16x8_t test_vmulq_u16(uint16x8_t a, uint16x8_t b) { 5071 return vmulq_u16(a, b); 5072 } 5073 5074 // CHECK-LABEL: test_vmulq_u32 5075 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5076 uint32x4_t test_vmulq_u32(uint32x4_t a, uint32x4_t b) { 5077 return vmulq_u32(a, b); 5078 } 5079 5080 5081 // CHECK-LABEL: test_vmull_s8 5082 // CHECK: vmull.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5083 int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) { 5084 return vmull_s8(a, b); 5085 } 5086 5087 // CHECK-LABEL: test_vmull_s16 5088 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5089 int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) { 5090 return vmull_s16(a, b); 5091 } 5092 5093 // CHECK-LABEL: test_vmull_s32 5094 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5095 int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) { 5096 return vmull_s32(a, b); 5097 } 5098 5099 // CHECK-LABEL: test_vmull_u8 5100 // CHECK: vmull.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5101 uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) { 5102 return vmull_u8(a, b); 5103 } 5104 5105 // CHECK-LABEL: test_vmull_u16 5106 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5107 uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) { 5108 return vmull_u16(a, b); 5109 } 5110 5111 // CHECK-LABEL: test_vmull_u32 5112 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5113 uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) { 5114 return vmull_u32(a, b); 5115 } 5116 5117 // CHECK-LABEL: test_vmull_p8 5118 // CHECK: vmull.p8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5119 poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) { 5120 return vmull_p8(a, b); 5121 } 5122 5123 5124 // CHECK-LABEL: test_vmull_lane_s16 5125 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5126 int32x4_t test_vmull_lane_s16(int16x4_t a, int16x4_t b) { 5127 return vmull_lane_s16(a, b, 3); 5128 } 5129 5130 // CHECK-LABEL: test_vmull_lane_s32 5131 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5132 int64x2_t test_vmull_lane_s32(int32x2_t a, int32x2_t b) { 5133 return vmull_lane_s32(a, b, 1); 5134 } 5135 5136 // CHECK-LABEL: test_vmull_lane_u16 5137 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5138 uint32x4_t test_vmull_lane_u16(uint16x4_t a, uint16x4_t b) { 5139 return vmull_lane_u16(a, b, 3); 5140 } 5141 5142 // CHECK-LABEL: test_vmull_lane_u32 5143 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5144 uint64x2_t test_vmull_lane_u32(uint32x2_t a, uint32x2_t b) { 5145 return vmull_lane_u32(a, b, 1); 5146 } 5147 5148 5149 // CHECK-LABEL: test_vmull_n_s16 5150 // CHECK: vmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5151 int32x4_t test_vmull_n_s16(int16x4_t a, int16_t b) { 5152 return vmull_n_s16(a, b); 5153 } 5154 5155 // CHECK-LABEL: test_vmull_n_s32 5156 // CHECK: vmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5157 int64x2_t test_vmull_n_s32(int32x2_t a, int32_t b) { 5158 return vmull_n_s32(a, b); 5159 } 5160 5161 // CHECK-LABEL: test_vmull_n_u16 5162 // CHECK: vmull.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5163 uint32x4_t test_vmull_n_u16(uint16x4_t a, uint16_t b) { 5164 return vmull_n_u16(a, b); 5165 } 5166 5167 // CHECK-LABEL: test_vmull_n_u32 5168 // CHECK: vmull.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5169 uint64x2_t test_vmull_n_u32(uint32x2_t a, uint32_t b) { 5170 return vmull_n_u32(a, b); 5171 } 5172 5173 5174 // CHECK-LABEL: test_vmul_p8 5175 // CHECK: vmul.p8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5176 poly8x8_t test_vmul_p8(poly8x8_t a, poly8x8_t b) { 5177 return vmul_p8(a, b); 5178 } 5179 5180 // CHECK-LABEL: test_vmulq_p8 5181 // CHECK: vmul.p8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5182 poly8x16_t test_vmulq_p8(poly8x16_t a, poly8x16_t b) { 5183 return vmulq_p8(a, b); 5184 } 5185 5186 5187 // CHECK-LABEL: test_vmul_lane_s16 5188 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5189 int16x4_t test_vmul_lane_s16(int16x4_t a, int16x4_t b) { 5190 return vmul_lane_s16(a, b, 3); 5191 } 5192 5193 // CHECK-LABEL: test_vmul_lane_s32 5194 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5195 int32x2_t test_vmul_lane_s32(int32x2_t a, int32x2_t b) { 5196 return vmul_lane_s32(a, b, 1); 5197 } 5198 5199 // CHECK-LABEL: test_vmul_lane_f32 5200 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5201 float32x2_t test_vmul_lane_f32(float32x2_t a, float32x2_t b) { 5202 return vmul_lane_f32(a, b, 1); 5203 } 5204 5205 // CHECK-LABEL: test_vmul_lane_u16 5206 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5207 uint16x4_t test_vmul_lane_u16(uint16x4_t a, uint16x4_t b) { 5208 return vmul_lane_u16(a, b, 3); 5209 } 5210 5211 // CHECK-LABEL: test_vmul_lane_u32 5212 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5213 uint32x2_t test_vmul_lane_u32(uint32x2_t a, uint32x2_t b) { 5214 return vmul_lane_u32(a, b, 1); 5215 } 5216 5217 // CHECK-LABEL: test_vmulq_lane_s16 5218 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5219 int16x8_t test_vmulq_lane_s16(int16x8_t a, int16x4_t b) { 5220 return vmulq_lane_s16(a, b, 3); 5221 } 5222 5223 // CHECK-LABEL: test_vmulq_lane_s32 5224 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5225 int32x4_t test_vmulq_lane_s32(int32x4_t a, int32x2_t b) { 5226 return vmulq_lane_s32(a, b, 1); 5227 } 5228 5229 // CHECK-LABEL: test_vmulq_lane_f32 5230 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5231 float32x4_t test_vmulq_lane_f32(float32x4_t a, float32x2_t b) { 5232 return vmulq_lane_f32(a, b, 1); 5233 } 5234 5235 // CHECK-LABEL: test_vmulq_lane_u16 5236 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5237 uint16x8_t test_vmulq_lane_u16(uint16x8_t a, uint16x4_t b) { 5238 return vmulq_lane_u16(a, b, 3); 5239 } 5240 5241 // CHECK-LABEL: test_vmulq_lane_u32 5242 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 5243 uint32x4_t test_vmulq_lane_u32(uint32x4_t a, uint32x2_t b) { 5244 return vmulq_lane_u32(a, b, 1); 5245 } 5246 5247 5248 // CHECK-LABEL: test_vmul_n_s16 5249 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5250 int16x4_t test_vmul_n_s16(int16x4_t a, int16_t b) { 5251 return vmul_n_s16(a, b); 5252 } 5253 5254 // CHECK-LABEL: test_vmul_n_s32 5255 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5256 int32x2_t test_vmul_n_s32(int32x2_t a, int32_t b) { 5257 return vmul_n_s32(a, b); 5258 } 5259 5260 // CHECK-LABEL: test_vmul_n_f32 5261 // CHECK: vmul.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5262 float32x2_t test_vmul_n_f32(float32x2_t a, float32_t b) { 5263 return vmul_n_f32(a, b); 5264 } 5265 5266 // CHECK-LABEL: test_vmul_n_u16 5267 // CHECK: vmul.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5268 uint16x4_t test_vmul_n_u16(uint16x4_t a, uint16_t b) { 5269 return vmul_n_u16(a, b); 5270 } 5271 5272 // CHECK-LABEL: test_vmul_n_u32 5273 // CHECK: vmul.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5274 uint32x2_t test_vmul_n_u32(uint32x2_t a, uint32_t b) { 5275 return vmul_n_u32(a, b); 5276 } 5277 5278 // CHECK-LABEL: test_vmulq_n_s16 5279 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5280 int16x8_t test_vmulq_n_s16(int16x8_t a, int16_t b) { 5281 return vmulq_n_s16(a, b); 5282 } 5283 5284 // CHECK-LABEL: test_vmulq_n_s32 5285 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5286 int32x4_t test_vmulq_n_s32(int32x4_t a, int32_t b) { 5287 return vmulq_n_s32(a, b); 5288 } 5289 5290 // CHECK-LABEL: test_vmulq_n_f32 5291 // CHECK: vmul.f32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[0] 5292 float32x4_t test_vmulq_n_f32(float32x4_t a, float32_t b) { 5293 return vmulq_n_f32(a, b); 5294 } 5295 5296 // CHECK-LABEL: test_vmulq_n_u16 5297 // CHECK: vmul.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5298 uint16x8_t test_vmulq_n_u16(uint16x8_t a, uint16_t b) { 5299 return vmulq_n_u16(a, b); 5300 } 5301 5302 // CHECK-LABEL: test_vmulq_n_u32 5303 // CHECK: vmul.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5304 uint32x4_t test_vmulq_n_u32(uint32x4_t a, uint32_t b) { 5305 return vmulq_n_u32(a, b); 5306 } 5307 5308 5309 // CHECK-LABEL: test_vmvn_s8 5310 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5311 int8x8_t test_vmvn_s8(int8x8_t a) { 5312 return vmvn_s8(a); 5313 } 5314 5315 // CHECK-LABEL: test_vmvn_s16 5316 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5317 int16x4_t test_vmvn_s16(int16x4_t a) { 5318 return vmvn_s16(a); 5319 } 5320 5321 // CHECK-LABEL: test_vmvn_s32 5322 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5323 int32x2_t test_vmvn_s32(int32x2_t a) { 5324 return vmvn_s32(a); 5325 } 5326 5327 // CHECK-LABEL: test_vmvn_u8 5328 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5329 uint8x8_t test_vmvn_u8(uint8x8_t a) { 5330 return vmvn_u8(a); 5331 } 5332 5333 // CHECK-LABEL: test_vmvn_u16 5334 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5335 uint16x4_t test_vmvn_u16(uint16x4_t a) { 5336 return vmvn_u16(a); 5337 } 5338 5339 // CHECK-LABEL: test_vmvn_u32 5340 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5341 uint32x2_t test_vmvn_u32(uint32x2_t a) { 5342 return vmvn_u32(a); 5343 } 5344 5345 // CHECK-LABEL: test_vmvn_p8 5346 // CHECK: vmvn d{{[0-9]+}}, d{{[0-9]+}} 5347 poly8x8_t test_vmvn_p8(poly8x8_t a) { 5348 return vmvn_p8(a); 5349 } 5350 5351 // CHECK-LABEL: test_vmvnq_s8 5352 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5353 int8x16_t test_vmvnq_s8(int8x16_t a) { 5354 return vmvnq_s8(a); 5355 } 5356 5357 // CHECK-LABEL: test_vmvnq_s16 5358 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5359 int16x8_t test_vmvnq_s16(int16x8_t a) { 5360 return vmvnq_s16(a); 5361 } 5362 5363 // CHECK-LABEL: test_vmvnq_s32 5364 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5365 int32x4_t test_vmvnq_s32(int32x4_t a) { 5366 return vmvnq_s32(a); 5367 } 5368 5369 // CHECK-LABEL: test_vmvnq_u8 5370 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5371 uint8x16_t test_vmvnq_u8(uint8x16_t a) { 5372 return vmvnq_u8(a); 5373 } 5374 5375 // CHECK-LABEL: test_vmvnq_u16 5376 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5377 uint16x8_t test_vmvnq_u16(uint16x8_t a) { 5378 return vmvnq_u16(a); 5379 } 5380 5381 // CHECK-LABEL: test_vmvnq_u32 5382 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5383 uint32x4_t test_vmvnq_u32(uint32x4_t a) { 5384 return vmvnq_u32(a); 5385 } 5386 5387 // CHECK-LABEL: test_vmvnq_p8 5388 // CHECK: vmvn q{{[0-9]+}}, q{{[0-9]+}} 5389 poly8x16_t test_vmvnq_p8(poly8x16_t a) { 5390 return vmvnq_p8(a); 5391 } 5392 5393 5394 // CHECK-LABEL: test_vneg_s8 5395 // CHECK: vneg.s8 d{{[0-9]+}}, d{{[0-9]+}} 5396 int8x8_t test_vneg_s8(int8x8_t a) { 5397 return vneg_s8(a); 5398 } 5399 5400 // CHECK-LABEL: test_vneg_s16 5401 // CHECK: vneg.s16 d{{[0-9]+}}, d{{[0-9]+}} 5402 int16x4_t test_vneg_s16(int16x4_t a) { 5403 return vneg_s16(a); 5404 } 5405 5406 // CHECK-LABEL: test_vneg_s32 5407 // CHECK: vneg.s32 d{{[0-9]+}}, d{{[0-9]+}} 5408 int32x2_t test_vneg_s32(int32x2_t a) { 5409 return vneg_s32(a); 5410 } 5411 5412 // CHECK-LABEL: test_vneg_f32 5413 // CHECK: vneg.f32 d{{[0-9]+}}, d{{[0-9]+}} 5414 float32x2_t test_vneg_f32(float32x2_t a) { 5415 return vneg_f32(a); 5416 } 5417 5418 // CHECK-LABEL: test_vnegq_s8 5419 // CHECK: vneg.s8 q{{[0-9]+}}, q{{[0-9]+}} 5420 int8x16_t test_vnegq_s8(int8x16_t a) { 5421 return vnegq_s8(a); 5422 } 5423 5424 // CHECK-LABEL: test_vnegq_s16 5425 // CHECK: vneg.s16 q{{[0-9]+}}, q{{[0-9]+}} 5426 int16x8_t test_vnegq_s16(int16x8_t a) { 5427 return vnegq_s16(a); 5428 } 5429 5430 // CHECK-LABEL: test_vnegq_s32 5431 // CHECK: vneg.s32 q{{[0-9]+}}, q{{[0-9]+}} 5432 int32x4_t test_vnegq_s32(int32x4_t a) { 5433 return vnegq_s32(a); 5434 } 5435 5436 // CHECK-LABEL: test_vnegq_f32 5437 // CHECK: vneg.f32 q{{[0-9]+}}, q{{[0-9]+}} 5438 float32x4_t test_vnegq_f32(float32x4_t a) { 5439 return vnegq_f32(a); 5440 } 5441 5442 5443 // CHECK-LABEL: test_vorn_s8 5444 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5445 int8x8_t test_vorn_s8(int8x8_t a, int8x8_t b) { 5446 return vorn_s8(a, b); 5447 } 5448 5449 // CHECK-LABEL: test_vorn_s16 5450 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5451 int16x4_t test_vorn_s16(int16x4_t a, int16x4_t b) { 5452 return vorn_s16(a, b); 5453 } 5454 5455 // CHECK-LABEL: test_vorn_s32 5456 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5457 int32x2_t test_vorn_s32(int32x2_t a, int32x2_t b) { 5458 return vorn_s32(a, b); 5459 } 5460 5461 // CHECK-LABEL: test_vorn_s64 5462 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5463 int64x1_t test_vorn_s64(int64x1_t a, int64x1_t b) { 5464 return vorn_s64(a, b); 5465 } 5466 5467 // CHECK-LABEL: test_vorn_u8 5468 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5469 uint8x8_t test_vorn_u8(uint8x8_t a, uint8x8_t b) { 5470 return vorn_u8(a, b); 5471 } 5472 5473 // CHECK-LABEL: test_vorn_u16 5474 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5475 uint16x4_t test_vorn_u16(uint16x4_t a, uint16x4_t b) { 5476 return vorn_u16(a, b); 5477 } 5478 5479 // CHECK-LABEL: test_vorn_u32 5480 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5481 uint32x2_t test_vorn_u32(uint32x2_t a, uint32x2_t b) { 5482 return vorn_u32(a, b); 5483 } 5484 5485 // CHECK-LABEL: test_vorn_u64 5486 // CHECK: vorn d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5487 uint64x1_t test_vorn_u64(uint64x1_t a, uint64x1_t b) { 5488 return vorn_u64(a, b); 5489 } 5490 5491 // CHECK-LABEL: test_vornq_s8 5492 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5493 int8x16_t test_vornq_s8(int8x16_t a, int8x16_t b) { 5494 return vornq_s8(a, b); 5495 } 5496 5497 // CHECK-LABEL: test_vornq_s16 5498 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5499 int16x8_t test_vornq_s16(int16x8_t a, int16x8_t b) { 5500 return vornq_s16(a, b); 5501 } 5502 5503 // CHECK-LABEL: test_vornq_s32 5504 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5505 int32x4_t test_vornq_s32(int32x4_t a, int32x4_t b) { 5506 return vornq_s32(a, b); 5507 } 5508 5509 // CHECK-LABEL: test_vornq_s64 5510 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5511 int64x2_t test_vornq_s64(int64x2_t a, int64x2_t b) { 5512 return vornq_s64(a, b); 5513 } 5514 5515 // CHECK-LABEL: test_vornq_u8 5516 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5517 uint8x16_t test_vornq_u8(uint8x16_t a, uint8x16_t b) { 5518 return vornq_u8(a, b); 5519 } 5520 5521 // CHECK-LABEL: test_vornq_u16 5522 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5523 uint16x8_t test_vornq_u16(uint16x8_t a, uint16x8_t b) { 5524 return vornq_u16(a, b); 5525 } 5526 5527 // CHECK-LABEL: test_vornq_u32 5528 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5529 uint32x4_t test_vornq_u32(uint32x4_t a, uint32x4_t b) { 5530 return vornq_u32(a, b); 5531 } 5532 5533 // CHECK-LABEL: test_vornq_u64 5534 // CHECK: vorn q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5535 uint64x2_t test_vornq_u64(uint64x2_t a, uint64x2_t b) { 5536 return vornq_u64(a, b); 5537 } 5538 5539 5540 // CHECK-LABEL: test_vorr_s8 5541 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5542 int8x8_t test_vorr_s8(int8x8_t a, int8x8_t b) { 5543 return vorr_s8(a, b); 5544 } 5545 5546 // CHECK-LABEL: test_vorr_s16 5547 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5548 int16x4_t test_vorr_s16(int16x4_t a, int16x4_t b) { 5549 return vorr_s16(a, b); 5550 } 5551 5552 // CHECK-LABEL: test_vorr_s32 5553 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5554 int32x2_t test_vorr_s32(int32x2_t a, int32x2_t b) { 5555 return vorr_s32(a, b); 5556 } 5557 5558 // CHECK-LABEL: test_vorr_s64 5559 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5560 int64x1_t test_vorr_s64(int64x1_t a, int64x1_t b) { 5561 return vorr_s64(a, b); 5562 } 5563 5564 // CHECK-LABEL: test_vorr_u8 5565 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5566 uint8x8_t test_vorr_u8(uint8x8_t a, uint8x8_t b) { 5567 return vorr_u8(a, b); 5568 } 5569 5570 // CHECK-LABEL: test_vorr_u16 5571 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5572 uint16x4_t test_vorr_u16(uint16x4_t a, uint16x4_t b) { 5573 return vorr_u16(a, b); 5574 } 5575 5576 // CHECK-LABEL: test_vorr_u32 5577 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5578 uint32x2_t test_vorr_u32(uint32x2_t a, uint32x2_t b) { 5579 return vorr_u32(a, b); 5580 } 5581 5582 // CHECK-LABEL: test_vorr_u64 5583 // CHECK: vorr d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5584 uint64x1_t test_vorr_u64(uint64x1_t a, uint64x1_t b) { 5585 return vorr_u64(a, b); 5586 } 5587 5588 // CHECK-LABEL: test_vorrq_s8 5589 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5590 int8x16_t test_vorrq_s8(int8x16_t a, int8x16_t b) { 5591 return vorrq_s8(a, b); 5592 } 5593 5594 // CHECK-LABEL: test_vorrq_s16 5595 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5596 int16x8_t test_vorrq_s16(int16x8_t a, int16x8_t b) { 5597 return vorrq_s16(a, b); 5598 } 5599 5600 // CHECK-LABEL: test_vorrq_s32 5601 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5602 int32x4_t test_vorrq_s32(int32x4_t a, int32x4_t b) { 5603 return vorrq_s32(a, b); 5604 } 5605 5606 // CHECK-LABEL: test_vorrq_s64 5607 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5608 int64x2_t test_vorrq_s64(int64x2_t a, int64x2_t b) { 5609 return vorrq_s64(a, b); 5610 } 5611 5612 // CHECK-LABEL: test_vorrq_u8 5613 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5614 uint8x16_t test_vorrq_u8(uint8x16_t a, uint8x16_t b) { 5615 return vorrq_u8(a, b); 5616 } 5617 5618 // CHECK-LABEL: test_vorrq_u16 5619 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5620 uint16x8_t test_vorrq_u16(uint16x8_t a, uint16x8_t b) { 5621 return vorrq_u16(a, b); 5622 } 5623 5624 // CHECK-LABEL: test_vorrq_u32 5625 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5626 uint32x4_t test_vorrq_u32(uint32x4_t a, uint32x4_t b) { 5627 return vorrq_u32(a, b); 5628 } 5629 5630 // CHECK-LABEL: test_vorrq_u64 5631 // CHECK: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5632 uint64x2_t test_vorrq_u64(uint64x2_t a, uint64x2_t b) { 5633 return vorrq_u64(a, b); 5634 } 5635 5636 5637 // CHECK-LABEL: test_vpadal_s8 5638 // CHECK: vpadal.s8 d{{[0-9]+}}, d{{[0-9]+}} 5639 int16x4_t test_vpadal_s8(int16x4_t a, int8x8_t b) { 5640 return vpadal_s8(a, b); 5641 } 5642 5643 // CHECK-LABEL: test_vpadal_s16 5644 // CHECK: vpadal.s16 d{{[0-9]+}}, d{{[0-9]+}} 5645 int32x2_t test_vpadal_s16(int32x2_t a, int16x4_t b) { 5646 return vpadal_s16(a, b); 5647 } 5648 5649 // CHECK-LABEL: test_vpadal_s32 5650 // CHECK: vpadal.s32 d{{[0-9]+}}, d{{[0-9]+}} 5651 int64x1_t test_vpadal_s32(int64x1_t a, int32x2_t b) { 5652 return vpadal_s32(a, b); 5653 } 5654 5655 // CHECK-LABEL: test_vpadal_u8 5656 // CHECK: vpadal.u8 d{{[0-9]+}}, d{{[0-9]+}} 5657 uint16x4_t test_vpadal_u8(uint16x4_t a, uint8x8_t b) { 5658 return vpadal_u8(a, b); 5659 } 5660 5661 // CHECK-LABEL: test_vpadal_u16 5662 // CHECK: vpadal.u16 d{{[0-9]+}}, d{{[0-9]+}} 5663 uint32x2_t test_vpadal_u16(uint32x2_t a, uint16x4_t b) { 5664 return vpadal_u16(a, b); 5665 } 5666 5667 // CHECK-LABEL: test_vpadal_u32 5668 // CHECK: vpadal.u32 d{{[0-9]+}}, d{{[0-9]+}} 5669 uint64x1_t test_vpadal_u32(uint64x1_t a, uint32x2_t b) { 5670 return vpadal_u32(a, b); 5671 } 5672 5673 // CHECK-LABEL: test_vpadalq_s8 5674 // CHECK: vpadal.s8 q{{[0-9]+}}, q{{[0-9]+}} 5675 int16x8_t test_vpadalq_s8(int16x8_t a, int8x16_t b) { 5676 return vpadalq_s8(a, b); 5677 } 5678 5679 // CHECK-LABEL: test_vpadalq_s16 5680 // CHECK: vpadal.s16 q{{[0-9]+}}, q{{[0-9]+}} 5681 int32x4_t test_vpadalq_s16(int32x4_t a, int16x8_t b) { 5682 return vpadalq_s16(a, b); 5683 } 5684 5685 // CHECK-LABEL: test_vpadalq_s32 5686 // CHECK: vpadal.s32 q{{[0-9]+}}, q{{[0-9]+}} 5687 int64x2_t test_vpadalq_s32(int64x2_t a, int32x4_t b) { 5688 return vpadalq_s32(a, b); 5689 } 5690 5691 // CHECK-LABEL: test_vpadalq_u8 5692 // CHECK: vpadal.u8 q{{[0-9]+}}, q{{[0-9]+}} 5693 uint16x8_t test_vpadalq_u8(uint16x8_t a, uint8x16_t b) { 5694 return vpadalq_u8(a, b); 5695 } 5696 5697 // CHECK-LABEL: test_vpadalq_u16 5698 // CHECK: vpadal.u16 q{{[0-9]+}}, q{{[0-9]+}} 5699 uint32x4_t test_vpadalq_u16(uint32x4_t a, uint16x8_t b) { 5700 return vpadalq_u16(a, b); 5701 } 5702 5703 // CHECK-LABEL: test_vpadalq_u32 5704 // CHECK: vpadal.u32 q{{[0-9]+}}, q{{[0-9]+}} 5705 uint64x2_t test_vpadalq_u32(uint64x2_t a, uint32x4_t b) { 5706 return vpadalq_u32(a, b); 5707 } 5708 5709 5710 // CHECK-LABEL: test_vpadd_s8 5711 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5712 int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) { 5713 return vpadd_s8(a, b); 5714 } 5715 5716 // CHECK-LABEL: test_vpadd_s16 5717 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5718 int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) { 5719 return vpadd_s16(a, b); 5720 } 5721 5722 // CHECK-LABEL: test_vpadd_s32 5723 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5724 int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) { 5725 return vpadd_s32(a, b); 5726 } 5727 5728 // CHECK-LABEL: test_vpadd_u8 5729 // CHECK: vpadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5730 uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) { 5731 return vpadd_u8(a, b); 5732 } 5733 5734 // CHECK-LABEL: test_vpadd_u16 5735 // CHECK: vpadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5736 uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) { 5737 return vpadd_u16(a, b); 5738 } 5739 5740 // CHECK-LABEL: test_vpadd_u32 5741 // CHECK: vpadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5742 uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) { 5743 return vpadd_u32(a, b); 5744 } 5745 5746 // CHECK-LABEL: test_vpadd_f32 5747 // CHECK: vpadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5748 float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) { 5749 return vpadd_f32(a, b); 5750 } 5751 5752 5753 // CHECK-LABEL: test_vpaddl_s8 5754 // CHECK: vpaddl.s8 d{{[0-9]+}}, d{{[0-9]+}} 5755 int16x4_t test_vpaddl_s8(int8x8_t a) { 5756 return vpaddl_s8(a); 5757 } 5758 5759 // CHECK-LABEL: test_vpaddl_s16 5760 // CHECK: vpaddl.s16 d{{[0-9]+}}, d{{[0-9]+}} 5761 int32x2_t test_vpaddl_s16(int16x4_t a) { 5762 return vpaddl_s16(a); 5763 } 5764 5765 // CHECK-LABEL: test_vpaddl_s32 5766 // CHECK: vpaddl.s32 d{{[0-9]+}}, d{{[0-9]+}} 5767 int64x1_t test_vpaddl_s32(int32x2_t a) { 5768 return vpaddl_s32(a); 5769 } 5770 5771 // CHECK-LABEL: test_vpaddl_u8 5772 // CHECK: vpaddl.u8 d{{[0-9]+}}, d{{[0-9]+}} 5773 uint16x4_t test_vpaddl_u8(uint8x8_t a) { 5774 return vpaddl_u8(a); 5775 } 5776 5777 // CHECK-LABEL: test_vpaddl_u16 5778 // CHECK: vpaddl.u16 d{{[0-9]+}}, d{{[0-9]+}} 5779 uint32x2_t test_vpaddl_u16(uint16x4_t a) { 5780 return vpaddl_u16(a); 5781 } 5782 5783 // CHECK-LABEL: test_vpaddl_u32 5784 // CHECK: vpaddl.u32 d{{[0-9]+}}, d{{[0-9]+}} 5785 uint64x1_t test_vpaddl_u32(uint32x2_t a) { 5786 return vpaddl_u32(a); 5787 } 5788 5789 // CHECK-LABEL: test_vpaddlq_s8 5790 // CHECK: vpaddl.s8 q{{[0-9]+}}, q{{[0-9]+}} 5791 int16x8_t test_vpaddlq_s8(int8x16_t a) { 5792 return vpaddlq_s8(a); 5793 } 5794 5795 // CHECK-LABEL: test_vpaddlq_s16 5796 // CHECK: vpaddl.s16 q{{[0-9]+}}, q{{[0-9]+}} 5797 int32x4_t test_vpaddlq_s16(int16x8_t a) { 5798 return vpaddlq_s16(a); 5799 } 5800 5801 // CHECK-LABEL: test_vpaddlq_s32 5802 // CHECK: vpaddl.s32 q{{[0-9]+}}, q{{[0-9]+}} 5803 int64x2_t test_vpaddlq_s32(int32x4_t a) { 5804 return vpaddlq_s32(a); 5805 } 5806 5807 // CHECK-LABEL: test_vpaddlq_u8 5808 // CHECK: vpaddl.u8 q{{[0-9]+}}, q{{[0-9]+}} 5809 uint16x8_t test_vpaddlq_u8(uint8x16_t a) { 5810 return vpaddlq_u8(a); 5811 } 5812 5813 // CHECK-LABEL: test_vpaddlq_u16 5814 // CHECK: vpaddl.u16 q{{[0-9]+}}, q{{[0-9]+}} 5815 uint32x4_t test_vpaddlq_u16(uint16x8_t a) { 5816 return vpaddlq_u16(a); 5817 } 5818 5819 // CHECK-LABEL: test_vpaddlq_u32 5820 // CHECK: vpaddl.u32 q{{[0-9]+}}, q{{[0-9]+}} 5821 uint64x2_t test_vpaddlq_u32(uint32x4_t a) { 5822 return vpaddlq_u32(a); 5823 } 5824 5825 5826 // CHECK-LABEL: test_vpmax_s8 5827 // CHECK: vpmax.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5828 int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) { 5829 return vpmax_s8(a, b); 5830 } 5831 5832 // CHECK-LABEL: test_vpmax_s16 5833 // CHECK: vpmax.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5834 int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) { 5835 return vpmax_s16(a, b); 5836 } 5837 5838 // CHECK-LABEL: test_vpmax_s32 5839 // CHECK: vpmax.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5840 int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) { 5841 return vpmax_s32(a, b); 5842 } 5843 5844 // CHECK-LABEL: test_vpmax_u8 5845 // CHECK: vpmax.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5846 uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) { 5847 return vpmax_u8(a, b); 5848 } 5849 5850 // CHECK-LABEL: test_vpmax_u16 5851 // CHECK: vpmax.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5852 uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) { 5853 return vpmax_u16(a, b); 5854 } 5855 5856 // CHECK-LABEL: test_vpmax_u32 5857 // CHECK: vpmax.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5858 uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) { 5859 return vpmax_u32(a, b); 5860 } 5861 5862 // CHECK-LABEL: test_vpmax_f32 5863 // CHECK: vpmax.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5864 float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) { 5865 return vpmax_f32(a, b); 5866 } 5867 5868 5869 // CHECK-LABEL: test_vpmin_s8 5870 // CHECK: vpmin.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5871 int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) { 5872 return vpmin_s8(a, b); 5873 } 5874 5875 // CHECK-LABEL: test_vpmin_s16 5876 // CHECK: vpmin.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5877 int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) { 5878 return vpmin_s16(a, b); 5879 } 5880 5881 // CHECK-LABEL: test_vpmin_s32 5882 // CHECK: vpmin.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5883 int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) { 5884 return vpmin_s32(a, b); 5885 } 5886 5887 // CHECK-LABEL: test_vpmin_u8 5888 // CHECK: vpmin.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5889 uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) { 5890 return vpmin_u8(a, b); 5891 } 5892 5893 // CHECK-LABEL: test_vpmin_u16 5894 // CHECK: vpmin.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5895 uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) { 5896 return vpmin_u16(a, b); 5897 } 5898 5899 // CHECK-LABEL: test_vpmin_u32 5900 // CHECK: vpmin.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5901 uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) { 5902 return vpmin_u32(a, b); 5903 } 5904 5905 // CHECK-LABEL: test_vpmin_f32 5906 // CHECK: vpmin.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5907 float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) { 5908 return vpmin_f32(a, b); 5909 } 5910 5911 5912 // CHECK-LABEL: test_vqabs_s8 5913 // CHECK: vqabs.s8 d{{[0-9]+}}, d{{[0-9]+}} 5914 int8x8_t test_vqabs_s8(int8x8_t a) { 5915 return vqabs_s8(a); 5916 } 5917 5918 // CHECK-LABEL: test_vqabs_s16 5919 // CHECK: vqabs.s16 d{{[0-9]+}}, d{{[0-9]+}} 5920 int16x4_t test_vqabs_s16(int16x4_t a) { 5921 return vqabs_s16(a); 5922 } 5923 5924 // CHECK-LABEL: test_vqabs_s32 5925 // CHECK: vqabs.s32 d{{[0-9]+}}, d{{[0-9]+}} 5926 int32x2_t test_vqabs_s32(int32x2_t a) { 5927 return vqabs_s32(a); 5928 } 5929 5930 // CHECK-LABEL: test_vqabsq_s8 5931 // CHECK: vqabs.s8 q{{[0-9]+}}, q{{[0-9]+}} 5932 int8x16_t test_vqabsq_s8(int8x16_t a) { 5933 return vqabsq_s8(a); 5934 } 5935 5936 // CHECK-LABEL: test_vqabsq_s16 5937 // CHECK: vqabs.s16 q{{[0-9]+}}, q{{[0-9]+}} 5938 int16x8_t test_vqabsq_s16(int16x8_t a) { 5939 return vqabsq_s16(a); 5940 } 5941 5942 // CHECK-LABEL: test_vqabsq_s32 5943 // CHECK: vqabs.s32 q{{[0-9]+}}, q{{[0-9]+}} 5944 int32x4_t test_vqabsq_s32(int32x4_t a) { 5945 return vqabsq_s32(a); 5946 } 5947 5948 5949 // CHECK-LABEL: test_vqadd_s8 5950 // CHECK: vqadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5951 int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) { 5952 return vqadd_s8(a, b); 5953 } 5954 5955 // CHECK-LABEL: test_vqadd_s16 5956 // CHECK: vqadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5957 int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) { 5958 return vqadd_s16(a, b); 5959 } 5960 5961 // CHECK-LABEL: test_vqadd_s32 5962 // CHECK: vqadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5963 int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) { 5964 return vqadd_s32(a, b); 5965 } 5966 5967 // CHECK-LABEL: test_vqadd_s64 5968 // CHECK: vqadd.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5969 int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) { 5970 return vqadd_s64(a, b); 5971 } 5972 5973 // CHECK-LABEL: test_vqadd_u8 5974 // CHECK: vqadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5975 uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) { 5976 return vqadd_u8(a, b); 5977 } 5978 5979 // CHECK-LABEL: test_vqadd_u16 5980 // CHECK: vqadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5981 uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) { 5982 return vqadd_u16(a, b); 5983 } 5984 5985 // CHECK-LABEL: test_vqadd_u32 5986 // CHECK: vqadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5987 uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) { 5988 return vqadd_u32(a, b); 5989 } 5990 5991 // CHECK-LABEL: test_vqadd_u64 5992 // CHECK: vqadd.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 5993 uint64x1_t test_vqadd_u64(uint64x1_t a, uint64x1_t b) { 5994 return vqadd_u64(a, b); 5995 } 5996 5997 // CHECK-LABEL: test_vqaddq_s8 5998 // CHECK: vqadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 5999 int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) { 6000 return vqaddq_s8(a, b); 6001 } 6002 6003 // CHECK-LABEL: test_vqaddq_s16 6004 // CHECK: vqadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6005 int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) { 6006 return vqaddq_s16(a, b); 6007 } 6008 6009 // CHECK-LABEL: test_vqaddq_s32 6010 // CHECK: vqadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6011 int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) { 6012 return vqaddq_s32(a, b); 6013 } 6014 6015 // CHECK-LABEL: test_vqaddq_s64 6016 // CHECK: vqadd.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6017 int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) { 6018 return vqaddq_s64(a, b); 6019 } 6020 6021 // CHECK-LABEL: test_vqaddq_u8 6022 // CHECK: vqadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6023 uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) { 6024 return vqaddq_u8(a, b); 6025 } 6026 6027 // CHECK-LABEL: test_vqaddq_u16 6028 // CHECK: vqadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6029 uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) { 6030 return vqaddq_u16(a, b); 6031 } 6032 6033 // CHECK-LABEL: test_vqaddq_u32 6034 // CHECK: vqadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6035 uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) { 6036 return vqaddq_u32(a, b); 6037 } 6038 6039 // CHECK-LABEL: test_vqaddq_u64 6040 // CHECK: vqadd.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6041 uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) { 6042 return vqaddq_u64(a, b); 6043 } 6044 6045 6046 // CHECK-LABEL: test_vqdmlal_s16 6047 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6048 int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6049 return vqdmlal_s16(a, b, c); 6050 } 6051 6052 // CHECK-LABEL: test_vqdmlal_s32 6053 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6054 int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6055 return vqdmlal_s32(a, b, c); 6056 } 6057 6058 6059 // CHECK-LABEL: test_vqdmlal_lane_s16 6060 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6061 int32x4_t test_vqdmlal_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6062 return vqdmlal_lane_s16(a, b, c, 3); 6063 } 6064 6065 // CHECK-LABEL: test_vqdmlal_lane_s32 6066 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6067 int64x2_t test_vqdmlal_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6068 return vqdmlal_lane_s32(a, b, c, 1); 6069 } 6070 6071 6072 // CHECK-LABEL: test_vqdmlal_n_s16 6073 // CHECK: vqdmlal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6074 int32x4_t test_vqdmlal_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 6075 return vqdmlal_n_s16(a, b, c); 6076 } 6077 6078 // CHECK-LABEL: test_vqdmlal_n_s32 6079 // CHECK: vqdmlal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6080 int64x2_t test_vqdmlal_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 6081 return vqdmlal_n_s32(a, b, c); 6082 } 6083 6084 6085 // CHECK-LABEL: test_vqdmlsl_s16 6086 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6087 int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6088 return vqdmlsl_s16(a, b, c); 6089 } 6090 6091 // CHECK-LABEL: test_vqdmlsl_s32 6092 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6093 int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6094 return vqdmlsl_s32(a, b, c); 6095 } 6096 6097 6098 // CHECK-LABEL: test_vqdmlsl_lane_s16 6099 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6100 int32x4_t test_vqdmlsl_lane_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 6101 return vqdmlsl_lane_s16(a, b, c, 3); 6102 } 6103 6104 // CHECK-LABEL: test_vqdmlsl_lane_s32 6105 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6106 int64x2_t test_vqdmlsl_lane_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 6107 return vqdmlsl_lane_s32(a, b, c, 1); 6108 } 6109 6110 6111 // CHECK-LABEL: test_vqdmlsl_n_s16 6112 // CHECK: vqdmlsl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6113 int32x4_t test_vqdmlsl_n_s16(int32x4_t a, int16x4_t b, int16_t c) { 6114 return vqdmlsl_n_s16(a, b, c); 6115 } 6116 6117 // CHECK-LABEL: test_vqdmlsl_n_s32 6118 // CHECK: vqdmlsl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6119 int64x2_t test_vqdmlsl_n_s32(int64x2_t a, int32x2_t b, int32_t c) { 6120 return vqdmlsl_n_s32(a, b, c); 6121 } 6122 6123 6124 // CHECK-LABEL: test_vqdmulh_s16 6125 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6126 int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) { 6127 return vqdmulh_s16(a, b); 6128 } 6129 6130 // CHECK-LABEL: test_vqdmulh_s32 6131 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6132 int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) { 6133 return vqdmulh_s32(a, b); 6134 } 6135 6136 // CHECK-LABEL: test_vqdmulhq_s16 6137 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6138 int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) { 6139 return vqdmulhq_s16(a, b); 6140 } 6141 6142 // CHECK-LABEL: test_vqdmulhq_s32 6143 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6144 int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) { 6145 return vqdmulhq_s32(a, b); 6146 } 6147 6148 6149 // CHECK-LABEL: test_vqdmulh_lane_s16 6150 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6151 int16x4_t test_vqdmulh_lane_s16(int16x4_t a, int16x4_t b) { 6152 return vqdmulh_lane_s16(a, b, 3); 6153 } 6154 6155 // CHECK-LABEL: test_vqdmulh_lane_s32 6156 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6157 int32x2_t test_vqdmulh_lane_s32(int32x2_t a, int32x2_t b) { 6158 return vqdmulh_lane_s32(a, b, 1); 6159 } 6160 6161 // CHECK-LABEL: test_vqdmulhq_lane_s16 6162 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6163 int16x8_t test_vqdmulhq_lane_s16(int16x8_t a, int16x4_t b) { 6164 return vqdmulhq_lane_s16(a, b, 3); 6165 } 6166 6167 // CHECK-LABEL: test_vqdmulhq_lane_s32 6168 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6169 int32x4_t test_vqdmulhq_lane_s32(int32x4_t a, int32x2_t b) { 6170 return vqdmulhq_lane_s32(a, b, 1); 6171 } 6172 6173 6174 // CHECK-LABEL: test_vqdmulh_n_s16 6175 // CHECK: vqdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6176 int16x4_t test_vqdmulh_n_s16(int16x4_t a, int16_t b) { 6177 return vqdmulh_n_s16(a, b); 6178 } 6179 6180 // CHECK-LABEL: test_vqdmulh_n_s32 6181 // CHECK: vqdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6182 int32x2_t test_vqdmulh_n_s32(int32x2_t a, int32_t b) { 6183 return vqdmulh_n_s32(a, b); 6184 } 6185 6186 // CHECK-LABEL: test_vqdmulhq_n_s16 6187 // CHECK: vqdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6188 int16x8_t test_vqdmulhq_n_s16(int16x8_t a, int16_t b) { 6189 return vqdmulhq_n_s16(a, b); 6190 } 6191 6192 // CHECK-LABEL: test_vqdmulhq_n_s32 6193 // CHECK: vqdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6194 int32x4_t test_vqdmulhq_n_s32(int32x4_t a, int32_t b) { 6195 return vqdmulhq_n_s32(a, b); 6196 } 6197 6198 6199 // CHECK-LABEL: test_vqdmull_s16 6200 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6201 int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) { 6202 return vqdmull_s16(a, b); 6203 } 6204 6205 // CHECK-LABEL: test_vqdmull_s32 6206 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6207 int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) { 6208 return vqdmull_s32(a, b); 6209 } 6210 6211 6212 // CHECK-LABEL: test_vqdmull_lane_s16 6213 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6214 int32x4_t test_vqdmull_lane_s16(int16x4_t a, int16x4_t b) { 6215 return vqdmull_lane_s16(a, b, 3); 6216 } 6217 6218 // CHECK-LABEL: test_vqdmull_lane_s32 6219 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6220 int64x2_t test_vqdmull_lane_s32(int32x2_t a, int32x2_t b) { 6221 return vqdmull_lane_s32(a, b, 1); 6222 } 6223 6224 6225 // CHECK-LABEL: test_vqdmull_n_s16 6226 // CHECK: vqdmull.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6227 int32x4_t test_vqdmull_n_s16(int16x4_t a, int16_t b) { 6228 return vqdmull_n_s16(a, b); 6229 } 6230 6231 // CHECK-LABEL: test_vqdmull_n_s32 6232 // CHECK: vqdmull.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6233 int64x2_t test_vqdmull_n_s32(int32x2_t a, int32_t b) { 6234 return vqdmull_n_s32(a, b); 6235 } 6236 6237 6238 // CHECK-LABEL: test_vqmovn_s16 6239 // CHECK: vqmovn.s16 d{{[0-9]+}}, q{{[0-9]+}} 6240 int8x8_t test_vqmovn_s16(int16x8_t a) { 6241 return vqmovn_s16(a); 6242 } 6243 6244 // CHECK-LABEL: test_vqmovn_s32 6245 // CHECK: vqmovn.s32 d{{[0-9]+}}, q{{[0-9]+}} 6246 int16x4_t test_vqmovn_s32(int32x4_t a) { 6247 return vqmovn_s32(a); 6248 } 6249 6250 // CHECK-LABEL: test_vqmovn_s64 6251 // CHECK: vqmovn.s64 d{{[0-9]+}}, q{{[0-9]+}} 6252 int32x2_t test_vqmovn_s64(int64x2_t a) { 6253 return vqmovn_s64(a); 6254 } 6255 6256 // CHECK-LABEL: test_vqmovn_u16 6257 // CHECK: vqmovn.u16 d{{[0-9]+}}, q{{[0-9]+}} 6258 uint8x8_t test_vqmovn_u16(uint16x8_t a) { 6259 return vqmovn_u16(a); 6260 } 6261 6262 // CHECK-LABEL: test_vqmovn_u32 6263 // CHECK: vqmovn.u32 d{{[0-9]+}}, q{{[0-9]+}} 6264 uint16x4_t test_vqmovn_u32(uint32x4_t a) { 6265 return vqmovn_u32(a); 6266 } 6267 6268 // CHECK-LABEL: test_vqmovn_u64 6269 // CHECK: vqmovn.u64 d{{[0-9]+}}, q{{[0-9]+}} 6270 uint32x2_t test_vqmovn_u64(uint64x2_t a) { 6271 return vqmovn_u64(a); 6272 } 6273 6274 6275 // CHECK-LABEL: test_vqmovun_s16 6276 // CHECK: vqmovun.s16 d{{[0-9]+}}, q{{[0-9]+}} 6277 uint8x8_t test_vqmovun_s16(int16x8_t a) { 6278 return vqmovun_s16(a); 6279 } 6280 6281 // CHECK-LABEL: test_vqmovun_s32 6282 // CHECK: vqmovun.s32 d{{[0-9]+}}, q{{[0-9]+}} 6283 uint16x4_t test_vqmovun_s32(int32x4_t a) { 6284 return vqmovun_s32(a); 6285 } 6286 6287 // CHECK-LABEL: test_vqmovun_s64 6288 // CHECK: vqmovun.s64 d{{[0-9]+}}, q{{[0-9]+}} 6289 uint32x2_t test_vqmovun_s64(int64x2_t a) { 6290 return vqmovun_s64(a); 6291 } 6292 6293 6294 // CHECK-LABEL: test_vqneg_s8 6295 // CHECK: vqneg.s8 d{{[0-9]+}}, d{{[0-9]+}} 6296 int8x8_t test_vqneg_s8(int8x8_t a) { 6297 return vqneg_s8(a); 6298 } 6299 6300 // CHECK-LABEL: test_vqneg_s16 6301 // CHECK: vqneg.s16 d{{[0-9]+}}, d{{[0-9]+}} 6302 int16x4_t test_vqneg_s16(int16x4_t a) { 6303 return vqneg_s16(a); 6304 } 6305 6306 // CHECK-LABEL: test_vqneg_s32 6307 // CHECK: vqneg.s32 d{{[0-9]+}}, d{{[0-9]+}} 6308 int32x2_t test_vqneg_s32(int32x2_t a) { 6309 return vqneg_s32(a); 6310 } 6311 6312 // CHECK-LABEL: test_vqnegq_s8 6313 // CHECK: vqneg.s8 q{{[0-9]+}}, q{{[0-9]+}} 6314 int8x16_t test_vqnegq_s8(int8x16_t a) { 6315 return vqnegq_s8(a); 6316 } 6317 6318 // CHECK-LABEL: test_vqnegq_s16 6319 // CHECK: vqneg.s16 q{{[0-9]+}}, q{{[0-9]+}} 6320 int16x8_t test_vqnegq_s16(int16x8_t a) { 6321 return vqnegq_s16(a); 6322 } 6323 6324 // CHECK-LABEL: test_vqnegq_s32 6325 // CHECK: vqneg.s32 q{{[0-9]+}}, q{{[0-9]+}} 6326 int32x4_t test_vqnegq_s32(int32x4_t a) { 6327 return vqnegq_s32(a); 6328 } 6329 6330 6331 // CHECK-LABEL: test_vqrdmulh_s16 6332 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6333 int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) { 6334 return vqrdmulh_s16(a, b); 6335 } 6336 6337 // CHECK-LABEL: test_vqrdmulh_s32 6338 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6339 int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) { 6340 return vqrdmulh_s32(a, b); 6341 } 6342 6343 // CHECK-LABEL: test_vqrdmulhq_s16 6344 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6345 int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) { 6346 return vqrdmulhq_s16(a, b); 6347 } 6348 6349 // CHECK-LABEL: test_vqrdmulhq_s32 6350 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6351 int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) { 6352 return vqrdmulhq_s32(a, b); 6353 } 6354 6355 6356 // CHECK-LABEL: test_vqrdmulh_lane_s16 6357 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6358 int16x4_t test_vqrdmulh_lane_s16(int16x4_t a, int16x4_t b) { 6359 return vqrdmulh_lane_s16(a, b, 3); 6360 } 6361 6362 // CHECK-LABEL: test_vqrdmulh_lane_s32 6363 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6364 int32x2_t test_vqrdmulh_lane_s32(int32x2_t a, int32x2_t b) { 6365 return vqrdmulh_lane_s32(a, b, 1); 6366 } 6367 6368 // CHECK-LABEL: test_vqrdmulhq_lane_s16 6369 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6370 int16x8_t test_vqrdmulhq_lane_s16(int16x8_t a, int16x4_t b) { 6371 return vqrdmulhq_lane_s16(a, b, 3); 6372 } 6373 6374 // CHECK-LABEL: test_vqrdmulhq_lane_s32 6375 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] 6376 int32x4_t test_vqrdmulhq_lane_s32(int32x4_t a, int32x2_t b) { 6377 return vqrdmulhq_lane_s32(a, b, 1); 6378 } 6379 6380 6381 // CHECK-LABEL: test_vqrdmulh_n_s16 6382 // CHECK: vqrdmulh.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6383 int16x4_t test_vqrdmulh_n_s16(int16x4_t a, int16_t b) { 6384 return vqrdmulh_n_s16(a, b); 6385 } 6386 6387 // CHECK-LABEL: test_vqrdmulh_n_s32 6388 // CHECK: vqrdmulh.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6389 int32x2_t test_vqrdmulh_n_s32(int32x2_t a, int32_t b) { 6390 return vqrdmulh_n_s32(a, b); 6391 } 6392 6393 // CHECK-LABEL: test_vqrdmulhq_n_s16 6394 // CHECK: vqrdmulh.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6395 int16x8_t test_vqrdmulhq_n_s16(int16x8_t a, int16_t b) { 6396 return vqrdmulhq_n_s16(a, b); 6397 } 6398 6399 // CHECK-LABEL: test_vqrdmulhq_n_s32 6400 // CHECK: vqrdmulh.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6401 int32x4_t test_vqrdmulhq_n_s32(int32x4_t a, int32_t b) { 6402 return vqrdmulhq_n_s32(a, b); 6403 } 6404 6405 6406 // CHECK-LABEL: test_vqrshl_s8 6407 // CHECK: vqrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6408 int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) { 6409 return vqrshl_s8(a, b); 6410 } 6411 6412 // CHECK-LABEL: test_vqrshl_s16 6413 // CHECK: vqrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6414 int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) { 6415 return vqrshl_s16(a, b); 6416 } 6417 6418 // CHECK-LABEL: test_vqrshl_s32 6419 // CHECK: vqrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6420 int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) { 6421 return vqrshl_s32(a, b); 6422 } 6423 6424 // CHECK-LABEL: test_vqrshl_s64 6425 // CHECK: vqrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6426 int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) { 6427 return vqrshl_s64(a, b); 6428 } 6429 6430 // CHECK-LABEL: test_vqrshl_u8 6431 // CHECK: vqrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6432 uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) { 6433 return vqrshl_u8(a, b); 6434 } 6435 6436 // CHECK-LABEL: test_vqrshl_u16 6437 // CHECK: vqrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6438 uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) { 6439 return vqrshl_u16(a, b); 6440 } 6441 6442 // CHECK-LABEL: test_vqrshl_u32 6443 // CHECK: vqrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6444 uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) { 6445 return vqrshl_u32(a, b); 6446 } 6447 6448 // CHECK-LABEL: test_vqrshl_u64 6449 // CHECK: vqrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6450 uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) { 6451 return vqrshl_u64(a, b); 6452 } 6453 6454 // CHECK-LABEL: test_vqrshlq_s8 6455 // CHECK: vqrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6456 int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) { 6457 return vqrshlq_s8(a, b); 6458 } 6459 6460 // CHECK-LABEL: test_vqrshlq_s16 6461 // CHECK: vqrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6462 int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) { 6463 return vqrshlq_s16(a, b); 6464 } 6465 6466 // CHECK-LABEL: test_vqrshlq_s32 6467 // CHECK: vqrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6468 int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) { 6469 return vqrshlq_s32(a, b); 6470 } 6471 6472 // CHECK-LABEL: test_vqrshlq_s64 6473 // CHECK: vqrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6474 int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) { 6475 return vqrshlq_s64(a, b); 6476 } 6477 6478 // CHECK-LABEL: test_vqrshlq_u8 6479 // CHECK: vqrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6480 uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) { 6481 return vqrshlq_u8(a, b); 6482 } 6483 6484 // CHECK-LABEL: test_vqrshlq_u16 6485 // CHECK: vqrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6486 uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) { 6487 return vqrshlq_u16(a, b); 6488 } 6489 6490 // CHECK-LABEL: test_vqrshlq_u32 6491 // CHECK: vqrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6492 uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) { 6493 return vqrshlq_u32(a, b); 6494 } 6495 6496 // CHECK-LABEL: test_vqrshlq_u64 6497 // CHECK: vqrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6498 uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) { 6499 return vqrshlq_u64(a, b); 6500 } 6501 6502 6503 // CHECK-LABEL: test_vqrshrn_n_s16 6504 // CHECK: vqrshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6505 int8x8_t test_vqrshrn_n_s16(int16x8_t a) { 6506 return vqrshrn_n_s16(a, 1); 6507 } 6508 6509 // CHECK-LABEL: test_vqrshrn_n_s32 6510 // CHECK: vqrshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6511 int16x4_t test_vqrshrn_n_s32(int32x4_t a) { 6512 return vqrshrn_n_s32(a, 1); 6513 } 6514 6515 // CHECK-LABEL: test_vqrshrn_n_s64 6516 // CHECK: vqrshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6517 int32x2_t test_vqrshrn_n_s64(int64x2_t a) { 6518 return vqrshrn_n_s64(a, 1); 6519 } 6520 6521 // CHECK-LABEL: test_vqrshrn_n_u16 6522 // CHECK: vqrshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6523 uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) { 6524 return vqrshrn_n_u16(a, 1); 6525 } 6526 6527 // CHECK-LABEL: test_vqrshrn_n_u32 6528 // CHECK: vqrshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6529 uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) { 6530 return vqrshrn_n_u32(a, 1); 6531 } 6532 6533 // CHECK-LABEL: test_vqrshrn_n_u64 6534 // CHECK: vqrshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6535 uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) { 6536 return vqrshrn_n_u64(a, 1); 6537 } 6538 6539 6540 // CHECK-LABEL: test_vqrshrun_n_s16 6541 // CHECK: vqrshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6542 uint8x8_t test_vqrshrun_n_s16(int16x8_t a) { 6543 return vqrshrun_n_s16(a, 1); 6544 } 6545 6546 // CHECK-LABEL: test_vqrshrun_n_s32 6547 // CHECK: vqrshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6548 uint16x4_t test_vqrshrun_n_s32(int32x4_t a) { 6549 return vqrshrun_n_s32(a, 1); 6550 } 6551 6552 // CHECK-LABEL: test_vqrshrun_n_s64 6553 // CHECK: vqrshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6554 uint32x2_t test_vqrshrun_n_s64(int64x2_t a) { 6555 return vqrshrun_n_s64(a, 1); 6556 } 6557 6558 6559 // CHECK-LABEL: test_vqshl_s8 6560 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6561 int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) { 6562 return vqshl_s8(a, b); 6563 } 6564 6565 // CHECK-LABEL: test_vqshl_s16 6566 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6567 int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) { 6568 return vqshl_s16(a, b); 6569 } 6570 6571 // CHECK-LABEL: test_vqshl_s32 6572 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6573 int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) { 6574 return vqshl_s32(a, b); 6575 } 6576 6577 // CHECK-LABEL: test_vqshl_s64 6578 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6579 int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) { 6580 return vqshl_s64(a, b); 6581 } 6582 6583 // CHECK-LABEL: test_vqshl_u8 6584 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6585 uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) { 6586 return vqshl_u8(a, b); 6587 } 6588 6589 // CHECK-LABEL: test_vqshl_u16 6590 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6591 uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) { 6592 return vqshl_u16(a, b); 6593 } 6594 6595 // CHECK-LABEL: test_vqshl_u32 6596 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6597 uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) { 6598 return vqshl_u32(a, b); 6599 } 6600 6601 // CHECK-LABEL: test_vqshl_u64 6602 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6603 uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) { 6604 return vqshl_u64(a, b); 6605 } 6606 6607 // CHECK-LABEL: test_vqshlq_s8 6608 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6609 int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) { 6610 return vqshlq_s8(a, b); 6611 } 6612 6613 // CHECK-LABEL: test_vqshlq_s16 6614 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6615 int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) { 6616 return vqshlq_s16(a, b); 6617 } 6618 6619 // CHECK-LABEL: test_vqshlq_s32 6620 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6621 int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) { 6622 return vqshlq_s32(a, b); 6623 } 6624 6625 // CHECK-LABEL: test_vqshlq_s64 6626 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6627 int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) { 6628 return vqshlq_s64(a, b); 6629 } 6630 6631 // CHECK-LABEL: test_vqshlq_u8 6632 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6633 uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) { 6634 return vqshlq_u8(a, b); 6635 } 6636 6637 // CHECK-LABEL: test_vqshlq_u16 6638 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6639 uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) { 6640 return vqshlq_u16(a, b); 6641 } 6642 6643 // CHECK-LABEL: test_vqshlq_u32 6644 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6645 uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) { 6646 return vqshlq_u32(a, b); 6647 } 6648 6649 // CHECK-LABEL: test_vqshlq_u64 6650 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6651 uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) { 6652 return vqshlq_u64(a, b); 6653 } 6654 6655 6656 // CHECK-LABEL: test_vqshlu_n_s8 6657 // CHECK: vqshlu.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6658 uint8x8_t test_vqshlu_n_s8(int8x8_t a) { 6659 return vqshlu_n_s8(a, 1); 6660 } 6661 6662 // CHECK-LABEL: test_vqshlu_n_s16 6663 // CHECK: vqshlu.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6664 uint16x4_t test_vqshlu_n_s16(int16x4_t a) { 6665 return vqshlu_n_s16(a, 1); 6666 } 6667 6668 // CHECK-LABEL: test_vqshlu_n_s32 6669 // CHECK: vqshlu.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6670 uint32x2_t test_vqshlu_n_s32(int32x2_t a) { 6671 return vqshlu_n_s32(a, 1); 6672 } 6673 6674 // CHECK-LABEL: test_vqshlu_n_s64 6675 // CHECK: vqshlu.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6676 uint64x1_t test_vqshlu_n_s64(int64x1_t a) { 6677 return vqshlu_n_s64(a, 1); 6678 } 6679 6680 // CHECK-LABEL: test_vqshluq_n_s8 6681 // CHECK: vqshlu.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6682 uint8x16_t test_vqshluq_n_s8(int8x16_t a) { 6683 return vqshluq_n_s8(a, 1); 6684 } 6685 6686 // CHECK-LABEL: test_vqshluq_n_s16 6687 // CHECK: vqshlu.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6688 uint16x8_t test_vqshluq_n_s16(int16x8_t a) { 6689 return vqshluq_n_s16(a, 1); 6690 } 6691 6692 // CHECK-LABEL: test_vqshluq_n_s32 6693 // CHECK: vqshlu.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6694 uint32x4_t test_vqshluq_n_s32(int32x4_t a) { 6695 return vqshluq_n_s32(a, 1); 6696 } 6697 6698 // CHECK-LABEL: test_vqshluq_n_s64 6699 // CHECK: vqshlu.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6700 uint64x2_t test_vqshluq_n_s64(int64x2_t a) { 6701 return vqshluq_n_s64(a, 1); 6702 } 6703 6704 6705 // CHECK-LABEL: test_vqshl_n_s8 6706 // CHECK: vqshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6707 int8x8_t test_vqshl_n_s8(int8x8_t a) { 6708 return vqshl_n_s8(a, 1); 6709 } 6710 6711 // CHECK-LABEL: test_vqshl_n_s16 6712 // CHECK: vqshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6713 int16x4_t test_vqshl_n_s16(int16x4_t a) { 6714 return vqshl_n_s16(a, 1); 6715 } 6716 6717 // CHECK-LABEL: test_vqshl_n_s32 6718 // CHECK: vqshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6719 int32x2_t test_vqshl_n_s32(int32x2_t a) { 6720 return vqshl_n_s32(a, 1); 6721 } 6722 6723 // CHECK-LABEL: test_vqshl_n_s64 6724 // CHECK: vqshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6725 int64x1_t test_vqshl_n_s64(int64x1_t a) { 6726 return vqshl_n_s64(a, 1); 6727 } 6728 6729 // CHECK-LABEL: test_vqshl_n_u8 6730 // CHECK: vqshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6731 uint8x8_t test_vqshl_n_u8(uint8x8_t a) { 6732 return vqshl_n_u8(a, 1); 6733 } 6734 6735 // CHECK-LABEL: test_vqshl_n_u16 6736 // CHECK: vqshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6737 uint16x4_t test_vqshl_n_u16(uint16x4_t a) { 6738 return vqshl_n_u16(a, 1); 6739 } 6740 6741 // CHECK-LABEL: test_vqshl_n_u32 6742 // CHECK: vqshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6743 uint32x2_t test_vqshl_n_u32(uint32x2_t a) { 6744 return vqshl_n_u32(a, 1); 6745 } 6746 6747 // CHECK-LABEL: test_vqshl_n_u64 6748 // CHECK: vqshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 6749 uint64x1_t test_vqshl_n_u64(uint64x1_t a) { 6750 return vqshl_n_u64(a, 1); 6751 } 6752 6753 // CHECK-LABEL: test_vqshlq_n_s8 6754 // CHECK: vqshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6755 int8x16_t test_vqshlq_n_s8(int8x16_t a) { 6756 return vqshlq_n_s8(a, 1); 6757 } 6758 6759 // CHECK-LABEL: test_vqshlq_n_s16 6760 // CHECK: vqshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6761 int16x8_t test_vqshlq_n_s16(int16x8_t a) { 6762 return vqshlq_n_s16(a, 1); 6763 } 6764 6765 // CHECK-LABEL: test_vqshlq_n_s32 6766 // CHECK: vqshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6767 int32x4_t test_vqshlq_n_s32(int32x4_t a) { 6768 return vqshlq_n_s32(a, 1); 6769 } 6770 6771 // CHECK-LABEL: test_vqshlq_n_s64 6772 // CHECK: vqshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6773 int64x2_t test_vqshlq_n_s64(int64x2_t a) { 6774 return vqshlq_n_s64(a, 1); 6775 } 6776 6777 // CHECK-LABEL: test_vqshlq_n_u8 6778 // CHECK: vqshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6779 uint8x16_t test_vqshlq_n_u8(uint8x16_t a) { 6780 return vqshlq_n_u8(a, 1); 6781 } 6782 6783 // CHECK-LABEL: test_vqshlq_n_u16 6784 // CHECK: vqshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6785 uint16x8_t test_vqshlq_n_u16(uint16x8_t a) { 6786 return vqshlq_n_u16(a, 1); 6787 } 6788 6789 // CHECK-LABEL: test_vqshlq_n_u32 6790 // CHECK: vqshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6791 uint32x4_t test_vqshlq_n_u32(uint32x4_t a) { 6792 return vqshlq_n_u32(a, 1); 6793 } 6794 6795 // CHECK-LABEL: test_vqshlq_n_u64 6796 // CHECK: vqshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6797 uint64x2_t test_vqshlq_n_u64(uint64x2_t a) { 6798 return vqshlq_n_u64(a, 1); 6799 } 6800 6801 6802 // CHECK-LABEL: test_vqshrn_n_s16 6803 // CHECK: vqshrn.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6804 int8x8_t test_vqshrn_n_s16(int16x8_t a) { 6805 return vqshrn_n_s16(a, 1); 6806 } 6807 6808 // CHECK-LABEL: test_vqshrn_n_s32 6809 // CHECK: vqshrn.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6810 int16x4_t test_vqshrn_n_s32(int32x4_t a) { 6811 return vqshrn_n_s32(a, 1); 6812 } 6813 6814 // CHECK-LABEL: test_vqshrn_n_s64 6815 // CHECK: vqshrn.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6816 int32x2_t test_vqshrn_n_s64(int64x2_t a) { 6817 return vqshrn_n_s64(a, 1); 6818 } 6819 6820 // CHECK-LABEL: test_vqshrn_n_u16 6821 // CHECK: vqshrn.u16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6822 uint8x8_t test_vqshrn_n_u16(uint16x8_t a) { 6823 return vqshrn_n_u16(a, 1); 6824 } 6825 6826 // CHECK-LABEL: test_vqshrn_n_u32 6827 // CHECK: vqshrn.u32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6828 uint16x4_t test_vqshrn_n_u32(uint32x4_t a) { 6829 return vqshrn_n_u32(a, 1); 6830 } 6831 6832 // CHECK-LABEL: test_vqshrn_n_u64 6833 // CHECK: vqshrn.u64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6834 uint32x2_t test_vqshrn_n_u64(uint64x2_t a) { 6835 return vqshrn_n_u64(a, 1); 6836 } 6837 6838 6839 // CHECK-LABEL: test_vqshrun_n_s16 6840 // CHECK: vqshrun.s16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6841 uint8x8_t test_vqshrun_n_s16(int16x8_t a) { 6842 return vqshrun_n_s16(a, 1); 6843 } 6844 6845 // CHECK-LABEL: test_vqshrun_n_s32 6846 // CHECK: vqshrun.s32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6847 uint16x4_t test_vqshrun_n_s32(int32x4_t a) { 6848 return vqshrun_n_s32(a, 1); 6849 } 6850 6851 // CHECK-LABEL: test_vqshrun_n_s64 6852 // CHECK: vqshrun.s64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 6853 uint32x2_t test_vqshrun_n_s64(int64x2_t a) { 6854 return vqshrun_n_s64(a, 1); 6855 } 6856 6857 6858 // CHECK-LABEL: test_vqsub_s8 6859 // CHECK: vqsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6860 int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) { 6861 return vqsub_s8(a, b); 6862 } 6863 6864 // CHECK-LABEL: test_vqsub_s16 6865 // CHECK: vqsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6866 int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) { 6867 return vqsub_s16(a, b); 6868 } 6869 6870 // CHECK-LABEL: test_vqsub_s32 6871 // CHECK: vqsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6872 int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) { 6873 return vqsub_s32(a, b); 6874 } 6875 6876 // CHECK-LABEL: test_vqsub_s64 6877 // CHECK: vqsub.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6878 int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) { 6879 return vqsub_s64(a, b); 6880 } 6881 6882 // CHECK-LABEL: test_vqsub_u8 6883 // CHECK: vqsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6884 uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) { 6885 return vqsub_u8(a, b); 6886 } 6887 6888 // CHECK-LABEL: test_vqsub_u16 6889 // CHECK: vqsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6890 uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) { 6891 return vqsub_u16(a, b); 6892 } 6893 6894 // CHECK-LABEL: test_vqsub_u32 6895 // CHECK: vqsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6896 uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) { 6897 return vqsub_u32(a, b); 6898 } 6899 6900 // CHECK-LABEL: test_vqsub_u64 6901 // CHECK: vqsub.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 6902 uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) { 6903 return vqsub_u64(a, b); 6904 } 6905 6906 // CHECK-LABEL: test_vqsubq_s8 6907 // CHECK: vqsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6908 int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) { 6909 return vqsubq_s8(a, b); 6910 } 6911 6912 // CHECK-LABEL: test_vqsubq_s16 6913 // CHECK: vqsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6914 int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) { 6915 return vqsubq_s16(a, b); 6916 } 6917 6918 // CHECK-LABEL: test_vqsubq_s32 6919 // CHECK: vqsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6920 int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) { 6921 return vqsubq_s32(a, b); 6922 } 6923 6924 // CHECK-LABEL: test_vqsubq_s64 6925 // CHECK: vqsub.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6926 int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) { 6927 return vqsubq_s64(a, b); 6928 } 6929 6930 // CHECK-LABEL: test_vqsubq_u8 6931 // CHECK: vqsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6932 uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) { 6933 return vqsubq_u8(a, b); 6934 } 6935 6936 // CHECK-LABEL: test_vqsubq_u16 6937 // CHECK: vqsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6938 uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) { 6939 return vqsubq_u16(a, b); 6940 } 6941 6942 // CHECK-LABEL: test_vqsubq_u32 6943 // CHECK: vqsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6944 uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) { 6945 return vqsubq_u32(a, b); 6946 } 6947 6948 // CHECK-LABEL: test_vqsubq_u64 6949 // CHECK: vqsub.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6950 uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) { 6951 return vqsubq_u64(a, b); 6952 } 6953 6954 6955 // CHECK-LABEL: test_vraddhn_s16 6956 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6957 int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) { 6958 return vraddhn_s16(a, b); 6959 } 6960 6961 // CHECK-LABEL: test_vraddhn_s32 6962 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6963 int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) { 6964 return vraddhn_s32(a, b); 6965 } 6966 6967 // CHECK-LABEL: test_vraddhn_s64 6968 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6969 int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) { 6970 return vraddhn_s64(a, b); 6971 } 6972 6973 // CHECK-LABEL: test_vraddhn_u16 6974 // CHECK: vraddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6975 uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) { 6976 return vraddhn_u16(a, b); 6977 } 6978 6979 // CHECK-LABEL: test_vraddhn_u32 6980 // CHECK: vraddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6981 uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) { 6982 return vraddhn_u32(a, b); 6983 } 6984 6985 // CHECK-LABEL: test_vraddhn_u64 6986 // CHECK: vraddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 6987 uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) { 6988 return vraddhn_u64(a, b); 6989 } 6990 6991 6992 // CHECK-LABEL: test_vrecpe_f32 6993 // CHECK: vrecpe.f32 d{{[0-9]+}}, d{{[0-9]+}} 6994 float32x2_t test_vrecpe_f32(float32x2_t a) { 6995 return vrecpe_f32(a); 6996 } 6997 6998 // CHECK-LABEL: test_vrecpe_u32 6999 // CHECK: vrecpe.u32 d{{[0-9]+}}, d{{[0-9]+}} 7000 uint32x2_t test_vrecpe_u32(uint32x2_t a) { 7001 return vrecpe_u32(a); 7002 } 7003 7004 // CHECK-LABEL: test_vrecpeq_f32 7005 // CHECK: vrecpe.f32 q{{[0-9]+}}, q{{[0-9]+}} 7006 float32x4_t test_vrecpeq_f32(float32x4_t a) { 7007 return vrecpeq_f32(a); 7008 } 7009 7010 // CHECK-LABEL: test_vrecpeq_u32 7011 // CHECK: vrecpe.u32 q{{[0-9]+}}, q{{[0-9]+}} 7012 uint32x4_t test_vrecpeq_u32(uint32x4_t a) { 7013 return vrecpeq_u32(a); 7014 } 7015 7016 7017 // CHECK-LABEL: test_vrecps_f32 7018 // CHECK: vrecps.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 7019 float32x2_t test_vrecps_f32(float32x2_t a, float32x2_t b) { 7020 return vrecps_f32(a, b); 7021 } 7022 7023 // CHECK-LABEL: test_vrecpsq_f32 7024 // CHECK: vrecps.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 7025 float32x4_t test_vrecpsq_f32(float32x4_t a, float32x4_t b) { 7026 return vrecpsq_f32(a, b); 7027 } 7028 7029 7030 // CHECK-LABEL: test_vreinterpret_s8_s16 7031 int8x8_t test_vreinterpret_s8_s16(int16x4_t a) { 7032 return vreinterpret_s8_s16(a); 7033 } 7034 7035 // CHECK-LABEL: test_vreinterpret_s8_s32 7036 int8x8_t test_vreinterpret_s8_s32(int32x2_t a) { 7037 return vreinterpret_s8_s32(a); 7038 } 7039 7040 // CHECK-LABEL: test_vreinterpret_s8_s64 7041 int8x8_t test_vreinterpret_s8_s64(int64x1_t a) { 7042 return vreinterpret_s8_s64(a); 7043 } 7044 7045 // CHECK-LABEL: test_vreinterpret_s8_u8 7046 int8x8_t test_vreinterpret_s8_u8(uint8x8_t a) { 7047 return vreinterpret_s8_u8(a); 7048 } 7049 7050 // CHECK-LABEL: test_vreinterpret_s8_u16 7051 int8x8_t test_vreinterpret_s8_u16(uint16x4_t a) { 7052 return vreinterpret_s8_u16(a); 7053 } 7054 7055 // CHECK-LABEL: test_vreinterpret_s8_u32 7056 int8x8_t test_vreinterpret_s8_u32(uint32x2_t a) { 7057 return vreinterpret_s8_u32(a); 7058 } 7059 7060 // CHECK-LABEL: test_vreinterpret_s8_u64 7061 int8x8_t test_vreinterpret_s8_u64(uint64x1_t a) { 7062 return vreinterpret_s8_u64(a); 7063 } 7064 7065 // CHECK-LABEL: test_vreinterpret_s8_f16 7066 int8x8_t test_vreinterpret_s8_f16(float16x4_t a) { 7067 return vreinterpret_s8_f16(a); 7068 } 7069 7070 // CHECK-LABEL: test_vreinterpret_s8_f32 7071 int8x8_t test_vreinterpret_s8_f32(float32x2_t a) { 7072 return vreinterpret_s8_f32(a); 7073 } 7074 7075 // CHECK-LABEL: test_vreinterpret_s8_p8 7076 int8x8_t test_vreinterpret_s8_p8(poly8x8_t a) { 7077 return vreinterpret_s8_p8(a); 7078 } 7079 7080 // CHECK-LABEL: test_vreinterpret_s8_p16 7081 int8x8_t test_vreinterpret_s8_p16(poly16x4_t a) { 7082 return vreinterpret_s8_p16(a); 7083 } 7084 7085 // CHECK-LABEL: test_vreinterpret_s16_s8 7086 int16x4_t test_vreinterpret_s16_s8(int8x8_t a) { 7087 return vreinterpret_s16_s8(a); 7088 } 7089 7090 // CHECK-LABEL: test_vreinterpret_s16_s32 7091 int16x4_t test_vreinterpret_s16_s32(int32x2_t a) { 7092 return vreinterpret_s16_s32(a); 7093 } 7094 7095 // CHECK-LABEL: test_vreinterpret_s16_s64 7096 int16x4_t test_vreinterpret_s16_s64(int64x1_t a) { 7097 return vreinterpret_s16_s64(a); 7098 } 7099 7100 // CHECK-LABEL: test_vreinterpret_s16_u8 7101 int16x4_t test_vreinterpret_s16_u8(uint8x8_t a) { 7102 return vreinterpret_s16_u8(a); 7103 } 7104 7105 // CHECK-LABEL: test_vreinterpret_s16_u16 7106 int16x4_t test_vreinterpret_s16_u16(uint16x4_t a) { 7107 return vreinterpret_s16_u16(a); 7108 } 7109 7110 // CHECK-LABEL: test_vreinterpret_s16_u32 7111 int16x4_t test_vreinterpret_s16_u32(uint32x2_t a) { 7112 return vreinterpret_s16_u32(a); 7113 } 7114 7115 // CHECK-LABEL: test_vreinterpret_s16_u64 7116 int16x4_t test_vreinterpret_s16_u64(uint64x1_t a) { 7117 return vreinterpret_s16_u64(a); 7118 } 7119 7120 // CHECK-LABEL: test_vreinterpret_s16_f16 7121 int16x4_t test_vreinterpret_s16_f16(float16x4_t a) { 7122 return vreinterpret_s16_f16(a); 7123 } 7124 7125 // CHECK-LABEL: test_vreinterpret_s16_f32 7126 int16x4_t test_vreinterpret_s16_f32(float32x2_t a) { 7127 return vreinterpret_s16_f32(a); 7128 } 7129 7130 // CHECK-LABEL: test_vreinterpret_s16_p8 7131 int16x4_t test_vreinterpret_s16_p8(poly8x8_t a) { 7132 return vreinterpret_s16_p8(a); 7133 } 7134 7135 // CHECK-LABEL: test_vreinterpret_s16_p16 7136 int16x4_t test_vreinterpret_s16_p16(poly16x4_t a) { 7137 return vreinterpret_s16_p16(a); 7138 } 7139 7140 // CHECK-LABEL: test_vreinterpret_s32_s8 7141 int32x2_t test_vreinterpret_s32_s8(int8x8_t a) { 7142 return vreinterpret_s32_s8(a); 7143 } 7144 7145 // CHECK-LABEL: test_vreinterpret_s32_s16 7146 int32x2_t test_vreinterpret_s32_s16(int16x4_t a) { 7147 return vreinterpret_s32_s16(a); 7148 } 7149 7150 // CHECK-LABEL: test_vreinterpret_s32_s64 7151 int32x2_t test_vreinterpret_s32_s64(int64x1_t a) { 7152 return vreinterpret_s32_s64(a); 7153 } 7154 7155 // CHECK-LABEL: test_vreinterpret_s32_u8 7156 int32x2_t test_vreinterpret_s32_u8(uint8x8_t a) { 7157 return vreinterpret_s32_u8(a); 7158 } 7159 7160 // CHECK-LABEL: test_vreinterpret_s32_u16 7161 int32x2_t test_vreinterpret_s32_u16(uint16x4_t a) { 7162 return vreinterpret_s32_u16(a); 7163 } 7164 7165 // CHECK-LABEL: test_vreinterpret_s32_u32 7166 int32x2_t test_vreinterpret_s32_u32(uint32x2_t a) { 7167 return vreinterpret_s32_u32(a); 7168 } 7169 7170 // CHECK-LABEL: test_vreinterpret_s32_u64 7171 int32x2_t test_vreinterpret_s32_u64(uint64x1_t a) { 7172 return vreinterpret_s32_u64(a); 7173 } 7174 7175 // CHECK-LABEL: test_vreinterpret_s32_f16 7176 int32x2_t test_vreinterpret_s32_f16(float16x4_t a) { 7177 return vreinterpret_s32_f16(a); 7178 } 7179 7180 // CHECK-LABEL: test_vreinterpret_s32_f32 7181 int32x2_t test_vreinterpret_s32_f32(float32x2_t a) { 7182 return vreinterpret_s32_f32(a); 7183 } 7184 7185 // CHECK-LABEL: test_vreinterpret_s32_p8 7186 int32x2_t test_vreinterpret_s32_p8(poly8x8_t a) { 7187 return vreinterpret_s32_p8(a); 7188 } 7189 7190 // CHECK-LABEL: test_vreinterpret_s32_p16 7191 int32x2_t test_vreinterpret_s32_p16(poly16x4_t a) { 7192 return vreinterpret_s32_p16(a); 7193 } 7194 7195 // CHECK-LABEL: test_vreinterpret_s64_s8 7196 int64x1_t test_vreinterpret_s64_s8(int8x8_t a) { 7197 return vreinterpret_s64_s8(a); 7198 } 7199 7200 // CHECK-LABEL: test_vreinterpret_s64_s16 7201 int64x1_t test_vreinterpret_s64_s16(int16x4_t a) { 7202 return vreinterpret_s64_s16(a); 7203 } 7204 7205 // CHECK-LABEL: test_vreinterpret_s64_s32 7206 int64x1_t test_vreinterpret_s64_s32(int32x2_t a) { 7207 return vreinterpret_s64_s32(a); 7208 } 7209 7210 // CHECK-LABEL: test_vreinterpret_s64_u8 7211 int64x1_t test_vreinterpret_s64_u8(uint8x8_t a) { 7212 return vreinterpret_s64_u8(a); 7213 } 7214 7215 // CHECK-LABEL: test_vreinterpret_s64_u16 7216 int64x1_t test_vreinterpret_s64_u16(uint16x4_t a) { 7217 return vreinterpret_s64_u16(a); 7218 } 7219 7220 // CHECK-LABEL: test_vreinterpret_s64_u32 7221 int64x1_t test_vreinterpret_s64_u32(uint32x2_t a) { 7222 return vreinterpret_s64_u32(a); 7223 } 7224 7225 // CHECK-LABEL: test_vreinterpret_s64_u64 7226 int64x1_t test_vreinterpret_s64_u64(uint64x1_t a) { 7227 return vreinterpret_s64_u64(a); 7228 } 7229 7230 // CHECK-LABEL: test_vreinterpret_s64_f16 7231 int64x1_t test_vreinterpret_s64_f16(float16x4_t a) { 7232 return vreinterpret_s64_f16(a); 7233 } 7234 7235 // CHECK-LABEL: test_vreinterpret_s64_f32 7236 int64x1_t test_vreinterpret_s64_f32(float32x2_t a) { 7237 return vreinterpret_s64_f32(a); 7238 } 7239 7240 // CHECK-LABEL: test_vreinterpret_s64_p8 7241 int64x1_t test_vreinterpret_s64_p8(poly8x8_t a) { 7242 return vreinterpret_s64_p8(a); 7243 } 7244 7245 // CHECK-LABEL: test_vreinterpret_s64_p16 7246 int64x1_t test_vreinterpret_s64_p16(poly16x4_t a) { 7247 return vreinterpret_s64_p16(a); 7248 } 7249 7250 // CHECK-LABEL: test_vreinterpret_u8_s8 7251 uint8x8_t test_vreinterpret_u8_s8(int8x8_t a) { 7252 return vreinterpret_u8_s8(a); 7253 } 7254 7255 // CHECK-LABEL: test_vreinterpret_u8_s16 7256 uint8x8_t test_vreinterpret_u8_s16(int16x4_t a) { 7257 return vreinterpret_u8_s16(a); 7258 } 7259 7260 // CHECK-LABEL: test_vreinterpret_u8_s32 7261 uint8x8_t test_vreinterpret_u8_s32(int32x2_t a) { 7262 return vreinterpret_u8_s32(a); 7263 } 7264 7265 // CHECK-LABEL: test_vreinterpret_u8_s64 7266 uint8x8_t test_vreinterpret_u8_s64(int64x1_t a) { 7267 return vreinterpret_u8_s64(a); 7268 } 7269 7270 // CHECK-LABEL: test_vreinterpret_u8_u16 7271 uint8x8_t test_vreinterpret_u8_u16(uint16x4_t a) { 7272 return vreinterpret_u8_u16(a); 7273 } 7274 7275 // CHECK-LABEL: test_vreinterpret_u8_u32 7276 uint8x8_t test_vreinterpret_u8_u32(uint32x2_t a) { 7277 return vreinterpret_u8_u32(a); 7278 } 7279 7280 // CHECK-LABEL: test_vreinterpret_u8_u64 7281 uint8x8_t test_vreinterpret_u8_u64(uint64x1_t a) { 7282 return vreinterpret_u8_u64(a); 7283 } 7284 7285 // CHECK-LABEL: test_vreinterpret_u8_f16 7286 uint8x8_t test_vreinterpret_u8_f16(float16x4_t a) { 7287 return vreinterpret_u8_f16(a); 7288 } 7289 7290 // CHECK-LABEL: test_vreinterpret_u8_f32 7291 uint8x8_t test_vreinterpret_u8_f32(float32x2_t a) { 7292 return vreinterpret_u8_f32(a); 7293 } 7294 7295 // CHECK-LABEL: test_vreinterpret_u8_p8 7296 uint8x8_t test_vreinterpret_u8_p8(poly8x8_t a) { 7297 return vreinterpret_u8_p8(a); 7298 } 7299 7300 // CHECK-LABEL: test_vreinterpret_u8_p16 7301 uint8x8_t test_vreinterpret_u8_p16(poly16x4_t a) { 7302 return vreinterpret_u8_p16(a); 7303 } 7304 7305 // CHECK-LABEL: test_vreinterpret_u16_s8 7306 uint16x4_t test_vreinterpret_u16_s8(int8x8_t a) { 7307 return vreinterpret_u16_s8(a); 7308 } 7309 7310 // CHECK-LABEL: test_vreinterpret_u16_s16 7311 uint16x4_t test_vreinterpret_u16_s16(int16x4_t a) { 7312 return vreinterpret_u16_s16(a); 7313 } 7314 7315 // CHECK-LABEL: test_vreinterpret_u16_s32 7316 uint16x4_t test_vreinterpret_u16_s32(int32x2_t a) { 7317 return vreinterpret_u16_s32(a); 7318 } 7319 7320 // CHECK-LABEL: test_vreinterpret_u16_s64 7321 uint16x4_t test_vreinterpret_u16_s64(int64x1_t a) { 7322 return vreinterpret_u16_s64(a); 7323 } 7324 7325 // CHECK-LABEL: test_vreinterpret_u16_u8 7326 uint16x4_t test_vreinterpret_u16_u8(uint8x8_t a) { 7327 return vreinterpret_u16_u8(a); 7328 } 7329 7330 // CHECK-LABEL: test_vreinterpret_u16_u32 7331 uint16x4_t test_vreinterpret_u16_u32(uint32x2_t a) { 7332 return vreinterpret_u16_u32(a); 7333 } 7334 7335 // CHECK-LABEL: test_vreinterpret_u16_u64 7336 uint16x4_t test_vreinterpret_u16_u64(uint64x1_t a) { 7337 return vreinterpret_u16_u64(a); 7338 } 7339 7340 // CHECK-LABEL: test_vreinterpret_u16_f16 7341 uint16x4_t test_vreinterpret_u16_f16(float16x4_t a) { 7342 return vreinterpret_u16_f16(a); 7343 } 7344 7345 // CHECK-LABEL: test_vreinterpret_u16_f32 7346 uint16x4_t test_vreinterpret_u16_f32(float32x2_t a) { 7347 return vreinterpret_u16_f32(a); 7348 } 7349 7350 // CHECK-LABEL: test_vreinterpret_u16_p8 7351 uint16x4_t test_vreinterpret_u16_p8(poly8x8_t a) { 7352 return vreinterpret_u16_p8(a); 7353 } 7354 7355 // CHECK-LABEL: test_vreinterpret_u16_p16 7356 uint16x4_t test_vreinterpret_u16_p16(poly16x4_t a) { 7357 return vreinterpret_u16_p16(a); 7358 } 7359 7360 // CHECK-LABEL: test_vreinterpret_u32_s8 7361 uint32x2_t test_vreinterpret_u32_s8(int8x8_t a) { 7362 return vreinterpret_u32_s8(a); 7363 } 7364 7365 // CHECK-LABEL: test_vreinterpret_u32_s16 7366 uint32x2_t test_vreinterpret_u32_s16(int16x4_t a) { 7367 return vreinterpret_u32_s16(a); 7368 } 7369 7370 // CHECK-LABEL: test_vreinterpret_u32_s32 7371 uint32x2_t test_vreinterpret_u32_s32(int32x2_t a) { 7372 return vreinterpret_u32_s32(a); 7373 } 7374 7375 // CHECK-LABEL: test_vreinterpret_u32_s64 7376 uint32x2_t test_vreinterpret_u32_s64(int64x1_t a) { 7377 return vreinterpret_u32_s64(a); 7378 } 7379 7380 // CHECK-LABEL: test_vreinterpret_u32_u8 7381 uint32x2_t test_vreinterpret_u32_u8(uint8x8_t a) { 7382 return vreinterpret_u32_u8(a); 7383 } 7384 7385 // CHECK-LABEL: test_vreinterpret_u32_u16 7386 uint32x2_t test_vreinterpret_u32_u16(uint16x4_t a) { 7387 return vreinterpret_u32_u16(a); 7388 } 7389 7390 // CHECK-LABEL: test_vreinterpret_u32_u64 7391 uint32x2_t test_vreinterpret_u32_u64(uint64x1_t a) { 7392 return vreinterpret_u32_u64(a); 7393 } 7394 7395 // CHECK-LABEL: test_vreinterpret_u32_f16 7396 uint32x2_t test_vreinterpret_u32_f16(float16x4_t a) { 7397 return vreinterpret_u32_f16(a); 7398 } 7399 7400 // CHECK-LABEL: test_vreinterpret_u32_f32 7401 uint32x2_t test_vreinterpret_u32_f32(float32x2_t a) { 7402 return vreinterpret_u32_f32(a); 7403 } 7404 7405 // CHECK-LABEL: test_vreinterpret_u32_p8 7406 uint32x2_t test_vreinterpret_u32_p8(poly8x8_t a) { 7407 return vreinterpret_u32_p8(a); 7408 } 7409 7410 // CHECK-LABEL: test_vreinterpret_u32_p16 7411 uint32x2_t test_vreinterpret_u32_p16(poly16x4_t a) { 7412 return vreinterpret_u32_p16(a); 7413 } 7414 7415 // CHECK-LABEL: test_vreinterpret_u64_s8 7416 uint64x1_t test_vreinterpret_u64_s8(int8x8_t a) { 7417 return vreinterpret_u64_s8(a); 7418 } 7419 7420 // CHECK-LABEL: test_vreinterpret_u64_s16 7421 uint64x1_t test_vreinterpret_u64_s16(int16x4_t a) { 7422 return vreinterpret_u64_s16(a); 7423 } 7424 7425 // CHECK-LABEL: test_vreinterpret_u64_s32 7426 uint64x1_t test_vreinterpret_u64_s32(int32x2_t a) { 7427 return vreinterpret_u64_s32(a); 7428 } 7429 7430 // CHECK-LABEL: test_vreinterpret_u64_s64 7431 uint64x1_t test_vreinterpret_u64_s64(int64x1_t a) { 7432 return vreinterpret_u64_s64(a); 7433 } 7434 7435 // CHECK-LABEL: test_vreinterpret_u64_u8 7436 uint64x1_t test_vreinterpret_u64_u8(uint8x8_t a) { 7437 return vreinterpret_u64_u8(a); 7438 } 7439 7440 // CHECK-LABEL: test_vreinterpret_u64_u16 7441 uint64x1_t test_vreinterpret_u64_u16(uint16x4_t a) { 7442 return vreinterpret_u64_u16(a); 7443 } 7444 7445 // CHECK-LABEL: test_vreinterpret_u64_u32 7446 uint64x1_t test_vreinterpret_u64_u32(uint32x2_t a) { 7447 return vreinterpret_u64_u32(a); 7448 } 7449 7450 // CHECK-LABEL: test_vreinterpret_u64_f16 7451 uint64x1_t test_vreinterpret_u64_f16(float16x4_t a) { 7452 return vreinterpret_u64_f16(a); 7453 } 7454 7455 // CHECK-LABEL: test_vreinterpret_u64_f32 7456 uint64x1_t test_vreinterpret_u64_f32(float32x2_t a) { 7457 return vreinterpret_u64_f32(a); 7458 } 7459 7460 // CHECK-LABEL: test_vreinterpret_u64_p8 7461 uint64x1_t test_vreinterpret_u64_p8(poly8x8_t a) { 7462 return vreinterpret_u64_p8(a); 7463 } 7464 7465 // CHECK-LABEL: test_vreinterpret_u64_p16 7466 uint64x1_t test_vreinterpret_u64_p16(poly16x4_t a) { 7467 return vreinterpret_u64_p16(a); 7468 } 7469 7470 // CHECK-LABEL: test_vreinterpret_f16_s8 7471 float16x4_t test_vreinterpret_f16_s8(int8x8_t a) { 7472 return vreinterpret_f16_s8(a); 7473 } 7474 7475 // CHECK-LABEL: test_vreinterpret_f16_s16 7476 float16x4_t test_vreinterpret_f16_s16(int16x4_t a) { 7477 return vreinterpret_f16_s16(a); 7478 } 7479 7480 // CHECK-LABEL: test_vreinterpret_f16_s32 7481 float16x4_t test_vreinterpret_f16_s32(int32x2_t a) { 7482 return vreinterpret_f16_s32(a); 7483 } 7484 7485 // CHECK-LABEL: test_vreinterpret_f16_s64 7486 float16x4_t test_vreinterpret_f16_s64(int64x1_t a) { 7487 return vreinterpret_f16_s64(a); 7488 } 7489 7490 // CHECK-LABEL: test_vreinterpret_f16_u8 7491 float16x4_t test_vreinterpret_f16_u8(uint8x8_t a) { 7492 return vreinterpret_f16_u8(a); 7493 } 7494 7495 // CHECK-LABEL: test_vreinterpret_f16_u16 7496 float16x4_t test_vreinterpret_f16_u16(uint16x4_t a) { 7497 return vreinterpret_f16_u16(a); 7498 } 7499 7500 // CHECK-LABEL: test_vreinterpret_f16_u32 7501 float16x4_t test_vreinterpret_f16_u32(uint32x2_t a) { 7502 return vreinterpret_f16_u32(a); 7503 } 7504 7505 // CHECK-LABEL: test_vreinterpret_f16_u64 7506 float16x4_t test_vreinterpret_f16_u64(uint64x1_t a) { 7507 return vreinterpret_f16_u64(a); 7508 } 7509 7510 // CHECK-LABEL: test_vreinterpret_f16_f32 7511 float16x4_t test_vreinterpret_f16_f32(float32x2_t a) { 7512 return vreinterpret_f16_f32(a); 7513 } 7514 7515 // CHECK-LABEL: test_vreinterpret_f16_p8 7516 float16x4_t test_vreinterpret_f16_p8(poly8x8_t a) { 7517 return vreinterpret_f16_p8(a); 7518 } 7519 7520 // CHECK-LABEL: test_vreinterpret_f16_p16 7521 float16x4_t test_vreinterpret_f16_p16(poly16x4_t a) { 7522 return vreinterpret_f16_p16(a); 7523 } 7524 7525 // CHECK-LABEL: test_vreinterpret_f32_s8 7526 float32x2_t test_vreinterpret_f32_s8(int8x8_t a) { 7527 return vreinterpret_f32_s8(a); 7528 } 7529 7530 // CHECK-LABEL: test_vreinterpret_f32_s16 7531 float32x2_t test_vreinterpret_f32_s16(int16x4_t a) { 7532 return vreinterpret_f32_s16(a); 7533 } 7534 7535 // CHECK-LABEL: test_vreinterpret_f32_s32 7536 float32x2_t test_vreinterpret_f32_s32(int32x2_t a) { 7537 return vreinterpret_f32_s32(a); 7538 } 7539 7540 // CHECK-LABEL: test_vreinterpret_f32_s64 7541 float32x2_t test_vreinterpret_f32_s64(int64x1_t a) { 7542 return vreinterpret_f32_s64(a); 7543 } 7544 7545 // CHECK-LABEL: test_vreinterpret_f32_u8 7546 float32x2_t test_vreinterpret_f32_u8(uint8x8_t a) { 7547 return vreinterpret_f32_u8(a); 7548 } 7549 7550 // CHECK-LABEL: test_vreinterpret_f32_u16 7551 float32x2_t test_vreinterpret_f32_u16(uint16x4_t a) { 7552 return vreinterpret_f32_u16(a); 7553 } 7554 7555 // CHECK-LABEL: test_vreinterpret_f32_u32 7556 float32x2_t test_vreinterpret_f32_u32(uint32x2_t a) { 7557 return vreinterpret_f32_u32(a); 7558 } 7559 7560 // CHECK-LABEL: test_vreinterpret_f32_u64 7561 float32x2_t test_vreinterpret_f32_u64(uint64x1_t a) { 7562 return vreinterpret_f32_u64(a); 7563 } 7564 7565 // CHECK-LABEL: test_vreinterpret_f32_f16 7566 float32x2_t test_vreinterpret_f32_f16(float16x4_t a) { 7567 return vreinterpret_f32_f16(a); 7568 } 7569 7570 // CHECK-LABEL: test_vreinterpret_f32_p8 7571 float32x2_t test_vreinterpret_f32_p8(poly8x8_t a) { 7572 return vreinterpret_f32_p8(a); 7573 } 7574 7575 // CHECK-LABEL: test_vreinterpret_f32_p16 7576 float32x2_t test_vreinterpret_f32_p16(poly16x4_t a) { 7577 return vreinterpret_f32_p16(a); 7578 } 7579 7580 // CHECK-LABEL: test_vreinterpret_p8_s8 7581 poly8x8_t test_vreinterpret_p8_s8(int8x8_t a) { 7582 return vreinterpret_p8_s8(a); 7583 } 7584 7585 // CHECK-LABEL: test_vreinterpret_p8_s16 7586 poly8x8_t test_vreinterpret_p8_s16(int16x4_t a) { 7587 return vreinterpret_p8_s16(a); 7588 } 7589 7590 // CHECK-LABEL: test_vreinterpret_p8_s32 7591 poly8x8_t test_vreinterpret_p8_s32(int32x2_t a) { 7592 return vreinterpret_p8_s32(a); 7593 } 7594 7595 // CHECK-LABEL: test_vreinterpret_p8_s64 7596 poly8x8_t test_vreinterpret_p8_s64(int64x1_t a) { 7597 return vreinterpret_p8_s64(a); 7598 } 7599 7600 // CHECK-LABEL: test_vreinterpret_p8_u8 7601 poly8x8_t test_vreinterpret_p8_u8(uint8x8_t a) { 7602 return vreinterpret_p8_u8(a); 7603 } 7604 7605 // CHECK-LABEL: test_vreinterpret_p8_u16 7606 poly8x8_t test_vreinterpret_p8_u16(uint16x4_t a) { 7607 return vreinterpret_p8_u16(a); 7608 } 7609 7610 // CHECK-LABEL: test_vreinterpret_p8_u32 7611 poly8x8_t test_vreinterpret_p8_u32(uint32x2_t a) { 7612 return vreinterpret_p8_u32(a); 7613 } 7614 7615 // CHECK-LABEL: test_vreinterpret_p8_u64 7616 poly8x8_t test_vreinterpret_p8_u64(uint64x1_t a) { 7617 return vreinterpret_p8_u64(a); 7618 } 7619 7620 // CHECK-LABEL: test_vreinterpret_p8_f16 7621 poly8x8_t test_vreinterpret_p8_f16(float16x4_t a) { 7622 return vreinterpret_p8_f16(a); 7623 } 7624 7625 // CHECK-LABEL: test_vreinterpret_p8_f32 7626 poly8x8_t test_vreinterpret_p8_f32(float32x2_t a) { 7627 return vreinterpret_p8_f32(a); 7628 } 7629 7630 // CHECK-LABEL: test_vreinterpret_p8_p16 7631 poly8x8_t test_vreinterpret_p8_p16(poly16x4_t a) { 7632 return vreinterpret_p8_p16(a); 7633 } 7634 7635 // CHECK-LABEL: test_vreinterpret_p16_s8 7636 poly16x4_t test_vreinterpret_p16_s8(int8x8_t a) { 7637 return vreinterpret_p16_s8(a); 7638 } 7639 7640 // CHECK-LABEL: test_vreinterpret_p16_s16 7641 poly16x4_t test_vreinterpret_p16_s16(int16x4_t a) { 7642 return vreinterpret_p16_s16(a); 7643 } 7644 7645 // CHECK-LABEL: test_vreinterpret_p16_s32 7646 poly16x4_t test_vreinterpret_p16_s32(int32x2_t a) { 7647 return vreinterpret_p16_s32(a); 7648 } 7649 7650 // CHECK-LABEL: test_vreinterpret_p16_s64 7651 poly16x4_t test_vreinterpret_p16_s64(int64x1_t a) { 7652 return vreinterpret_p16_s64(a); 7653 } 7654 7655 // CHECK-LABEL: test_vreinterpret_p16_u8 7656 poly16x4_t test_vreinterpret_p16_u8(uint8x8_t a) { 7657 return vreinterpret_p16_u8(a); 7658 } 7659 7660 // CHECK-LABEL: test_vreinterpret_p16_u16 7661 poly16x4_t test_vreinterpret_p16_u16(uint16x4_t a) { 7662 return vreinterpret_p16_u16(a); 7663 } 7664 7665 // CHECK-LABEL: test_vreinterpret_p16_u32 7666 poly16x4_t test_vreinterpret_p16_u32(uint32x2_t a) { 7667 return vreinterpret_p16_u32(a); 7668 } 7669 7670 // CHECK-LABEL: test_vreinterpret_p16_u64 7671 poly16x4_t test_vreinterpret_p16_u64(uint64x1_t a) { 7672 return vreinterpret_p16_u64(a); 7673 } 7674 7675 // CHECK-LABEL: test_vreinterpret_p16_f16 7676 poly16x4_t test_vreinterpret_p16_f16(float16x4_t a) { 7677 return vreinterpret_p16_f16(a); 7678 } 7679 7680 // CHECK-LABEL: test_vreinterpret_p16_f32 7681 poly16x4_t test_vreinterpret_p16_f32(float32x2_t a) { 7682 return vreinterpret_p16_f32(a); 7683 } 7684 7685 // CHECK-LABEL: test_vreinterpret_p16_p8 7686 poly16x4_t test_vreinterpret_p16_p8(poly8x8_t a) { 7687 return vreinterpret_p16_p8(a); 7688 } 7689 7690 // CHECK-LABEL: test_vreinterpretq_s8_s16 7691 int8x16_t test_vreinterpretq_s8_s16(int16x8_t a) { 7692 return vreinterpretq_s8_s16(a); 7693 } 7694 7695 // CHECK-LABEL: test_vreinterpretq_s8_s32 7696 int8x16_t test_vreinterpretq_s8_s32(int32x4_t a) { 7697 return vreinterpretq_s8_s32(a); 7698 } 7699 7700 // CHECK-LABEL: test_vreinterpretq_s8_s64 7701 int8x16_t test_vreinterpretq_s8_s64(int64x2_t a) { 7702 return vreinterpretq_s8_s64(a); 7703 } 7704 7705 // CHECK-LABEL: test_vreinterpretq_s8_u8 7706 int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a) { 7707 return vreinterpretq_s8_u8(a); 7708 } 7709 7710 // CHECK-LABEL: test_vreinterpretq_s8_u16 7711 int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a) { 7712 return vreinterpretq_s8_u16(a); 7713 } 7714 7715 // CHECK-LABEL: test_vreinterpretq_s8_u32 7716 int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a) { 7717 return vreinterpretq_s8_u32(a); 7718 } 7719 7720 // CHECK-LABEL: test_vreinterpretq_s8_u64 7721 int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a) { 7722 return vreinterpretq_s8_u64(a); 7723 } 7724 7725 // CHECK-LABEL: test_vreinterpretq_s8_f16 7726 int8x16_t test_vreinterpretq_s8_f16(float16x8_t a) { 7727 return vreinterpretq_s8_f16(a); 7728 } 7729 7730 // CHECK-LABEL: test_vreinterpretq_s8_f32 7731 int8x16_t test_vreinterpretq_s8_f32(float32x4_t a) { 7732 return vreinterpretq_s8_f32(a); 7733 } 7734 7735 // CHECK-LABEL: test_vreinterpretq_s8_p8 7736 int8x16_t test_vreinterpretq_s8_p8(poly8x16_t a) { 7737 return vreinterpretq_s8_p8(a); 7738 } 7739 7740 // CHECK-LABEL: test_vreinterpretq_s8_p16 7741 int8x16_t test_vreinterpretq_s8_p16(poly16x8_t a) { 7742 return vreinterpretq_s8_p16(a); 7743 } 7744 7745 // CHECK-LABEL: test_vreinterpretq_s16_s8 7746 int16x8_t test_vreinterpretq_s16_s8(int8x16_t a) { 7747 return vreinterpretq_s16_s8(a); 7748 } 7749 7750 // CHECK-LABEL: test_vreinterpretq_s16_s32 7751 int16x8_t test_vreinterpretq_s16_s32(int32x4_t a) { 7752 return vreinterpretq_s16_s32(a); 7753 } 7754 7755 // CHECK-LABEL: test_vreinterpretq_s16_s64 7756 int16x8_t test_vreinterpretq_s16_s64(int64x2_t a) { 7757 return vreinterpretq_s16_s64(a); 7758 } 7759 7760 // CHECK-LABEL: test_vreinterpretq_s16_u8 7761 int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a) { 7762 return vreinterpretq_s16_u8(a); 7763 } 7764 7765 // CHECK-LABEL: test_vreinterpretq_s16_u16 7766 int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a) { 7767 return vreinterpretq_s16_u16(a); 7768 } 7769 7770 // CHECK-LABEL: test_vreinterpretq_s16_u32 7771 int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a) { 7772 return vreinterpretq_s16_u32(a); 7773 } 7774 7775 // CHECK-LABEL: test_vreinterpretq_s16_u64 7776 int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a) { 7777 return vreinterpretq_s16_u64(a); 7778 } 7779 7780 // CHECK-LABEL: test_vreinterpretq_s16_f16 7781 int16x8_t test_vreinterpretq_s16_f16(float16x8_t a) { 7782 return vreinterpretq_s16_f16(a); 7783 } 7784 7785 // CHECK-LABEL: test_vreinterpretq_s16_f32 7786 int16x8_t test_vreinterpretq_s16_f32(float32x4_t a) { 7787 return vreinterpretq_s16_f32(a); 7788 } 7789 7790 // CHECK-LABEL: test_vreinterpretq_s16_p8 7791 int16x8_t test_vreinterpretq_s16_p8(poly8x16_t a) { 7792 return vreinterpretq_s16_p8(a); 7793 } 7794 7795 // CHECK-LABEL: test_vreinterpretq_s16_p16 7796 int16x8_t test_vreinterpretq_s16_p16(poly16x8_t a) { 7797 return vreinterpretq_s16_p16(a); 7798 } 7799 7800 // CHECK-LABEL: test_vreinterpretq_s32_s8 7801 int32x4_t test_vreinterpretq_s32_s8(int8x16_t a) { 7802 return vreinterpretq_s32_s8(a); 7803 } 7804 7805 // CHECK-LABEL: test_vreinterpretq_s32_s16 7806 int32x4_t test_vreinterpretq_s32_s16(int16x8_t a) { 7807 return vreinterpretq_s32_s16(a); 7808 } 7809 7810 // CHECK-LABEL: test_vreinterpretq_s32_s64 7811 int32x4_t test_vreinterpretq_s32_s64(int64x2_t a) { 7812 return vreinterpretq_s32_s64(a); 7813 } 7814 7815 // CHECK-LABEL: test_vreinterpretq_s32_u8 7816 int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a) { 7817 return vreinterpretq_s32_u8(a); 7818 } 7819 7820 // CHECK-LABEL: test_vreinterpretq_s32_u16 7821 int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a) { 7822 return vreinterpretq_s32_u16(a); 7823 } 7824 7825 // CHECK-LABEL: test_vreinterpretq_s32_u32 7826 int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a) { 7827 return vreinterpretq_s32_u32(a); 7828 } 7829 7830 // CHECK-LABEL: test_vreinterpretq_s32_u64 7831 int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a) { 7832 return vreinterpretq_s32_u64(a); 7833 } 7834 7835 // CHECK-LABEL: test_vreinterpretq_s32_f16 7836 int32x4_t test_vreinterpretq_s32_f16(float16x8_t a) { 7837 return vreinterpretq_s32_f16(a); 7838 } 7839 7840 // CHECK-LABEL: test_vreinterpretq_s32_f32 7841 int32x4_t test_vreinterpretq_s32_f32(float32x4_t a) { 7842 return vreinterpretq_s32_f32(a); 7843 } 7844 7845 // CHECK-LABEL: test_vreinterpretq_s32_p8 7846 int32x4_t test_vreinterpretq_s32_p8(poly8x16_t a) { 7847 return vreinterpretq_s32_p8(a); 7848 } 7849 7850 // CHECK-LABEL: test_vreinterpretq_s32_p16 7851 int32x4_t test_vreinterpretq_s32_p16(poly16x8_t a) { 7852 return vreinterpretq_s32_p16(a); 7853 } 7854 7855 // CHECK-LABEL: test_vreinterpretq_s64_s8 7856 int64x2_t test_vreinterpretq_s64_s8(int8x16_t a) { 7857 return vreinterpretq_s64_s8(a); 7858 } 7859 7860 // CHECK-LABEL: test_vreinterpretq_s64_s16 7861 int64x2_t test_vreinterpretq_s64_s16(int16x8_t a) { 7862 return vreinterpretq_s64_s16(a); 7863 } 7864 7865 // CHECK-LABEL: test_vreinterpretq_s64_s32 7866 int64x2_t test_vreinterpretq_s64_s32(int32x4_t a) { 7867 return vreinterpretq_s64_s32(a); 7868 } 7869 7870 // CHECK-LABEL: test_vreinterpretq_s64_u8 7871 int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a) { 7872 return vreinterpretq_s64_u8(a); 7873 } 7874 7875 // CHECK-LABEL: test_vreinterpretq_s64_u16 7876 int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a) { 7877 return vreinterpretq_s64_u16(a); 7878 } 7879 7880 // CHECK-LABEL: test_vreinterpretq_s64_u32 7881 int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a) { 7882 return vreinterpretq_s64_u32(a); 7883 } 7884 7885 // CHECK-LABEL: test_vreinterpretq_s64_u64 7886 int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a) { 7887 return vreinterpretq_s64_u64(a); 7888 } 7889 7890 // CHECK-LABEL: test_vreinterpretq_s64_f16 7891 int64x2_t test_vreinterpretq_s64_f16(float16x8_t a) { 7892 return vreinterpretq_s64_f16(a); 7893 } 7894 7895 // CHECK-LABEL: test_vreinterpretq_s64_f32 7896 int64x2_t test_vreinterpretq_s64_f32(float32x4_t a) { 7897 return vreinterpretq_s64_f32(a); 7898 } 7899 7900 // CHECK-LABEL: test_vreinterpretq_s64_p8 7901 int64x2_t test_vreinterpretq_s64_p8(poly8x16_t a) { 7902 return vreinterpretq_s64_p8(a); 7903 } 7904 7905 // CHECK-LABEL: test_vreinterpretq_s64_p16 7906 int64x2_t test_vreinterpretq_s64_p16(poly16x8_t a) { 7907 return vreinterpretq_s64_p16(a); 7908 } 7909 7910 // CHECK-LABEL: test_vreinterpretq_u8_s8 7911 uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a) { 7912 return vreinterpretq_u8_s8(a); 7913 } 7914 7915 // CHECK-LABEL: test_vreinterpretq_u8_s16 7916 uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a) { 7917 return vreinterpretq_u8_s16(a); 7918 } 7919 7920 // CHECK-LABEL: test_vreinterpretq_u8_s32 7921 uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a) { 7922 return vreinterpretq_u8_s32(a); 7923 } 7924 7925 // CHECK-LABEL: test_vreinterpretq_u8_s64 7926 uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a) { 7927 return vreinterpretq_u8_s64(a); 7928 } 7929 7930 // CHECK-LABEL: test_vreinterpretq_u8_u16 7931 uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a) { 7932 return vreinterpretq_u8_u16(a); 7933 } 7934 7935 // CHECK-LABEL: test_vreinterpretq_u8_u32 7936 uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a) { 7937 return vreinterpretq_u8_u32(a); 7938 } 7939 7940 // CHECK-LABEL: test_vreinterpretq_u8_u64 7941 uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a) { 7942 return vreinterpretq_u8_u64(a); 7943 } 7944 7945 // CHECK-LABEL: test_vreinterpretq_u8_f16 7946 uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a) { 7947 return vreinterpretq_u8_f16(a); 7948 } 7949 7950 // CHECK-LABEL: test_vreinterpretq_u8_f32 7951 uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a) { 7952 return vreinterpretq_u8_f32(a); 7953 } 7954 7955 // CHECK-LABEL: test_vreinterpretq_u8_p8 7956 uint8x16_t test_vreinterpretq_u8_p8(poly8x16_t a) { 7957 return vreinterpretq_u8_p8(a); 7958 } 7959 7960 // CHECK-LABEL: test_vreinterpretq_u8_p16 7961 uint8x16_t test_vreinterpretq_u8_p16(poly16x8_t a) { 7962 return vreinterpretq_u8_p16(a); 7963 } 7964 7965 // CHECK-LABEL: test_vreinterpretq_u16_s8 7966 uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a) { 7967 return vreinterpretq_u16_s8(a); 7968 } 7969 7970 // CHECK-LABEL: test_vreinterpretq_u16_s16 7971 uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a) { 7972 return vreinterpretq_u16_s16(a); 7973 } 7974 7975 // CHECK-LABEL: test_vreinterpretq_u16_s32 7976 uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a) { 7977 return vreinterpretq_u16_s32(a); 7978 } 7979 7980 // CHECK-LABEL: test_vreinterpretq_u16_s64 7981 uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a) { 7982 return vreinterpretq_u16_s64(a); 7983 } 7984 7985 // CHECK-LABEL: test_vreinterpretq_u16_u8 7986 uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a) { 7987 return vreinterpretq_u16_u8(a); 7988 } 7989 7990 // CHECK-LABEL: test_vreinterpretq_u16_u32 7991 uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a) { 7992 return vreinterpretq_u16_u32(a); 7993 } 7994 7995 // CHECK-LABEL: test_vreinterpretq_u16_u64 7996 uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a) { 7997 return vreinterpretq_u16_u64(a); 7998 } 7999 8000 // CHECK-LABEL: test_vreinterpretq_u16_f16 8001 uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a) { 8002 return vreinterpretq_u16_f16(a); 8003 } 8004 8005 // CHECK-LABEL: test_vreinterpretq_u16_f32 8006 uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a) { 8007 return vreinterpretq_u16_f32(a); 8008 } 8009 8010 // CHECK-LABEL: test_vreinterpretq_u16_p8 8011 uint16x8_t test_vreinterpretq_u16_p8(poly8x16_t a) { 8012 return vreinterpretq_u16_p8(a); 8013 } 8014 8015 // CHECK-LABEL: test_vreinterpretq_u16_p16 8016 uint16x8_t test_vreinterpretq_u16_p16(poly16x8_t a) { 8017 return vreinterpretq_u16_p16(a); 8018 } 8019 8020 // CHECK-LABEL: test_vreinterpretq_u32_s8 8021 uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a) { 8022 return vreinterpretq_u32_s8(a); 8023 } 8024 8025 // CHECK-LABEL: test_vreinterpretq_u32_s16 8026 uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a) { 8027 return vreinterpretq_u32_s16(a); 8028 } 8029 8030 // CHECK-LABEL: test_vreinterpretq_u32_s32 8031 uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a) { 8032 return vreinterpretq_u32_s32(a); 8033 } 8034 8035 // CHECK-LABEL: test_vreinterpretq_u32_s64 8036 uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a) { 8037 return vreinterpretq_u32_s64(a); 8038 } 8039 8040 // CHECK-LABEL: test_vreinterpretq_u32_u8 8041 uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a) { 8042 return vreinterpretq_u32_u8(a); 8043 } 8044 8045 // CHECK-LABEL: test_vreinterpretq_u32_u16 8046 uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a) { 8047 return vreinterpretq_u32_u16(a); 8048 } 8049 8050 // CHECK-LABEL: test_vreinterpretq_u32_u64 8051 uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a) { 8052 return vreinterpretq_u32_u64(a); 8053 } 8054 8055 // CHECK-LABEL: test_vreinterpretq_u32_f16 8056 uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a) { 8057 return vreinterpretq_u32_f16(a); 8058 } 8059 8060 // CHECK-LABEL: test_vreinterpretq_u32_f32 8061 uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a) { 8062 return vreinterpretq_u32_f32(a); 8063 } 8064 8065 // CHECK-LABEL: test_vreinterpretq_u32_p8 8066 uint32x4_t test_vreinterpretq_u32_p8(poly8x16_t a) { 8067 return vreinterpretq_u32_p8(a); 8068 } 8069 8070 // CHECK-LABEL: test_vreinterpretq_u32_p16 8071 uint32x4_t test_vreinterpretq_u32_p16(poly16x8_t a) { 8072 return vreinterpretq_u32_p16(a); 8073 } 8074 8075 // CHECK-LABEL: test_vreinterpretq_u64_s8 8076 uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a) { 8077 return vreinterpretq_u64_s8(a); 8078 } 8079 8080 // CHECK-LABEL: test_vreinterpretq_u64_s16 8081 uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a) { 8082 return vreinterpretq_u64_s16(a); 8083 } 8084 8085 // CHECK-LABEL: test_vreinterpretq_u64_s32 8086 uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a) { 8087 return vreinterpretq_u64_s32(a); 8088 } 8089 8090 // CHECK-LABEL: test_vreinterpretq_u64_s64 8091 uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a) { 8092 return vreinterpretq_u64_s64(a); 8093 } 8094 8095 // CHECK-LABEL: test_vreinterpretq_u64_u8 8096 uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a) { 8097 return vreinterpretq_u64_u8(a); 8098 } 8099 8100 // CHECK-LABEL: test_vreinterpretq_u64_u16 8101 uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a) { 8102 return vreinterpretq_u64_u16(a); 8103 } 8104 8105 // CHECK-LABEL: test_vreinterpretq_u64_u32 8106 uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a) { 8107 return vreinterpretq_u64_u32(a); 8108 } 8109 8110 // CHECK-LABEL: test_vreinterpretq_u64_f16 8111 uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a) { 8112 return vreinterpretq_u64_f16(a); 8113 } 8114 8115 // CHECK-LABEL: test_vreinterpretq_u64_f32 8116 uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a) { 8117 return vreinterpretq_u64_f32(a); 8118 } 8119 8120 // CHECK-LABEL: test_vreinterpretq_u64_p8 8121 uint64x2_t test_vreinterpretq_u64_p8(poly8x16_t a) { 8122 return vreinterpretq_u64_p8(a); 8123 } 8124 8125 // CHECK-LABEL: test_vreinterpretq_u64_p16 8126 uint64x2_t test_vreinterpretq_u64_p16(poly16x8_t a) { 8127 return vreinterpretq_u64_p16(a); 8128 } 8129 8130 // CHECK-LABEL: test_vreinterpretq_f16_s8 8131 float16x8_t test_vreinterpretq_f16_s8(int8x16_t a) { 8132 return vreinterpretq_f16_s8(a); 8133 } 8134 8135 // CHECK-LABEL: test_vreinterpretq_f16_s16 8136 float16x8_t test_vreinterpretq_f16_s16(int16x8_t a) { 8137 return vreinterpretq_f16_s16(a); 8138 } 8139 8140 // CHECK-LABEL: test_vreinterpretq_f16_s32 8141 float16x8_t test_vreinterpretq_f16_s32(int32x4_t a) { 8142 return vreinterpretq_f16_s32(a); 8143 } 8144 8145 // CHECK-LABEL: test_vreinterpretq_f16_s64 8146 float16x8_t test_vreinterpretq_f16_s64(int64x2_t a) { 8147 return vreinterpretq_f16_s64(a); 8148 } 8149 8150 // CHECK-LABEL: test_vreinterpretq_f16_u8 8151 float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a) { 8152 return vreinterpretq_f16_u8(a); 8153 } 8154 8155 // CHECK-LABEL: test_vreinterpretq_f16_u16 8156 float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a) { 8157 return vreinterpretq_f16_u16(a); 8158 } 8159 8160 // CHECK-LABEL: test_vreinterpretq_f16_u32 8161 float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a) { 8162 return vreinterpretq_f16_u32(a); 8163 } 8164 8165 // CHECK-LABEL: test_vreinterpretq_f16_u64 8166 float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a) { 8167 return vreinterpretq_f16_u64(a); 8168 } 8169 8170 // CHECK-LABEL: test_vreinterpretq_f16_f32 8171 float16x8_t test_vreinterpretq_f16_f32(float32x4_t a) { 8172 return vreinterpretq_f16_f32(a); 8173 } 8174 8175 // CHECK-LABEL: test_vreinterpretq_f16_p8 8176 float16x8_t test_vreinterpretq_f16_p8(poly8x16_t a) { 8177 return vreinterpretq_f16_p8(a); 8178 } 8179 8180 // CHECK-LABEL: test_vreinterpretq_f16_p16 8181 float16x8_t test_vreinterpretq_f16_p16(poly16x8_t a) { 8182 return vreinterpretq_f16_p16(a); 8183 } 8184 8185 // CHECK-LABEL: test_vreinterpretq_f32_s8 8186 float32x4_t test_vreinterpretq_f32_s8(int8x16_t a) { 8187 return vreinterpretq_f32_s8(a); 8188 } 8189 8190 // CHECK-LABEL: test_vreinterpretq_f32_s16 8191 float32x4_t test_vreinterpretq_f32_s16(int16x8_t a) { 8192 return vreinterpretq_f32_s16(a); 8193 } 8194 8195 // CHECK-LABEL: test_vreinterpretq_f32_s32 8196 float32x4_t test_vreinterpretq_f32_s32(int32x4_t a) { 8197 return vreinterpretq_f32_s32(a); 8198 } 8199 8200 // CHECK-LABEL: test_vreinterpretq_f32_s64 8201 float32x4_t test_vreinterpretq_f32_s64(int64x2_t a) { 8202 return vreinterpretq_f32_s64(a); 8203 } 8204 8205 // CHECK-LABEL: test_vreinterpretq_f32_u8 8206 float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a) { 8207 return vreinterpretq_f32_u8(a); 8208 } 8209 8210 // CHECK-LABEL: test_vreinterpretq_f32_u16 8211 float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a) { 8212 return vreinterpretq_f32_u16(a); 8213 } 8214 8215 // CHECK-LABEL: test_vreinterpretq_f32_u32 8216 float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a) { 8217 return vreinterpretq_f32_u32(a); 8218 } 8219 8220 // CHECK-LABEL: test_vreinterpretq_f32_u64 8221 float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a) { 8222 return vreinterpretq_f32_u64(a); 8223 } 8224 8225 // CHECK-LABEL: test_vreinterpretq_f32_f16 8226 float32x4_t test_vreinterpretq_f32_f16(float16x8_t a) { 8227 return vreinterpretq_f32_f16(a); 8228 } 8229 8230 // CHECK-LABEL: test_vreinterpretq_f32_p8 8231 float32x4_t test_vreinterpretq_f32_p8(poly8x16_t a) { 8232 return vreinterpretq_f32_p8(a); 8233 } 8234 8235 // CHECK-LABEL: test_vreinterpretq_f32_p16 8236 float32x4_t test_vreinterpretq_f32_p16(poly16x8_t a) { 8237 return vreinterpretq_f32_p16(a); 8238 } 8239 8240 // CHECK-LABEL: test_vreinterpretq_p8_s8 8241 poly8x16_t test_vreinterpretq_p8_s8(int8x16_t a) { 8242 return vreinterpretq_p8_s8(a); 8243 } 8244 8245 // CHECK-LABEL: test_vreinterpretq_p8_s16 8246 poly8x16_t test_vreinterpretq_p8_s16(int16x8_t a) { 8247 return vreinterpretq_p8_s16(a); 8248 } 8249 8250 // CHECK-LABEL: test_vreinterpretq_p8_s32 8251 poly8x16_t test_vreinterpretq_p8_s32(int32x4_t a) { 8252 return vreinterpretq_p8_s32(a); 8253 } 8254 8255 // CHECK-LABEL: test_vreinterpretq_p8_s64 8256 poly8x16_t test_vreinterpretq_p8_s64(int64x2_t a) { 8257 return vreinterpretq_p8_s64(a); 8258 } 8259 8260 // CHECK-LABEL: test_vreinterpretq_p8_u8 8261 poly8x16_t test_vreinterpretq_p8_u8(uint8x16_t a) { 8262 return vreinterpretq_p8_u8(a); 8263 } 8264 8265 // CHECK-LABEL: test_vreinterpretq_p8_u16 8266 poly8x16_t test_vreinterpretq_p8_u16(uint16x8_t a) { 8267 return vreinterpretq_p8_u16(a); 8268 } 8269 8270 // CHECK-LABEL: test_vreinterpretq_p8_u32 8271 poly8x16_t test_vreinterpretq_p8_u32(uint32x4_t a) { 8272 return vreinterpretq_p8_u32(a); 8273 } 8274 8275 // CHECK-LABEL: test_vreinterpretq_p8_u64 8276 poly8x16_t test_vreinterpretq_p8_u64(uint64x2_t a) { 8277 return vreinterpretq_p8_u64(a); 8278 } 8279 8280 // CHECK-LABEL: test_vreinterpretq_p8_f16 8281 poly8x16_t test_vreinterpretq_p8_f16(float16x8_t a) { 8282 return vreinterpretq_p8_f16(a); 8283 } 8284 8285 // CHECK-LABEL: test_vreinterpretq_p8_f32 8286 poly8x16_t test_vreinterpretq_p8_f32(float32x4_t a) { 8287 return vreinterpretq_p8_f32(a); 8288 } 8289 8290 // CHECK-LABEL: test_vreinterpretq_p8_p16 8291 poly8x16_t test_vreinterpretq_p8_p16(poly16x8_t a) { 8292 return vreinterpretq_p8_p16(a); 8293 } 8294 8295 // CHECK-LABEL: test_vreinterpretq_p16_s8 8296 poly16x8_t test_vreinterpretq_p16_s8(int8x16_t a) { 8297 return vreinterpretq_p16_s8(a); 8298 } 8299 8300 // CHECK-LABEL: test_vreinterpretq_p16_s16 8301 poly16x8_t test_vreinterpretq_p16_s16(int16x8_t a) { 8302 return vreinterpretq_p16_s16(a); 8303 } 8304 8305 // CHECK-LABEL: test_vreinterpretq_p16_s32 8306 poly16x8_t test_vreinterpretq_p16_s32(int32x4_t a) { 8307 return vreinterpretq_p16_s32(a); 8308 } 8309 8310 // CHECK-LABEL: test_vreinterpretq_p16_s64 8311 poly16x8_t test_vreinterpretq_p16_s64(int64x2_t a) { 8312 return vreinterpretq_p16_s64(a); 8313 } 8314 8315 // CHECK-LABEL: test_vreinterpretq_p16_u8 8316 poly16x8_t test_vreinterpretq_p16_u8(uint8x16_t a) { 8317 return vreinterpretq_p16_u8(a); 8318 } 8319 8320 // CHECK-LABEL: test_vreinterpretq_p16_u16 8321 poly16x8_t test_vreinterpretq_p16_u16(uint16x8_t a) { 8322 return vreinterpretq_p16_u16(a); 8323 } 8324 8325 // CHECK-LABEL: test_vreinterpretq_p16_u32 8326 poly16x8_t test_vreinterpretq_p16_u32(uint32x4_t a) { 8327 return vreinterpretq_p16_u32(a); 8328 } 8329 8330 // CHECK-LABEL: test_vreinterpretq_p16_u64 8331 poly16x8_t test_vreinterpretq_p16_u64(uint64x2_t a) { 8332 return vreinterpretq_p16_u64(a); 8333 } 8334 8335 // CHECK-LABEL: test_vreinterpretq_p16_f16 8336 poly16x8_t test_vreinterpretq_p16_f16(float16x8_t a) { 8337 return vreinterpretq_p16_f16(a); 8338 } 8339 8340 // CHECK-LABEL: test_vreinterpretq_p16_f32 8341 poly16x8_t test_vreinterpretq_p16_f32(float32x4_t a) { 8342 return vreinterpretq_p16_f32(a); 8343 } 8344 8345 // CHECK-LABEL: test_vreinterpretq_p16_p8 8346 poly16x8_t test_vreinterpretq_p16_p8(poly8x16_t a) { 8347 return vreinterpretq_p16_p8(a); 8348 } 8349 8350 8351 // CHECK-LABEL: test_vrev16_s8 8352 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8353 int8x8_t test_vrev16_s8(int8x8_t a) { 8354 return vrev16_s8(a); 8355 } 8356 8357 // CHECK-LABEL: test_vrev16_u8 8358 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8359 uint8x8_t test_vrev16_u8(uint8x8_t a) { 8360 return vrev16_u8(a); 8361 } 8362 8363 // CHECK-LABEL: test_vrev16_p8 8364 // CHECK: vrev16.8 d{{[0-9]+}}, d{{[0-9]+}} 8365 poly8x8_t test_vrev16_p8(poly8x8_t a) { 8366 return vrev16_p8(a); 8367 } 8368 8369 // CHECK-LABEL: test_vrev16q_s8 8370 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8371 int8x16_t test_vrev16q_s8(int8x16_t a) { 8372 return vrev16q_s8(a); 8373 } 8374 8375 // CHECK-LABEL: test_vrev16q_u8 8376 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8377 uint8x16_t test_vrev16q_u8(uint8x16_t a) { 8378 return vrev16q_u8(a); 8379 } 8380 8381 // CHECK-LABEL: test_vrev16q_p8 8382 // CHECK: vrev16.8 q{{[0-9]+}}, q{{[0-9]+}} 8383 poly8x16_t test_vrev16q_p8(poly8x16_t a) { 8384 return vrev16q_p8(a); 8385 } 8386 8387 8388 // CHECK-LABEL: test_vrev32_s8 8389 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8390 int8x8_t test_vrev32_s8(int8x8_t a) { 8391 return vrev32_s8(a); 8392 } 8393 8394 // CHECK-LABEL: test_vrev32_s16 8395 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8396 int16x4_t test_vrev32_s16(int16x4_t a) { 8397 return vrev32_s16(a); 8398 } 8399 8400 // CHECK-LABEL: test_vrev32_u8 8401 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8402 uint8x8_t test_vrev32_u8(uint8x8_t a) { 8403 return vrev32_u8(a); 8404 } 8405 8406 // CHECK-LABEL: test_vrev32_u16 8407 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8408 uint16x4_t test_vrev32_u16(uint16x4_t a) { 8409 return vrev32_u16(a); 8410 } 8411 8412 // CHECK-LABEL: test_vrev32_p8 8413 // CHECK: vrev32.8 d{{[0-9]+}}, d{{[0-9]+}} 8414 poly8x8_t test_vrev32_p8(poly8x8_t a) { 8415 return vrev32_p8(a); 8416 } 8417 8418 // CHECK-LABEL: test_vrev32_p16 8419 // CHECK: vrev32.16 d{{[0-9]+}}, d{{[0-9]+}} 8420 poly16x4_t test_vrev32_p16(poly16x4_t a) { 8421 return vrev32_p16(a); 8422 } 8423 8424 // CHECK-LABEL: test_vrev32q_s8 8425 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8426 int8x16_t test_vrev32q_s8(int8x16_t a) { 8427 return vrev32q_s8(a); 8428 } 8429 8430 // CHECK-LABEL: test_vrev32q_s16 8431 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8432 int16x8_t test_vrev32q_s16(int16x8_t a) { 8433 return vrev32q_s16(a); 8434 } 8435 8436 // CHECK-LABEL: test_vrev32q_u8 8437 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8438 uint8x16_t test_vrev32q_u8(uint8x16_t a) { 8439 return vrev32q_u8(a); 8440 } 8441 8442 // CHECK-LABEL: test_vrev32q_u16 8443 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8444 uint16x8_t test_vrev32q_u16(uint16x8_t a) { 8445 return vrev32q_u16(a); 8446 } 8447 8448 // CHECK-LABEL: test_vrev32q_p8 8449 // CHECK: vrev32.8 q{{[0-9]+}}, q{{[0-9]+}} 8450 poly8x16_t test_vrev32q_p8(poly8x16_t a) { 8451 return vrev32q_p8(a); 8452 } 8453 8454 // CHECK-LABEL: test_vrev32q_p16 8455 // CHECK: vrev32.16 q{{[0-9]+}}, q{{[0-9]+}} 8456 poly16x8_t test_vrev32q_p16(poly16x8_t a) { 8457 return vrev32q_p16(a); 8458 } 8459 8460 8461 // CHECK-LABEL: test_vrev64_s8 8462 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8463 int8x8_t test_vrev64_s8(int8x8_t a) { 8464 return vrev64_s8(a); 8465 } 8466 8467 // CHECK-LABEL: test_vrev64_s16 8468 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8469 int16x4_t test_vrev64_s16(int16x4_t a) { 8470 return vrev64_s16(a); 8471 } 8472 8473 // CHECK-LABEL: test_vrev64_s32 8474 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8475 int32x2_t test_vrev64_s32(int32x2_t a) { 8476 return vrev64_s32(a); 8477 } 8478 8479 // CHECK-LABEL: test_vrev64_u8 8480 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8481 uint8x8_t test_vrev64_u8(uint8x8_t a) { 8482 return vrev64_u8(a); 8483 } 8484 8485 // CHECK-LABEL: test_vrev64_u16 8486 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8487 uint16x4_t test_vrev64_u16(uint16x4_t a) { 8488 return vrev64_u16(a); 8489 } 8490 8491 // CHECK-LABEL: test_vrev64_u32 8492 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8493 uint32x2_t test_vrev64_u32(uint32x2_t a) { 8494 return vrev64_u32(a); 8495 } 8496 8497 // CHECK-LABEL: test_vrev64_p8 8498 // CHECK: vrev64.8 d{{[0-9]+}}, d{{[0-9]+}} 8499 poly8x8_t test_vrev64_p8(poly8x8_t a) { 8500 return vrev64_p8(a); 8501 } 8502 8503 // CHECK-LABEL: test_vrev64_p16 8504 // CHECK: vrev64.16 d{{[0-9]+}}, d{{[0-9]+}} 8505 poly16x4_t test_vrev64_p16(poly16x4_t a) { 8506 return vrev64_p16(a); 8507 } 8508 8509 // CHECK-LABEL: test_vrev64_f32 8510 // CHECK: vrev64.32 d{{[0-9]+}}, d{{[0-9]+}} 8511 float32x2_t test_vrev64_f32(float32x2_t a) { 8512 return vrev64_f32(a); 8513 } 8514 8515 // CHECK-LABEL: test_vrev64q_s8 8516 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8517 int8x16_t test_vrev64q_s8(int8x16_t a) { 8518 return vrev64q_s8(a); 8519 } 8520 8521 // CHECK-LABEL: test_vrev64q_s16 8522 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8523 int16x8_t test_vrev64q_s16(int16x8_t a) { 8524 return vrev64q_s16(a); 8525 } 8526 8527 // CHECK-LABEL: test_vrev64q_s32 8528 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8529 int32x4_t test_vrev64q_s32(int32x4_t a) { 8530 return vrev64q_s32(a); 8531 } 8532 8533 // CHECK-LABEL: test_vrev64q_u8 8534 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8535 uint8x16_t test_vrev64q_u8(uint8x16_t a) { 8536 return vrev64q_u8(a); 8537 } 8538 8539 // CHECK-LABEL: test_vrev64q_u16 8540 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8541 uint16x8_t test_vrev64q_u16(uint16x8_t a) { 8542 return vrev64q_u16(a); 8543 } 8544 8545 // CHECK-LABEL: test_vrev64q_u32 8546 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8547 uint32x4_t test_vrev64q_u32(uint32x4_t a) { 8548 return vrev64q_u32(a); 8549 } 8550 8551 // CHECK-LABEL: test_vrev64q_p8 8552 // CHECK: vrev64.8 q{{[0-9]+}}, q{{[0-9]+}} 8553 poly8x16_t test_vrev64q_p8(poly8x16_t a) { 8554 return vrev64q_p8(a); 8555 } 8556 8557 // CHECK-LABEL: test_vrev64q_p16 8558 // CHECK: vrev64.16 q{{[0-9]+}}, q{{[0-9]+}} 8559 poly16x8_t test_vrev64q_p16(poly16x8_t a) { 8560 return vrev64q_p16(a); 8561 } 8562 8563 // CHECK-LABEL: test_vrev64q_f32 8564 // CHECK: vrev64.32 q{{[0-9]+}}, q{{[0-9]+}} 8565 float32x4_t test_vrev64q_f32(float32x4_t a) { 8566 return vrev64q_f32(a); 8567 } 8568 8569 8570 // CHECK-LABEL: test_vrhadd_s8 8571 // CHECK: vrhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8572 int8x8_t test_vrhadd_s8(int8x8_t a, int8x8_t b) { 8573 return vrhadd_s8(a, b); 8574 } 8575 8576 // CHECK-LABEL: test_vrhadd_s16 8577 // CHECK: vrhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8578 int16x4_t test_vrhadd_s16(int16x4_t a, int16x4_t b) { 8579 return vrhadd_s16(a, b); 8580 } 8581 8582 // CHECK-LABEL: test_vrhadd_s32 8583 // CHECK: vrhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8584 int32x2_t test_vrhadd_s32(int32x2_t a, int32x2_t b) { 8585 return vrhadd_s32(a, b); 8586 } 8587 8588 // CHECK-LABEL: test_vrhadd_u8 8589 // CHECK: vrhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8590 uint8x8_t test_vrhadd_u8(uint8x8_t a, uint8x8_t b) { 8591 return vrhadd_u8(a, b); 8592 } 8593 8594 // CHECK-LABEL: test_vrhadd_u16 8595 // CHECK: vrhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8596 uint16x4_t test_vrhadd_u16(uint16x4_t a, uint16x4_t b) { 8597 return vrhadd_u16(a, b); 8598 } 8599 8600 // CHECK-LABEL: test_vrhadd_u32 8601 // CHECK: vrhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8602 uint32x2_t test_vrhadd_u32(uint32x2_t a, uint32x2_t b) { 8603 return vrhadd_u32(a, b); 8604 } 8605 8606 // CHECK-LABEL: test_vrhaddq_s8 8607 // CHECK: vrhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8608 int8x16_t test_vrhaddq_s8(int8x16_t a, int8x16_t b) { 8609 return vrhaddq_s8(a, b); 8610 } 8611 8612 // CHECK-LABEL: test_vrhaddq_s16 8613 // CHECK: vrhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8614 int16x8_t test_vrhaddq_s16(int16x8_t a, int16x8_t b) { 8615 return vrhaddq_s16(a, b); 8616 } 8617 8618 // CHECK-LABEL: test_vrhaddq_s32 8619 // CHECK: vrhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8620 int32x4_t test_vrhaddq_s32(int32x4_t a, int32x4_t b) { 8621 return vrhaddq_s32(a, b); 8622 } 8623 8624 // CHECK-LABEL: test_vrhaddq_u8 8625 // CHECK: vrhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8626 uint8x16_t test_vrhaddq_u8(uint8x16_t a, uint8x16_t b) { 8627 return vrhaddq_u8(a, b); 8628 } 8629 8630 // CHECK-LABEL: test_vrhaddq_u16 8631 // CHECK: vrhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8632 uint16x8_t test_vrhaddq_u16(uint16x8_t a, uint16x8_t b) { 8633 return vrhaddq_u16(a, b); 8634 } 8635 8636 // CHECK-LABEL: test_vrhaddq_u32 8637 // CHECK: vrhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8638 uint32x4_t test_vrhaddq_u32(uint32x4_t a, uint32x4_t b) { 8639 return vrhaddq_u32(a, b); 8640 } 8641 8642 8643 // CHECK-LABEL: test_vrshl_s8 8644 // CHECK: vrshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8645 int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) { 8646 return vrshl_s8(a, b); 8647 } 8648 8649 // CHECK-LABEL: test_vrshl_s16 8650 // CHECK: vrshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8651 int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) { 8652 return vrshl_s16(a, b); 8653 } 8654 8655 // CHECK-LABEL: test_vrshl_s32 8656 // CHECK: vrshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8657 int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) { 8658 return vrshl_s32(a, b); 8659 } 8660 8661 // CHECK-LABEL: test_vrshl_s64 8662 // CHECK: vrshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8663 int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) { 8664 return vrshl_s64(a, b); 8665 } 8666 8667 // CHECK-LABEL: test_vrshl_u8 8668 // CHECK: vrshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8669 uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) { 8670 return vrshl_u8(a, b); 8671 } 8672 8673 // CHECK-LABEL: test_vrshl_u16 8674 // CHECK: vrshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8675 uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) { 8676 return vrshl_u16(a, b); 8677 } 8678 8679 // CHECK-LABEL: test_vrshl_u32 8680 // CHECK: vrshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8681 uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) { 8682 return vrshl_u32(a, b); 8683 } 8684 8685 // CHECK-LABEL: test_vrshl_u64 8686 // CHECK: vrshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8687 uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) { 8688 return vrshl_u64(a, b); 8689 } 8690 8691 // CHECK-LABEL: test_vrshlq_s8 8692 // CHECK: vrshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8693 int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) { 8694 return vrshlq_s8(a, b); 8695 } 8696 8697 // CHECK-LABEL: test_vrshlq_s16 8698 // CHECK: vrshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8699 int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) { 8700 return vrshlq_s16(a, b); 8701 } 8702 8703 // CHECK-LABEL: test_vrshlq_s32 8704 // CHECK: vrshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8705 int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) { 8706 return vrshlq_s32(a, b); 8707 } 8708 8709 // CHECK-LABEL: test_vrshlq_s64 8710 // CHECK: vrshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8711 int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) { 8712 return vrshlq_s64(a, b); 8713 } 8714 8715 // CHECK-LABEL: test_vrshlq_u8 8716 // CHECK: vrshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8717 uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) { 8718 return vrshlq_u8(a, b); 8719 } 8720 8721 // CHECK-LABEL: test_vrshlq_u16 8722 // CHECK: vrshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8723 uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) { 8724 return vrshlq_u16(a, b); 8725 } 8726 8727 // CHECK-LABEL: test_vrshlq_u32 8728 // CHECK: vrshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8729 uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) { 8730 return vrshlq_u32(a, b); 8731 } 8732 8733 // CHECK-LABEL: test_vrshlq_u64 8734 // CHECK: vrshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8735 uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) { 8736 return vrshlq_u64(a, b); 8737 } 8738 8739 8740 // CHECK-LABEL: test_vrshrn_n_s16 8741 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8742 int8x8_t test_vrshrn_n_s16(int16x8_t a) { 8743 return vrshrn_n_s16(a, 1); 8744 } 8745 8746 // CHECK-LABEL: test_vrshrn_n_s32 8747 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8748 int16x4_t test_vrshrn_n_s32(int32x4_t a) { 8749 return vrshrn_n_s32(a, 1); 8750 } 8751 8752 // CHECK-LABEL: test_vrshrn_n_s64 8753 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8754 int32x2_t test_vrshrn_n_s64(int64x2_t a) { 8755 return vrshrn_n_s64(a, 1); 8756 } 8757 8758 // CHECK-LABEL: test_vrshrn_n_u16 8759 // CHECK: vrshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8760 uint8x8_t test_vrshrn_n_u16(uint16x8_t a) { 8761 return vrshrn_n_u16(a, 1); 8762 } 8763 8764 // CHECK-LABEL: test_vrshrn_n_u32 8765 // CHECK: vrshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8766 uint16x4_t test_vrshrn_n_u32(uint32x4_t a) { 8767 return vrshrn_n_u32(a, 1); 8768 } 8769 8770 // CHECK-LABEL: test_vrshrn_n_u64 8771 // CHECK: vrshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8772 uint32x2_t test_vrshrn_n_u64(uint64x2_t a) { 8773 return vrshrn_n_u64(a, 1); 8774 } 8775 8776 8777 // CHECK-LABEL: test_vrshr_n_s8 8778 // CHECK: vrshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8779 int8x8_t test_vrshr_n_s8(int8x8_t a) { 8780 return vrshr_n_s8(a, 1); 8781 } 8782 8783 // CHECK-LABEL: test_vrshr_n_s16 8784 // CHECK: vrshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8785 int16x4_t test_vrshr_n_s16(int16x4_t a) { 8786 return vrshr_n_s16(a, 1); 8787 } 8788 8789 // CHECK-LABEL: test_vrshr_n_s32 8790 // CHECK: vrshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8791 int32x2_t test_vrshr_n_s32(int32x2_t a) { 8792 return vrshr_n_s32(a, 1); 8793 } 8794 8795 // CHECK-LABEL: test_vrshr_n_s64 8796 // CHECK: vrshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8797 int64x1_t test_vrshr_n_s64(int64x1_t a) { 8798 return vrshr_n_s64(a, 1); 8799 } 8800 8801 // CHECK-LABEL: test_vrshr_n_u8 8802 // CHECK: vrshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8803 uint8x8_t test_vrshr_n_u8(uint8x8_t a) { 8804 return vrshr_n_u8(a, 1); 8805 } 8806 8807 // CHECK-LABEL: test_vrshr_n_u16 8808 // CHECK: vrshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8809 uint16x4_t test_vrshr_n_u16(uint16x4_t a) { 8810 return vrshr_n_u16(a, 1); 8811 } 8812 8813 // CHECK-LABEL: test_vrshr_n_u32 8814 // CHECK: vrshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8815 uint32x2_t test_vrshr_n_u32(uint32x2_t a) { 8816 return vrshr_n_u32(a, 1); 8817 } 8818 8819 // CHECK-LABEL: test_vrshr_n_u64 8820 // CHECK: vrshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8821 uint64x1_t test_vrshr_n_u64(uint64x1_t a) { 8822 return vrshr_n_u64(a, 1); 8823 } 8824 8825 // CHECK-LABEL: test_vrshrq_n_s8 8826 // CHECK: vrshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8827 int8x16_t test_vrshrq_n_s8(int8x16_t a) { 8828 return vrshrq_n_s8(a, 1); 8829 } 8830 8831 // CHECK-LABEL: test_vrshrq_n_s16 8832 // CHECK: vrshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8833 int16x8_t test_vrshrq_n_s16(int16x8_t a) { 8834 return vrshrq_n_s16(a, 1); 8835 } 8836 8837 // CHECK-LABEL: test_vrshrq_n_s32 8838 // CHECK: vrshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8839 int32x4_t test_vrshrq_n_s32(int32x4_t a) { 8840 return vrshrq_n_s32(a, 1); 8841 } 8842 8843 // CHECK-LABEL: test_vrshrq_n_s64 8844 // CHECK: vrshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8845 int64x2_t test_vrshrq_n_s64(int64x2_t a) { 8846 return vrshrq_n_s64(a, 1); 8847 } 8848 8849 // CHECK-LABEL: test_vrshrq_n_u8 8850 // CHECK: vrshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8851 uint8x16_t test_vrshrq_n_u8(uint8x16_t a) { 8852 return vrshrq_n_u8(a, 1); 8853 } 8854 8855 // CHECK-LABEL: test_vrshrq_n_u16 8856 // CHECK: vrshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8857 uint16x8_t test_vrshrq_n_u16(uint16x8_t a) { 8858 return vrshrq_n_u16(a, 1); 8859 } 8860 8861 // CHECK-LABEL: test_vrshrq_n_u32 8862 // CHECK: vrshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8863 uint32x4_t test_vrshrq_n_u32(uint32x4_t a) { 8864 return vrshrq_n_u32(a, 1); 8865 } 8866 8867 // CHECK-LABEL: test_vrshrq_n_u64 8868 // CHECK: vrshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8869 uint64x2_t test_vrshrq_n_u64(uint64x2_t a) { 8870 return vrshrq_n_u64(a, 1); 8871 } 8872 8873 8874 // CHECK-LABEL: test_vrsqrte_f32 8875 // CHECK: vrsqrte.f32 d{{[0-9]+}}, d{{[0-9]+}} 8876 float32x2_t test_vrsqrte_f32(float32x2_t a) { 8877 return vrsqrte_f32(a); 8878 } 8879 8880 // CHECK-LABEL: test_vrsqrte_u32 8881 // CHECK: vrsqrte.u32 d{{[0-9]+}}, d{{[0-9]+}} 8882 uint32x2_t test_vrsqrte_u32(uint32x2_t a) { 8883 return vrsqrte_u32(a); 8884 } 8885 8886 // CHECK-LABEL: test_vrsqrteq_f32 8887 // CHECK: vrsqrte.f32 q{{[0-9]+}}, q{{[0-9]+}} 8888 float32x4_t test_vrsqrteq_f32(float32x4_t a) { 8889 return vrsqrteq_f32(a); 8890 } 8891 8892 // CHECK-LABEL: test_vrsqrteq_u32 8893 // CHECK: vrsqrte.u32 q{{[0-9]+}}, q{{[0-9]+}} 8894 uint32x4_t test_vrsqrteq_u32(uint32x4_t a) { 8895 return vrsqrteq_u32(a); 8896 } 8897 8898 8899 // CHECK-LABEL: test_vrsqrts_f32 8900 // CHECK: vrsqrts.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 8901 float32x2_t test_vrsqrts_f32(float32x2_t a, float32x2_t b) { 8902 return vrsqrts_f32(a, b); 8903 } 8904 8905 // CHECK-LABEL: test_vrsqrtsq_f32 8906 // CHECK: vrsqrts.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 8907 float32x4_t test_vrsqrtsq_f32(float32x4_t a, float32x4_t b) { 8908 return vrsqrtsq_f32(a, b); 8909 } 8910 8911 8912 // CHECK-LABEL: test_vrsra_n_s8 8913 // CHECK: vrsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8914 int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) { 8915 return vrsra_n_s8(a, b, 1); 8916 } 8917 8918 // CHECK-LABEL: test_vrsra_n_s16 8919 // CHECK: vrsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8920 int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) { 8921 return vrsra_n_s16(a, b, 1); 8922 } 8923 8924 // CHECK-LABEL: test_vrsra_n_s32 8925 // CHECK: vrsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8926 int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) { 8927 return vrsra_n_s32(a, b, 1); 8928 } 8929 8930 // CHECK-LABEL: test_vrsra_n_s64 8931 // CHECK: vrsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8932 int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) { 8933 return vrsra_n_s64(a, b, 1); 8934 } 8935 8936 // CHECK-LABEL: test_vrsra_n_u8 8937 // CHECK: vrsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8938 uint8x8_t test_vrsra_n_u8(uint8x8_t a, uint8x8_t b) { 8939 return vrsra_n_u8(a, b, 1); 8940 } 8941 8942 // CHECK-LABEL: test_vrsra_n_u16 8943 // CHECK: vrsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8944 uint16x4_t test_vrsra_n_u16(uint16x4_t a, uint16x4_t b) { 8945 return vrsra_n_u16(a, b, 1); 8946 } 8947 8948 // CHECK-LABEL: test_vrsra_n_u32 8949 // CHECK: vrsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8950 uint32x2_t test_vrsra_n_u32(uint32x2_t a, uint32x2_t b) { 8951 return vrsra_n_u32(a, b, 1); 8952 } 8953 8954 // CHECK-LABEL: test_vrsra_n_u64 8955 // CHECK: vrsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 8956 uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) { 8957 return vrsra_n_u64(a, b, 1); 8958 } 8959 8960 // CHECK-LABEL: test_vrsraq_n_s8 8961 // CHECK: vrsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8962 int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) { 8963 return vrsraq_n_s8(a, b, 1); 8964 } 8965 8966 // CHECK-LABEL: test_vrsraq_n_s16 8967 // CHECK: vrsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8968 int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) { 8969 return vrsraq_n_s16(a, b, 1); 8970 } 8971 8972 // CHECK-LABEL: test_vrsraq_n_s32 8973 // CHECK: vrsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8974 int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) { 8975 return vrsraq_n_s32(a, b, 1); 8976 } 8977 8978 // CHECK-LABEL: test_vrsraq_n_s64 8979 // CHECK: vrsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8980 int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) { 8981 return vrsraq_n_s64(a, b, 1); 8982 } 8983 8984 // CHECK-LABEL: test_vrsraq_n_u8 8985 // CHECK: vrsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8986 uint8x16_t test_vrsraq_n_u8(uint8x16_t a, uint8x16_t b) { 8987 return vrsraq_n_u8(a, b, 1); 8988 } 8989 8990 // CHECK-LABEL: test_vrsraq_n_u16 8991 // CHECK: vrsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8992 uint16x8_t test_vrsraq_n_u16(uint16x8_t a, uint16x8_t b) { 8993 return vrsraq_n_u16(a, b, 1); 8994 } 8995 8996 // CHECK-LABEL: test_vrsraq_n_u32 8997 // CHECK: vrsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 8998 uint32x4_t test_vrsraq_n_u32(uint32x4_t a, uint32x4_t b) { 8999 return vrsraq_n_u32(a, b, 1); 9000 } 9001 9002 // CHECK-LABEL: test_vrsraq_n_u64 9003 // CHECK: vrsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9004 uint64x2_t test_vrsraq_n_u64(uint64x2_t a, uint64x2_t b) { 9005 return vrsraq_n_u64(a, b, 1); 9006 } 9007 9008 9009 // CHECK-LABEL: test_vrsubhn_s16 9010 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9011 int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) { 9012 return vrsubhn_s16(a, b); 9013 } 9014 9015 // CHECK-LABEL: test_vrsubhn_s32 9016 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9017 int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) { 9018 return vrsubhn_s32(a, b); 9019 } 9020 9021 // CHECK-LABEL: test_vrsubhn_s64 9022 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9023 int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) { 9024 return vrsubhn_s64(a, b); 9025 } 9026 9027 // CHECK-LABEL: test_vrsubhn_u16 9028 // CHECK: vrsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9029 uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) { 9030 return vrsubhn_u16(a, b); 9031 } 9032 9033 // CHECK-LABEL: test_vrsubhn_u32 9034 // CHECK: vrsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9035 uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) { 9036 return vrsubhn_u32(a, b); 9037 } 9038 9039 // CHECK-LABEL: test_vrsubhn_u64 9040 // CHECK: vrsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9041 uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) { 9042 return vrsubhn_u64(a, b); 9043 } 9044 9045 9046 // CHECK-LABEL: test_vset_lane_u8 9047 // CHECK: vmov 9048 uint8x8_t test_vset_lane_u8(uint8_t a, uint8x8_t b) { 9049 return vset_lane_u8(a, b, 7); 9050 } 9051 9052 // CHECK-LABEL: test_vset_lane_u16 9053 // CHECK: vmov 9054 uint16x4_t test_vset_lane_u16(uint16_t a, uint16x4_t b) { 9055 return vset_lane_u16(a, b, 3); 9056 } 9057 9058 // CHECK-LABEL: test_vset_lane_u32 9059 // CHECK: vmov 9060 uint32x2_t test_vset_lane_u32(uint32_t a, uint32x2_t b) { 9061 return vset_lane_u32(a, b, 1); 9062 } 9063 9064 // CHECK-LABEL: test_vset_lane_s8 9065 // CHECK: vmov 9066 int8x8_t test_vset_lane_s8(int8_t a, int8x8_t b) { 9067 return vset_lane_s8(a, b, 7); 9068 } 9069 9070 // CHECK-LABEL: test_vset_lane_s16 9071 // CHECK: vmov 9072 int16x4_t test_vset_lane_s16(int16_t a, int16x4_t b) { 9073 return vset_lane_s16(a, b, 3); 9074 } 9075 9076 // CHECK-LABEL: test_vset_lane_s32 9077 // CHECK: vmov 9078 int32x2_t test_vset_lane_s32(int32_t a, int32x2_t b) { 9079 return vset_lane_s32(a, b, 1); 9080 } 9081 9082 // CHECK-LABEL: test_vset_lane_p8 9083 // CHECK: vmov 9084 poly8x8_t test_vset_lane_p8(poly8_t a, poly8x8_t b) { 9085 return vset_lane_p8(a, b, 7); 9086 } 9087 9088 // CHECK-LABEL: test_vset_lane_p16 9089 // CHECK: vmov 9090 poly16x4_t test_vset_lane_p16(poly16_t a, poly16x4_t b) { 9091 return vset_lane_p16(a, b, 3); 9092 } 9093 9094 // CHECK-LABEL: test_vset_lane_f32 9095 // CHECK: vmov 9096 float32x2_t test_vset_lane_f32(float32_t a, float32x2_t b) { 9097 return vset_lane_f32(a, b, 1); 9098 } 9099 9100 // CHECK-LABEL: test_vsetq_lane_u8 9101 // CHECK: vmov 9102 uint8x16_t test_vsetq_lane_u8(uint8_t a, uint8x16_t b) { 9103 return vsetq_lane_u8(a, b, 15); 9104 } 9105 9106 // CHECK-LABEL: test_vsetq_lane_u16 9107 // CHECK: vmov 9108 uint16x8_t test_vsetq_lane_u16(uint16_t a, uint16x8_t b) { 9109 return vsetq_lane_u16(a, b, 7); 9110 } 9111 9112 // CHECK-LABEL: test_vsetq_lane_u32 9113 // CHECK: vmov 9114 uint32x4_t test_vsetq_lane_u32(uint32_t a, uint32x4_t b) { 9115 return vsetq_lane_u32(a, b, 3); 9116 } 9117 9118 // CHECK-LABEL: test_vsetq_lane_s8 9119 // CHECK: vmov 9120 int8x16_t test_vsetq_lane_s8(int8_t a, int8x16_t b) { 9121 return vsetq_lane_s8(a, b, 15); 9122 } 9123 9124 // CHECK-LABEL: test_vsetq_lane_s16 9125 // CHECK: vmov 9126 int16x8_t test_vsetq_lane_s16(int16_t a, int16x8_t b) { 9127 return vsetq_lane_s16(a, b, 7); 9128 } 9129 9130 // CHECK-LABEL: test_vsetq_lane_s32 9131 // CHECK: vmov 9132 int32x4_t test_vsetq_lane_s32(int32_t a, int32x4_t b) { 9133 return vsetq_lane_s32(a, b, 3); 9134 } 9135 9136 // CHECK-LABEL: test_vsetq_lane_p8 9137 // CHECK: vmov 9138 poly8x16_t test_vsetq_lane_p8(poly8_t a, poly8x16_t b) { 9139 return vsetq_lane_p8(a, b, 15); 9140 } 9141 9142 // CHECK-LABEL: test_vsetq_lane_p16 9143 // CHECK: vmov 9144 poly16x8_t test_vsetq_lane_p16(poly16_t a, poly16x8_t b) { 9145 return vsetq_lane_p16(a, b, 7); 9146 } 9147 9148 // CHECK-LABEL: test_vsetq_lane_f32 9149 // CHECK: vmov 9150 float32x4_t test_vsetq_lane_f32(float32_t a, float32x4_t b) { 9151 return vsetq_lane_f32(a, b, 3); 9152 } 9153 9154 // CHECK-LABEL: test_vset_lane_s64 9155 // CHECK: vmov 9156 int64x1_t test_vset_lane_s64(int64_t a, int64x1_t b) { 9157 return vset_lane_s64(a, b, 0); 9158 } 9159 9160 // CHECK-LABEL: test_vset_lane_u64 9161 // CHECK: vmov 9162 uint64x1_t test_vset_lane_u64(uint64_t a, uint64x1_t b) { 9163 return vset_lane_u64(a, b, 0); 9164 } 9165 9166 // CHECK-LABEL: test_vsetq_lane_s64 9167 // CHECK: vmov 9168 int64x2_t test_vsetq_lane_s64(int64_t a, int64x2_t b) { 9169 return vsetq_lane_s64(a, b, 1); 9170 } 9171 9172 // CHECK-LABEL: test_vsetq_lane_u64 9173 // CHECK: vmov 9174 uint64x2_t test_vsetq_lane_u64(uint64_t a, uint64x2_t b) { 9175 return vsetq_lane_u64(a, b, 1); 9176 } 9177 9178 9179 // CHECK-LABEL: test_vshl_s8 9180 // CHECK: vshl.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9181 int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) { 9182 return vshl_s8(a, b); 9183 } 9184 9185 // CHECK-LABEL: test_vshl_s16 9186 // CHECK: vshl.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9187 int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) { 9188 return vshl_s16(a, b); 9189 } 9190 9191 // CHECK-LABEL: test_vshl_s32 9192 // CHECK: vshl.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9193 int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) { 9194 return vshl_s32(a, b); 9195 } 9196 9197 // CHECK-LABEL: test_vshl_s64 9198 // CHECK: vshl.s64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9199 int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) { 9200 return vshl_s64(a, b); 9201 } 9202 9203 // CHECK-LABEL: test_vshl_u8 9204 // CHECK: vshl.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9205 uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) { 9206 return vshl_u8(a, b); 9207 } 9208 9209 // CHECK-LABEL: test_vshl_u16 9210 // CHECK: vshl.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9211 uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) { 9212 return vshl_u16(a, b); 9213 } 9214 9215 // CHECK-LABEL: test_vshl_u32 9216 // CHECK: vshl.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9217 uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) { 9218 return vshl_u32(a, b); 9219 } 9220 9221 // CHECK-LABEL: test_vshl_u64 9222 // CHECK: vshl.u64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 9223 uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) { 9224 return vshl_u64(a, b); 9225 } 9226 9227 // CHECK-LABEL: test_vshlq_s8 9228 // CHECK: vshl.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9229 int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) { 9230 return vshlq_s8(a, b); 9231 } 9232 9233 // CHECK-LABEL: test_vshlq_s16 9234 // CHECK: vshl.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9235 int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) { 9236 return vshlq_s16(a, b); 9237 } 9238 9239 // CHECK-LABEL: test_vshlq_s32 9240 // CHECK: vshl.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9241 int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) { 9242 return vshlq_s32(a, b); 9243 } 9244 9245 // CHECK-LABEL: test_vshlq_s64 9246 // CHECK: vshl.s64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9247 int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) { 9248 return vshlq_s64(a, b); 9249 } 9250 9251 // CHECK-LABEL: test_vshlq_u8 9252 // CHECK: vshl.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9253 uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) { 9254 return vshlq_u8(a, b); 9255 } 9256 9257 // CHECK-LABEL: test_vshlq_u16 9258 // CHECK: vshl.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9259 uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) { 9260 return vshlq_u16(a, b); 9261 } 9262 9263 // CHECK-LABEL: test_vshlq_u32 9264 // CHECK: vshl.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9265 uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) { 9266 return vshlq_u32(a, b); 9267 } 9268 9269 // CHECK-LABEL: test_vshlq_u64 9270 // CHECK: vshl.u64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 9271 uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) { 9272 return vshlq_u64(a, b); 9273 } 9274 9275 9276 // CHECK-LABEL: test_vshll_n_s8 9277 // CHECK: vshll.s8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9278 int16x8_t test_vshll_n_s8(int8x8_t a) { 9279 return vshll_n_s8(a, 1); 9280 } 9281 9282 // CHECK-LABEL: test_vshll_n_s16 9283 // CHECK: vshll.s16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9284 int32x4_t test_vshll_n_s16(int16x4_t a) { 9285 return vshll_n_s16(a, 1); 9286 } 9287 9288 // CHECK-LABEL: test_vshll_n_s32 9289 // CHECK: vshll.s32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9290 int64x2_t test_vshll_n_s32(int32x2_t a) { 9291 return vshll_n_s32(a, 1); 9292 } 9293 9294 // CHECK-LABEL: test_vshll_n_u8 9295 // CHECK: vshll.u8 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9296 uint16x8_t test_vshll_n_u8(uint8x8_t a) { 9297 return vshll_n_u8(a, 1); 9298 } 9299 9300 // CHECK-LABEL: test_vshll_n_u16 9301 // CHECK: vshll.u16 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9302 uint32x4_t test_vshll_n_u16(uint16x4_t a) { 9303 return vshll_n_u16(a, 1); 9304 } 9305 9306 // CHECK-LABEL: test_vshll_n_u32 9307 // CHECK: vshll.u32 q{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9308 uint64x2_t test_vshll_n_u32(uint32x2_t a) { 9309 return vshll_n_u32(a, 1); 9310 } 9311 9312 9313 // CHECK-LABEL: test_vshl_n_s8 9314 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9315 int8x8_t test_vshl_n_s8(int8x8_t a) { 9316 return vshl_n_s8(a, 1); 9317 } 9318 9319 // CHECK-LABEL: test_vshl_n_s16 9320 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9321 int16x4_t test_vshl_n_s16(int16x4_t a) { 9322 return vshl_n_s16(a, 1); 9323 } 9324 9325 // CHECK-LABEL: test_vshl_n_s32 9326 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9327 int32x2_t test_vshl_n_s32(int32x2_t a) { 9328 return vshl_n_s32(a, 1); 9329 } 9330 9331 // CHECK-LABEL: test_vshl_n_s64 9332 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9333 int64x1_t test_vshl_n_s64(int64x1_t a) { 9334 return vshl_n_s64(a, 1); 9335 } 9336 9337 // CHECK-LABEL: test_vshl_n_u8 9338 // CHECK: vshl.i8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9339 uint8x8_t test_vshl_n_u8(uint8x8_t a) { 9340 return vshl_n_u8(a, 1); 9341 } 9342 9343 // CHECK-LABEL: test_vshl_n_u16 9344 // CHECK: vshl.i16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9345 uint16x4_t test_vshl_n_u16(uint16x4_t a) { 9346 return vshl_n_u16(a, 1); 9347 } 9348 9349 // CHECK-LABEL: test_vshl_n_u32 9350 // CHECK: vshl.i32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9351 uint32x2_t test_vshl_n_u32(uint32x2_t a) { 9352 return vshl_n_u32(a, 1); 9353 } 9354 9355 // CHECK-LABEL: test_vshl_n_u64 9356 // CHECK: vshl.i64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9357 uint64x1_t test_vshl_n_u64(uint64x1_t a) { 9358 return vshl_n_u64(a, 1); 9359 } 9360 9361 // CHECK-LABEL: test_vshlq_n_s8 9362 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9363 int8x16_t test_vshlq_n_s8(int8x16_t a) { 9364 return vshlq_n_s8(a, 1); 9365 } 9366 9367 // CHECK-LABEL: test_vshlq_n_s16 9368 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9369 int16x8_t test_vshlq_n_s16(int16x8_t a) { 9370 return vshlq_n_s16(a, 1); 9371 } 9372 9373 // CHECK-LABEL: test_vshlq_n_s32 9374 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9375 int32x4_t test_vshlq_n_s32(int32x4_t a) { 9376 return vshlq_n_s32(a, 1); 9377 } 9378 9379 // CHECK-LABEL: test_vshlq_n_s64 9380 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9381 int64x2_t test_vshlq_n_s64(int64x2_t a) { 9382 return vshlq_n_s64(a, 1); 9383 } 9384 9385 // CHECK-LABEL: test_vshlq_n_u8 9386 // CHECK: vshl.i8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9387 uint8x16_t test_vshlq_n_u8(uint8x16_t a) { 9388 return vshlq_n_u8(a, 1); 9389 } 9390 9391 // CHECK-LABEL: test_vshlq_n_u16 9392 // CHECK: vshl.i16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9393 uint16x8_t test_vshlq_n_u16(uint16x8_t a) { 9394 return vshlq_n_u16(a, 1); 9395 } 9396 9397 // CHECK-LABEL: test_vshlq_n_u32 9398 // CHECK: vshl.i32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9399 uint32x4_t test_vshlq_n_u32(uint32x4_t a) { 9400 return vshlq_n_u32(a, 1); 9401 } 9402 9403 // CHECK-LABEL: test_vshlq_n_u64 9404 // CHECK: vshl.i64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9405 uint64x2_t test_vshlq_n_u64(uint64x2_t a) { 9406 return vshlq_n_u64(a, 1); 9407 } 9408 9409 9410 // CHECK-LABEL: test_vshrn_n_s16 9411 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9412 int8x8_t test_vshrn_n_s16(int16x8_t a) { 9413 return vshrn_n_s16(a, 1); 9414 } 9415 9416 // CHECK-LABEL: test_vshrn_n_s32 9417 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9418 int16x4_t test_vshrn_n_s32(int32x4_t a) { 9419 return vshrn_n_s32(a, 1); 9420 } 9421 9422 // CHECK-LABEL: test_vshrn_n_s64 9423 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9424 int32x2_t test_vshrn_n_s64(int64x2_t a) { 9425 return vshrn_n_s64(a, 1); 9426 } 9427 9428 // CHECK-LABEL: test_vshrn_n_u16 9429 // CHECK: vshrn.i16 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9430 uint8x8_t test_vshrn_n_u16(uint16x8_t a) { 9431 return vshrn_n_u16(a, 1); 9432 } 9433 9434 // CHECK-LABEL: test_vshrn_n_u32 9435 // CHECK: vshrn.i32 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9436 uint16x4_t test_vshrn_n_u32(uint32x4_t a) { 9437 return vshrn_n_u32(a, 1); 9438 } 9439 9440 // CHECK-LABEL: test_vshrn_n_u64 9441 // CHECK: vshrn.i64 d{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9442 uint32x2_t test_vshrn_n_u64(uint64x2_t a) { 9443 return vshrn_n_u64(a, 1); 9444 } 9445 9446 9447 // CHECK-LABEL: test_vshr_n_s8 9448 // CHECK: vshr.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9449 int8x8_t test_vshr_n_s8(int8x8_t a) { 9450 return vshr_n_s8(a, 1); 9451 } 9452 9453 // CHECK-LABEL: test_vshr_n_s16 9454 // CHECK: vshr.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9455 int16x4_t test_vshr_n_s16(int16x4_t a) { 9456 return vshr_n_s16(a, 1); 9457 } 9458 9459 // CHECK-LABEL: test_vshr_n_s32 9460 // CHECK: vshr.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9461 int32x2_t test_vshr_n_s32(int32x2_t a) { 9462 return vshr_n_s32(a, 1); 9463 } 9464 9465 // CHECK-LABEL: test_vshr_n_s64 9466 // CHECK: vshr.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9467 int64x1_t test_vshr_n_s64(int64x1_t a) { 9468 return vshr_n_s64(a, 1); 9469 } 9470 9471 // CHECK-LABEL: test_vshr_n_u8 9472 // CHECK: vshr.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9473 uint8x8_t test_vshr_n_u8(uint8x8_t a) { 9474 return vshr_n_u8(a, 1); 9475 } 9476 9477 // CHECK-LABEL: test_vshr_n_u16 9478 // CHECK: vshr.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9479 uint16x4_t test_vshr_n_u16(uint16x4_t a) { 9480 return vshr_n_u16(a, 1); 9481 } 9482 9483 // CHECK-LABEL: test_vshr_n_u32 9484 // CHECK: vshr.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9485 uint32x2_t test_vshr_n_u32(uint32x2_t a) { 9486 return vshr_n_u32(a, 1); 9487 } 9488 9489 // CHECK-LABEL: test_vshr_n_u64 9490 // CHECK: vshr.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9491 uint64x1_t test_vshr_n_u64(uint64x1_t a) { 9492 return vshr_n_u64(a, 1); 9493 } 9494 9495 // CHECK-LABEL: test_vshrq_n_s8 9496 // CHECK: vshr.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9497 int8x16_t test_vshrq_n_s8(int8x16_t a) { 9498 return vshrq_n_s8(a, 1); 9499 } 9500 9501 // CHECK-LABEL: test_vshrq_n_s16 9502 // CHECK: vshr.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9503 int16x8_t test_vshrq_n_s16(int16x8_t a) { 9504 return vshrq_n_s16(a, 1); 9505 } 9506 9507 // CHECK-LABEL: test_vshrq_n_s32 9508 // CHECK: vshr.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9509 int32x4_t test_vshrq_n_s32(int32x4_t a) { 9510 return vshrq_n_s32(a, 1); 9511 } 9512 9513 // CHECK-LABEL: test_vshrq_n_s64 9514 // CHECK: vshr.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9515 int64x2_t test_vshrq_n_s64(int64x2_t a) { 9516 return vshrq_n_s64(a, 1); 9517 } 9518 9519 // CHECK-LABEL: test_vshrq_n_u8 9520 // CHECK: vshr.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9521 uint8x16_t test_vshrq_n_u8(uint8x16_t a) { 9522 return vshrq_n_u8(a, 1); 9523 } 9524 9525 // CHECK-LABEL: test_vshrq_n_u16 9526 // CHECK: vshr.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9527 uint16x8_t test_vshrq_n_u16(uint16x8_t a) { 9528 return vshrq_n_u16(a, 1); 9529 } 9530 9531 // CHECK-LABEL: test_vshrq_n_u32 9532 // CHECK: vshr.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9533 uint32x4_t test_vshrq_n_u32(uint32x4_t a) { 9534 return vshrq_n_u32(a, 1); 9535 } 9536 9537 // CHECK-LABEL: test_vshrq_n_u64 9538 // CHECK: vshr.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9539 uint64x2_t test_vshrq_n_u64(uint64x2_t a) { 9540 return vshrq_n_u64(a, 1); 9541 } 9542 9543 9544 // CHECK-LABEL: test_vsli_n_s8 9545 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9546 int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) { 9547 return vsli_n_s8(a, b, 1); 9548 } 9549 9550 // CHECK-LABEL: test_vsli_n_s16 9551 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9552 int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) { 9553 return vsli_n_s16(a, b, 1); 9554 } 9555 9556 // CHECK-LABEL: test_vsli_n_s32 9557 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9558 int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) { 9559 return vsli_n_s32(a, b, 1); 9560 } 9561 9562 // CHECK-LABEL: test_vsli_n_s64 9563 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9564 int64x1_t test_vsli_n_s64(int64x1_t a, int64x1_t b) { 9565 return vsli_n_s64(a, b, 1); 9566 } 9567 9568 // CHECK-LABEL: test_vsli_n_u8 9569 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9570 uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) { 9571 return vsli_n_u8(a, b, 1); 9572 } 9573 9574 // CHECK-LABEL: test_vsli_n_u16 9575 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9576 uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) { 9577 return vsli_n_u16(a, b, 1); 9578 } 9579 9580 // CHECK-LABEL: test_vsli_n_u32 9581 // CHECK: vsli.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9582 uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) { 9583 return vsli_n_u32(a, b, 1); 9584 } 9585 9586 // CHECK-LABEL: test_vsli_n_u64 9587 // CHECK: vsli.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9588 uint64x1_t test_vsli_n_u64(uint64x1_t a, uint64x1_t b) { 9589 return vsli_n_u64(a, b, 1); 9590 } 9591 9592 // CHECK-LABEL: test_vsli_n_p8 9593 // CHECK: vsli.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9594 poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) { 9595 return vsli_n_p8(a, b, 1); 9596 } 9597 9598 // CHECK-LABEL: test_vsli_n_p16 9599 // CHECK: vsli.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9600 poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) { 9601 return vsli_n_p16(a, b, 1); 9602 } 9603 9604 // CHECK-LABEL: test_vsliq_n_s8 9605 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9606 int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) { 9607 return vsliq_n_s8(a, b, 1); 9608 } 9609 9610 // CHECK-LABEL: test_vsliq_n_s16 9611 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9612 int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) { 9613 return vsliq_n_s16(a, b, 1); 9614 } 9615 9616 // CHECK-LABEL: test_vsliq_n_s32 9617 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9618 int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) { 9619 return vsliq_n_s32(a, b, 1); 9620 } 9621 9622 // CHECK-LABEL: test_vsliq_n_s64 9623 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9624 int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) { 9625 return vsliq_n_s64(a, b, 1); 9626 } 9627 9628 // CHECK-LABEL: test_vsliq_n_u8 9629 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9630 uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) { 9631 return vsliq_n_u8(a, b, 1); 9632 } 9633 9634 // CHECK-LABEL: test_vsliq_n_u16 9635 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9636 uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) { 9637 return vsliq_n_u16(a, b, 1); 9638 } 9639 9640 // CHECK-LABEL: test_vsliq_n_u32 9641 // CHECK: vsli.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9642 uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) { 9643 return vsliq_n_u32(a, b, 1); 9644 } 9645 9646 // CHECK-LABEL: test_vsliq_n_u64 9647 // CHECK: vsli.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9648 uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) { 9649 return vsliq_n_u64(a, b, 1); 9650 } 9651 9652 // CHECK-LABEL: test_vsliq_n_p8 9653 // CHECK: vsli.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9654 poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) { 9655 return vsliq_n_p8(a, b, 1); 9656 } 9657 9658 // CHECK-LABEL: test_vsliq_n_p16 9659 // CHECK: vsli.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9660 poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) { 9661 return vsliq_n_p16(a, b, 1); 9662 } 9663 9664 9665 // CHECK-LABEL: test_vsra_n_s8 9666 // CHECK: vsra.s8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9667 int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) { 9668 return vsra_n_s8(a, b, 1); 9669 } 9670 9671 // CHECK-LABEL: test_vsra_n_s16 9672 // CHECK: vsra.s16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9673 int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) { 9674 return vsra_n_s16(a, b, 1); 9675 } 9676 9677 // CHECK-LABEL: test_vsra_n_s32 9678 // CHECK: vsra.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9679 int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) { 9680 return vsra_n_s32(a, b, 1); 9681 } 9682 9683 // CHECK-LABEL: test_vsra_n_s64 9684 // CHECK: vsra.s64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9685 int64x1_t test_vsra_n_s64(int64x1_t a, int64x1_t b) { 9686 return vsra_n_s64(a, b, 1); 9687 } 9688 9689 // CHECK-LABEL: test_vsra_n_u8 9690 // CHECK: vsra.u8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9691 uint8x8_t test_vsra_n_u8(uint8x8_t a, uint8x8_t b) { 9692 return vsra_n_u8(a, b, 1); 9693 } 9694 9695 // CHECK-LABEL: test_vsra_n_u16 9696 // CHECK: vsra.u16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9697 uint16x4_t test_vsra_n_u16(uint16x4_t a, uint16x4_t b) { 9698 return vsra_n_u16(a, b, 1); 9699 } 9700 9701 // CHECK-LABEL: test_vsra_n_u32 9702 // CHECK: vsra.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9703 uint32x2_t test_vsra_n_u32(uint32x2_t a, uint32x2_t b) { 9704 return vsra_n_u32(a, b, 1); 9705 } 9706 9707 // CHECK-LABEL: test_vsra_n_u64 9708 // CHECK: vsra.u64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9709 uint64x1_t test_vsra_n_u64(uint64x1_t a, uint64x1_t b) { 9710 return vsra_n_u64(a, b, 1); 9711 } 9712 9713 // CHECK-LABEL: test_vsraq_n_s8 9714 // CHECK: vsra.s8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9715 int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) { 9716 return vsraq_n_s8(a, b, 1); 9717 } 9718 9719 // CHECK-LABEL: test_vsraq_n_s16 9720 // CHECK: vsra.s16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9721 int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) { 9722 return vsraq_n_s16(a, b, 1); 9723 } 9724 9725 // CHECK-LABEL: test_vsraq_n_s32 9726 // CHECK: vsra.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9727 int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) { 9728 return vsraq_n_s32(a, b, 1); 9729 } 9730 9731 // CHECK-LABEL: test_vsraq_n_s64 9732 // CHECK: vsra.s64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9733 int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) { 9734 return vsraq_n_s64(a, b, 1); 9735 } 9736 9737 // CHECK-LABEL: test_vsraq_n_u8 9738 // CHECK: vsra.u8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9739 uint8x16_t test_vsraq_n_u8(uint8x16_t a, uint8x16_t b) { 9740 return vsraq_n_u8(a, b, 1); 9741 } 9742 9743 // CHECK-LABEL: test_vsraq_n_u16 9744 // CHECK: vsra.u16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9745 uint16x8_t test_vsraq_n_u16(uint16x8_t a, uint16x8_t b) { 9746 return vsraq_n_u16(a, b, 1); 9747 } 9748 9749 // CHECK-LABEL: test_vsraq_n_u32 9750 // CHECK: vsra.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9751 uint32x4_t test_vsraq_n_u32(uint32x4_t a, uint32x4_t b) { 9752 return vsraq_n_u32(a, b, 1); 9753 } 9754 9755 // CHECK-LABEL: test_vsraq_n_u64 9756 // CHECK: vsra.u64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9757 uint64x2_t test_vsraq_n_u64(uint64x2_t a, uint64x2_t b) { 9758 return vsraq_n_u64(a, b, 1); 9759 } 9760 9761 9762 // CHECK-LABEL: test_vsri_n_s8 9763 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9764 int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) { 9765 return vsri_n_s8(a, b, 1); 9766 } 9767 9768 // CHECK-LABEL: test_vsri_n_s16 9769 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9770 int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) { 9771 return vsri_n_s16(a, b, 1); 9772 } 9773 9774 // CHECK-LABEL: test_vsri_n_s32 9775 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9776 int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) { 9777 return vsri_n_s32(a, b, 1); 9778 } 9779 9780 // CHECK-LABEL: test_vsri_n_s64 9781 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9782 int64x1_t test_vsri_n_s64(int64x1_t a, int64x1_t b) { 9783 return vsri_n_s64(a, b, 1); 9784 } 9785 9786 // CHECK-LABEL: test_vsri_n_u8 9787 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9788 uint8x8_t test_vsri_n_u8(uint8x8_t a, uint8x8_t b) { 9789 return vsri_n_u8(a, b, 1); 9790 } 9791 9792 // CHECK-LABEL: test_vsri_n_u16 9793 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9794 uint16x4_t test_vsri_n_u16(uint16x4_t a, uint16x4_t b) { 9795 return vsri_n_u16(a, b, 1); 9796 } 9797 9798 // CHECK-LABEL: test_vsri_n_u32 9799 // CHECK: vsri.32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9800 uint32x2_t test_vsri_n_u32(uint32x2_t a, uint32x2_t b) { 9801 return vsri_n_u32(a, b, 1); 9802 } 9803 9804 // CHECK-LABEL: test_vsri_n_u64 9805 // CHECK: vsri.64 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9806 uint64x1_t test_vsri_n_u64(uint64x1_t a, uint64x1_t b) { 9807 return vsri_n_u64(a, b, 1); 9808 } 9809 9810 // CHECK-LABEL: test_vsri_n_p8 9811 // CHECK: vsri.8 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9812 poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) { 9813 return vsri_n_p8(a, b, 1); 9814 } 9815 9816 // CHECK-LABEL: test_vsri_n_p16 9817 // CHECK: vsri.16 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} 9818 poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) { 9819 return vsri_n_p16(a, b, 1); 9820 } 9821 9822 // CHECK-LABEL: test_vsriq_n_s8 9823 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9824 int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) { 9825 return vsriq_n_s8(a, b, 1); 9826 } 9827 9828 // CHECK-LABEL: test_vsriq_n_s16 9829 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9830 int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) { 9831 return vsriq_n_s16(a, b, 1); 9832 } 9833 9834 // CHECK-LABEL: test_vsriq_n_s32 9835 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9836 int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) { 9837 return vsriq_n_s32(a, b, 1); 9838 } 9839 9840 // CHECK-LABEL: test_vsriq_n_s64 9841 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9842 int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) { 9843 return vsriq_n_s64(a, b, 1); 9844 } 9845 9846 // CHECK-LABEL: test_vsriq_n_u8 9847 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9848 uint8x16_t test_vsriq_n_u8(uint8x16_t a, uint8x16_t b) { 9849 return vsriq_n_u8(a, b, 1); 9850 } 9851 9852 // CHECK-LABEL: test_vsriq_n_u16 9853 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9854 uint16x8_t test_vsriq_n_u16(uint16x8_t a, uint16x8_t b) { 9855 return vsriq_n_u16(a, b, 1); 9856 } 9857 9858 // CHECK-LABEL: test_vsriq_n_u32 9859 // CHECK: vsri.32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9860 uint32x4_t test_vsriq_n_u32(uint32x4_t a, uint32x4_t b) { 9861 return vsriq_n_u32(a, b, 1); 9862 } 9863 9864 // CHECK-LABEL: test_vsriq_n_u64 9865 // CHECK: vsri.64 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9866 uint64x2_t test_vsriq_n_u64(uint64x2_t a, uint64x2_t b) { 9867 return vsriq_n_u64(a, b, 1); 9868 } 9869 9870 // CHECK-LABEL: test_vsriq_n_p8 9871 // CHECK: vsri.8 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9872 poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) { 9873 return vsriq_n_p8(a, b, 1); 9874 } 9875 9876 // CHECK-LABEL: test_vsriq_n_p16 9877 // CHECK: vsri.16 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} 9878 poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) { 9879 return vsriq_n_p16(a, b, 1); 9880 } 9881 9882 9883 // CHECK-LABEL: test_vst1q_u8 9884 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9885 void test_vst1q_u8(uint8_t * a, uint8x16_t b) { 9886 vst1q_u8(a, b); 9887 } 9888 9889 // CHECK-LABEL: test_vst1q_u16 9890 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9891 void test_vst1q_u16(uint16_t * a, uint16x8_t b) { 9892 vst1q_u16(a, b); 9893 } 9894 9895 // CHECK-LABEL: test_vst1q_u32 9896 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9897 void test_vst1q_u32(uint32_t * a, uint32x4_t b) { 9898 vst1q_u32(a, b); 9899 } 9900 9901 // CHECK-LABEL: test_vst1q_u64 9902 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 9903 void test_vst1q_u64(uint64_t * a, uint64x2_t b) { 9904 vst1q_u64(a, b); 9905 } 9906 9907 // CHECK-LABEL: test_vst1q_s8 9908 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9909 void test_vst1q_s8(int8_t * a, int8x16_t b) { 9910 vst1q_s8(a, b); 9911 } 9912 9913 // CHECK-LABEL: test_vst1q_s16 9914 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9915 void test_vst1q_s16(int16_t * a, int16x8_t b) { 9916 vst1q_s16(a, b); 9917 } 9918 9919 // CHECK-LABEL: test_vst1q_s32 9920 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9921 void test_vst1q_s32(int32_t * a, int32x4_t b) { 9922 vst1q_s32(a, b); 9923 } 9924 9925 // CHECK-LABEL: test_vst1q_s64 9926 // CHECK: vst1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 9927 void test_vst1q_s64(int64_t * a, int64x2_t b) { 9928 vst1q_s64(a, b); 9929 } 9930 9931 // CHECK-LABEL: test_vst1q_f16 9932 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9933 void test_vst1q_f16(float16_t * a, float16x8_t b) { 9934 vst1q_f16(a, b); 9935 } 9936 9937 // CHECK-LABEL: test_vst1q_f32 9938 // CHECK: vst1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9939 void test_vst1q_f32(float32_t * a, float32x4_t b) { 9940 vst1q_f32(a, b); 9941 } 9942 9943 // CHECK-LABEL: test_vst1q_p8 9944 // CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9945 void test_vst1q_p8(poly8_t * a, poly8x16_t b) { 9946 vst1q_p8(a, b); 9947 } 9948 9949 // CHECK-LABEL: test_vst1q_p16 9950 // CHECK: vst1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 9951 void test_vst1q_p16(poly16_t * a, poly16x8_t b) { 9952 vst1q_p16(a, b); 9953 } 9954 9955 // CHECK-LABEL: test_vst1_u8 9956 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9957 void test_vst1_u8(uint8_t * a, uint8x8_t b) { 9958 vst1_u8(a, b); 9959 } 9960 9961 // CHECK-LABEL: test_vst1_u16 9962 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9963 void test_vst1_u16(uint16_t * a, uint16x4_t b) { 9964 vst1_u16(a, b); 9965 } 9966 9967 // CHECK-LABEL: test_vst1_u32 9968 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9969 void test_vst1_u32(uint32_t * a, uint32x2_t b) { 9970 vst1_u32(a, b); 9971 } 9972 9973 // CHECK-LABEL: test_vst1_u64 9974 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 9975 void test_vst1_u64(uint64_t * a, uint64x1_t b) { 9976 vst1_u64(a, b); 9977 } 9978 9979 // CHECK-LABEL: test_vst1_s8 9980 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9981 void test_vst1_s8(int8_t * a, int8x8_t b) { 9982 vst1_s8(a, b); 9983 } 9984 9985 // CHECK-LABEL: test_vst1_s16 9986 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9987 void test_vst1_s16(int16_t * a, int16x4_t b) { 9988 vst1_s16(a, b); 9989 } 9990 9991 // CHECK-LABEL: test_vst1_s32 9992 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 9993 void test_vst1_s32(int32_t * a, int32x2_t b) { 9994 vst1_s32(a, b); 9995 } 9996 9997 // CHECK-LABEL: test_vst1_s64 9998 // CHECK: vst1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] 9999 void test_vst1_s64(int64_t * a, int64x1_t b) { 10000 vst1_s64(a, b); 10001 } 10002 10003 // CHECK-LABEL: test_vst1_f16 10004 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 10005 void test_vst1_f16(float16_t * a, float16x4_t b) { 10006 vst1_f16(a, b); 10007 } 10008 10009 // CHECK-LABEL: test_vst1_f32 10010 // CHECK: vst1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] 10011 void test_vst1_f32(float32_t * a, float32x2_t b) { 10012 vst1_f32(a, b); 10013 } 10014 10015 // CHECK-LABEL: test_vst1_p8 10016 // CHECK: vst1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] 10017 void test_vst1_p8(poly8_t * a, poly8x8_t b) { 10018 vst1_p8(a, b); 10019 } 10020 10021 // CHECK-LABEL: test_vst1_p16 10022 // CHECK: vst1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] 10023 void test_vst1_p16(poly16_t * a, poly16x4_t b) { 10024 vst1_p16(a, b); 10025 } 10026 10027 10028 // CHECK-LABEL: test_vst1q_lane_u8 10029 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10030 void test_vst1q_lane_u8(uint8_t * a, uint8x16_t b) { 10031 vst1q_lane_u8(a, b, 15); 10032 } 10033 10034 // CHECK-LABEL: test_vst1q_lane_u16 10035 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10036 void test_vst1q_lane_u16(uint16_t * a, uint16x8_t b) { 10037 vst1q_lane_u16(a, b, 7); 10038 } 10039 10040 // CHECK-LABEL: test_vst1q_lane_u32 10041 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10042 void test_vst1q_lane_u32(uint32_t * a, uint32x4_t b) { 10043 vst1q_lane_u32(a, b, 3); 10044 } 10045 10046 // CHECK-LABEL: test_vst1q_lane_u64 10047 // CHECK: {{str|vstr|vmov}} 10048 void test_vst1q_lane_u64(uint64_t * a, uint64x2_t b) { 10049 vst1q_lane_u64(a, b, 1); 10050 } 10051 10052 // CHECK-LABEL: test_vst1q_lane_s8 10053 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10054 void test_vst1q_lane_s8(int8_t * a, int8x16_t b) { 10055 vst1q_lane_s8(a, b, 15); 10056 } 10057 10058 // CHECK-LABEL: test_vst1q_lane_s16 10059 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10060 void test_vst1q_lane_s16(int16_t * a, int16x8_t b) { 10061 vst1q_lane_s16(a, b, 7); 10062 } 10063 10064 // CHECK-LABEL: test_vst1q_lane_s32 10065 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10066 void test_vst1q_lane_s32(int32_t * a, int32x4_t b) { 10067 vst1q_lane_s32(a, b, 3); 10068 } 10069 10070 // CHECK-LABEL: test_vst1q_lane_s64 10071 // CHECK: {{str|vstr|vmov}} 10072 void test_vst1q_lane_s64(int64_t * a, int64x2_t b) { 10073 vst1q_lane_s64(a, b, 1); 10074 } 10075 10076 // CHECK-LABEL: test_vst1q_lane_f16 10077 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10078 void test_vst1q_lane_f16(float16_t * a, float16x8_t b) { 10079 vst1q_lane_f16(a, b, 7); 10080 } 10081 10082 // CHECK-LABEL: test_vst1q_lane_f32 10083 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10084 void test_vst1q_lane_f32(float32_t * a, float32x4_t b) { 10085 vst1q_lane_f32(a, b, 3); 10086 } 10087 10088 // CHECK-LABEL: test_vst1q_lane_p8 10089 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10090 void test_vst1q_lane_p8(poly8_t * a, poly8x16_t b) { 10091 vst1q_lane_p8(a, b, 15); 10092 } 10093 10094 // CHECK-LABEL: test_vst1q_lane_p16 10095 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10096 void test_vst1q_lane_p16(poly16_t * a, poly16x8_t b) { 10097 vst1q_lane_p16(a, b, 7); 10098 } 10099 10100 // CHECK-LABEL: test_vst1_lane_u8 10101 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10102 void test_vst1_lane_u8(uint8_t * a, uint8x8_t b) { 10103 vst1_lane_u8(a, b, 7); 10104 } 10105 10106 // CHECK-LABEL: test_vst1_lane_u16 10107 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10108 void test_vst1_lane_u16(uint16_t * a, uint16x4_t b) { 10109 vst1_lane_u16(a, b, 3); 10110 } 10111 10112 // CHECK-LABEL: test_vst1_lane_u32 10113 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10114 void test_vst1_lane_u32(uint32_t * a, uint32x2_t b) { 10115 vst1_lane_u32(a, b, 1); 10116 } 10117 10118 // CHECK-LABEL: test_vst1_lane_u64 10119 // CHECK: {{str|vstr|vmov}} 10120 void test_vst1_lane_u64(uint64_t * a, uint64x1_t b) { 10121 vst1_lane_u64(a, b, 0); 10122 } 10123 10124 // CHECK-LABEL: test_vst1_lane_s8 10125 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10126 void test_vst1_lane_s8(int8_t * a, int8x8_t b) { 10127 vst1_lane_s8(a, b, 7); 10128 } 10129 10130 // CHECK-LABEL: test_vst1_lane_s16 10131 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10132 void test_vst1_lane_s16(int16_t * a, int16x4_t b) { 10133 vst1_lane_s16(a, b, 3); 10134 } 10135 10136 // CHECK-LABEL: test_vst1_lane_s32 10137 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10138 void test_vst1_lane_s32(int32_t * a, int32x2_t b) { 10139 vst1_lane_s32(a, b, 1); 10140 } 10141 10142 // CHECK-LABEL: test_vst1_lane_s64 10143 // CHECK: {{str|vstr|vmov}} 10144 void test_vst1_lane_s64(int64_t * a, int64x1_t b) { 10145 vst1_lane_s64(a, b, 0); 10146 } 10147 10148 // CHECK-LABEL: test_vst1_lane_f16 10149 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10150 void test_vst1_lane_f16(float16_t * a, float16x4_t b) { 10151 vst1_lane_f16(a, b, 3); 10152 } 10153 10154 // CHECK-LABEL: test_vst1_lane_f32 10155 // CHECK: vst1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] 10156 void test_vst1_lane_f32(float32_t * a, float32x2_t b) { 10157 vst1_lane_f32(a, b, 1); 10158 } 10159 10160 // CHECK-LABEL: test_vst1_lane_p8 10161 // CHECK: vst1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10162 void test_vst1_lane_p8(poly8_t * a, poly8x8_t b) { 10163 vst1_lane_p8(a, b, 7); 10164 } 10165 10166 // CHECK-LABEL: test_vst1_lane_p16 10167 // CHECK: vst1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] 10168 void test_vst1_lane_p16(poly16_t * a, poly16x4_t b) { 10169 vst1_lane_p16(a, b, 3); 10170 } 10171 10172 10173 // CHECK-LABEL: test_vst2q_u8 10174 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10175 void test_vst2q_u8(uint8_t * a, uint8x16x2_t b) { 10176 vst2q_u8(a, b); 10177 } 10178 10179 // CHECK-LABEL: test_vst2q_u16 10180 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10181 void test_vst2q_u16(uint16_t * a, uint16x8x2_t b) { 10182 vst2q_u16(a, b); 10183 } 10184 10185 // CHECK-LABEL: test_vst2q_u32 10186 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10187 void test_vst2q_u32(uint32_t * a, uint32x4x2_t b) { 10188 vst2q_u32(a, b); 10189 } 10190 10191 // CHECK-LABEL: test_vst2q_s8 10192 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10193 void test_vst2q_s8(int8_t * a, int8x16x2_t b) { 10194 vst2q_s8(a, b); 10195 } 10196 10197 // CHECK-LABEL: test_vst2q_s16 10198 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10199 void test_vst2q_s16(int16_t * a, int16x8x2_t b) { 10200 vst2q_s16(a, b); 10201 } 10202 10203 // CHECK-LABEL: test_vst2q_s32 10204 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10205 void test_vst2q_s32(int32_t * a, int32x4x2_t b) { 10206 vst2q_s32(a, b); 10207 } 10208 10209 // CHECK-LABEL: test_vst2q_f16 10210 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10211 void test_vst2q_f16(float16_t * a, float16x8x2_t b) { 10212 vst2q_f16(a, b); 10213 } 10214 10215 // CHECK-LABEL: test_vst2q_f32 10216 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10217 void test_vst2q_f32(float32_t * a, float32x4x2_t b) { 10218 vst2q_f32(a, b); 10219 } 10220 10221 // CHECK-LABEL: test_vst2q_p8 10222 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10223 void test_vst2q_p8(poly8_t * a, poly8x16x2_t b) { 10224 vst2q_p8(a, b); 10225 } 10226 10227 // CHECK-LABEL: test_vst2q_p16 10228 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10229 void test_vst2q_p16(poly16_t * a, poly16x8x2_t b) { 10230 vst2q_p16(a, b); 10231 } 10232 10233 // CHECK-LABEL: test_vst2_u8 10234 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10235 void test_vst2_u8(uint8_t * a, uint8x8x2_t b) { 10236 vst2_u8(a, b); 10237 } 10238 10239 // CHECK-LABEL: test_vst2_u16 10240 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10241 void test_vst2_u16(uint16_t * a, uint16x4x2_t b) { 10242 vst2_u16(a, b); 10243 } 10244 10245 // CHECK-LABEL: test_vst2_u32 10246 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10247 void test_vst2_u32(uint32_t * a, uint32x2x2_t b) { 10248 vst2_u32(a, b); 10249 } 10250 10251 // CHECK-LABEL: test_vst2_u64 10252 // CHECK: vst1.64 10253 void test_vst2_u64(uint64_t * a, uint64x1x2_t b) { 10254 vst2_u64(a, b); 10255 } 10256 10257 // CHECK-LABEL: test_vst2_s8 10258 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10259 void test_vst2_s8(int8_t * a, int8x8x2_t b) { 10260 vst2_s8(a, b); 10261 } 10262 10263 // CHECK-LABEL: test_vst2_s16 10264 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10265 void test_vst2_s16(int16_t * a, int16x4x2_t b) { 10266 vst2_s16(a, b); 10267 } 10268 10269 // CHECK-LABEL: test_vst2_s32 10270 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10271 void test_vst2_s32(int32_t * a, int32x2x2_t b) { 10272 vst2_s32(a, b); 10273 } 10274 10275 // CHECK-LABEL: test_vst2_s64 10276 // CHECK: vst1.64 10277 void test_vst2_s64(int64_t * a, int64x1x2_t b) { 10278 vst2_s64(a, b); 10279 } 10280 10281 // CHECK-LABEL: test_vst2_f16 10282 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10283 void test_vst2_f16(float16_t * a, float16x4x2_t b) { 10284 vst2_f16(a, b); 10285 } 10286 10287 // CHECK-LABEL: test_vst2_f32 10288 // CHECK: vst2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10289 void test_vst2_f32(float32_t * a, float32x2x2_t b) { 10290 vst2_f32(a, b); 10291 } 10292 10293 // CHECK-LABEL: test_vst2_p8 10294 // CHECK: vst2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10295 void test_vst2_p8(poly8_t * a, poly8x8x2_t b) { 10296 vst2_p8(a, b); 10297 } 10298 10299 // CHECK-LABEL: test_vst2_p16 10300 // CHECK: vst2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10301 void test_vst2_p16(poly16_t * a, poly16x4x2_t b) { 10302 vst2_p16(a, b); 10303 } 10304 10305 10306 // CHECK-LABEL: test_vst2q_lane_u16 10307 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10308 void test_vst2q_lane_u16(uint16_t * a, uint16x8x2_t b) { 10309 vst2q_lane_u16(a, b, 7); 10310 } 10311 10312 // CHECK-LABEL: test_vst2q_lane_u32 10313 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10314 void test_vst2q_lane_u32(uint32_t * a, uint32x4x2_t b) { 10315 vst2q_lane_u32(a, b, 3); 10316 } 10317 10318 // CHECK-LABEL: test_vst2q_lane_s16 10319 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10320 void test_vst2q_lane_s16(int16_t * a, int16x8x2_t b) { 10321 vst2q_lane_s16(a, b, 7); 10322 } 10323 10324 // CHECK-LABEL: test_vst2q_lane_s32 10325 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10326 void test_vst2q_lane_s32(int32_t * a, int32x4x2_t b) { 10327 vst2q_lane_s32(a, b, 3); 10328 } 10329 10330 // CHECK-LABEL: test_vst2q_lane_f16 10331 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10332 void test_vst2q_lane_f16(float16_t * a, float16x8x2_t b) { 10333 vst2q_lane_f16(a, b, 7); 10334 } 10335 10336 // CHECK-LABEL: test_vst2q_lane_f32 10337 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10338 void test_vst2q_lane_f32(float32_t * a, float32x4x2_t b) { 10339 vst2q_lane_f32(a, b, 3); 10340 } 10341 10342 // CHECK-LABEL: test_vst2q_lane_p16 10343 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10344 void test_vst2q_lane_p16(poly16_t * a, poly16x8x2_t b) { 10345 vst2q_lane_p16(a, b, 7); 10346 } 10347 10348 // CHECK-LABEL: test_vst2_lane_u8 10349 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10350 void test_vst2_lane_u8(uint8_t * a, uint8x8x2_t b) { 10351 vst2_lane_u8(a, b, 7); 10352 } 10353 10354 // CHECK-LABEL: test_vst2_lane_u16 10355 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10356 void test_vst2_lane_u16(uint16_t * a, uint16x4x2_t b) { 10357 vst2_lane_u16(a, b, 3); 10358 } 10359 10360 // CHECK-LABEL: test_vst2_lane_u32 10361 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10362 void test_vst2_lane_u32(uint32_t * a, uint32x2x2_t b) { 10363 vst2_lane_u32(a, b, 1); 10364 } 10365 10366 // CHECK-LABEL: test_vst2_lane_s8 10367 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10368 void test_vst2_lane_s8(int8_t * a, int8x8x2_t b) { 10369 vst2_lane_s8(a, b, 7); 10370 } 10371 10372 // CHECK-LABEL: test_vst2_lane_s16 10373 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10374 void test_vst2_lane_s16(int16_t * a, int16x4x2_t b) { 10375 vst2_lane_s16(a, b, 3); 10376 } 10377 10378 // CHECK-LABEL: test_vst2_lane_s32 10379 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10380 void test_vst2_lane_s32(int32_t * a, int32x2x2_t b) { 10381 vst2_lane_s32(a, b, 1); 10382 } 10383 10384 // CHECK-LABEL: test_vst2_lane_f16 10385 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10386 void test_vst2_lane_f16(float16_t * a, float16x4x2_t b) { 10387 vst2_lane_f16(a, b, 3); 10388 } 10389 10390 // CHECK-LABEL: test_vst2_lane_f32 10391 // CHECK: vst2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10392 void test_vst2_lane_f32(float32_t * a, float32x2x2_t b) { 10393 vst2_lane_f32(a, b, 1); 10394 } 10395 10396 // CHECK-LABEL: test_vst2_lane_p8 10397 // CHECK: vst2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10398 void test_vst2_lane_p8(poly8_t * a, poly8x8x2_t b) { 10399 vst2_lane_p8(a, b, 7); 10400 } 10401 10402 // CHECK-LABEL: test_vst2_lane_p16 10403 // CHECK: vst2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10404 void test_vst2_lane_p16(poly16_t * a, poly16x4x2_t b) { 10405 vst2_lane_p16(a, b, 3); 10406 } 10407 10408 10409 // CHECK-LABEL: test_vst3q_u8 10410 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10411 void test_vst3q_u8(uint8_t * a, uint8x16x3_t b) { 10412 vst3q_u8(a, b); 10413 } 10414 10415 // CHECK-LABEL: test_vst3q_u16 10416 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10417 void test_vst3q_u16(uint16_t * a, uint16x8x3_t b) { 10418 vst3q_u16(a, b); 10419 } 10420 10421 // CHECK-LABEL: test_vst3q_u32 10422 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10423 void test_vst3q_u32(uint32_t * a, uint32x4x3_t b) { 10424 vst3q_u32(a, b); 10425 } 10426 10427 // CHECK-LABEL: test_vst3q_s8 10428 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10429 void test_vst3q_s8(int8_t * a, int8x16x3_t b) { 10430 vst3q_s8(a, b); 10431 } 10432 10433 // CHECK-LABEL: test_vst3q_s16 10434 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10435 void test_vst3q_s16(int16_t * a, int16x8x3_t b) { 10436 vst3q_s16(a, b); 10437 } 10438 10439 // CHECK-LABEL: test_vst3q_s32 10440 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10441 void test_vst3q_s32(int32_t * a, int32x4x3_t b) { 10442 vst3q_s32(a, b); 10443 } 10444 10445 // CHECK-LABEL: test_vst3q_f16 10446 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10447 void test_vst3q_f16(float16_t * a, float16x8x3_t b) { 10448 vst3q_f16(a, b); 10449 } 10450 10451 // CHECK-LABEL: test_vst3q_f32 10452 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10453 void test_vst3q_f32(float32_t * a, float32x4x3_t b) { 10454 vst3q_f32(a, b); 10455 } 10456 10457 // CHECK-LABEL: test_vst3q_p8 10458 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10459 void test_vst3q_p8(poly8_t * a, poly8x16x3_t b) { 10460 vst3q_p8(a, b); 10461 } 10462 10463 // CHECK-LABEL: test_vst3q_p16 10464 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10465 void test_vst3q_p16(poly16_t * a, poly16x8x3_t b) { 10466 vst3q_p16(a, b); 10467 } 10468 10469 // CHECK-LABEL: test_vst3_u8 10470 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10471 void test_vst3_u8(uint8_t * a, uint8x8x3_t b) { 10472 vst3_u8(a, b); 10473 } 10474 10475 // CHECK-LABEL: test_vst3_u16 10476 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10477 void test_vst3_u16(uint16_t * a, uint16x4x3_t b) { 10478 vst3_u16(a, b); 10479 } 10480 10481 // CHECK-LABEL: test_vst3_u32 10482 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10483 void test_vst3_u32(uint32_t * a, uint32x2x3_t b) { 10484 vst3_u32(a, b); 10485 } 10486 10487 // CHECK-LABEL: test_vst3_u64 10488 // CHECK: vst1.64 10489 void test_vst3_u64(uint64_t * a, uint64x1x3_t b) { 10490 vst3_u64(a, b); 10491 } 10492 10493 // CHECK-LABEL: test_vst3_s8 10494 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10495 void test_vst3_s8(int8_t * a, int8x8x3_t b) { 10496 vst3_s8(a, b); 10497 } 10498 10499 // CHECK-LABEL: test_vst3_s16 10500 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10501 void test_vst3_s16(int16_t * a, int16x4x3_t b) { 10502 vst3_s16(a, b); 10503 } 10504 10505 // CHECK-LABEL: test_vst3_s32 10506 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10507 void test_vst3_s32(int32_t * a, int32x2x3_t b) { 10508 vst3_s32(a, b); 10509 } 10510 10511 // CHECK-LABEL: test_vst3_s64 10512 // CHECK: vst1.64 10513 void test_vst3_s64(int64_t * a, int64x1x3_t b) { 10514 vst3_s64(a, b); 10515 } 10516 10517 // CHECK-LABEL: test_vst3_f16 10518 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10519 void test_vst3_f16(float16_t * a, float16x4x3_t b) { 10520 vst3_f16(a, b); 10521 } 10522 10523 // CHECK-LABEL: test_vst3_f32 10524 // CHECK: vst3.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10525 void test_vst3_f32(float32_t * a, float32x2x3_t b) { 10526 vst3_f32(a, b); 10527 } 10528 10529 // CHECK-LABEL: test_vst3_p8 10530 // CHECK: vst3.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10531 void test_vst3_p8(poly8_t * a, poly8x8x3_t b) { 10532 vst3_p8(a, b); 10533 } 10534 10535 // CHECK-LABEL: test_vst3_p16 10536 // CHECK: vst3.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10537 void test_vst3_p16(poly16_t * a, poly16x4x3_t b) { 10538 vst3_p16(a, b); 10539 } 10540 10541 10542 // CHECK-LABEL: test_vst3q_lane_u16 10543 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10544 void test_vst3q_lane_u16(uint16_t * a, uint16x8x3_t b) { 10545 vst3q_lane_u16(a, b, 7); 10546 } 10547 10548 // CHECK-LABEL: test_vst3q_lane_u32 10549 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10550 void test_vst3q_lane_u32(uint32_t * a, uint32x4x3_t b) { 10551 vst3q_lane_u32(a, b, 3); 10552 } 10553 10554 // CHECK-LABEL: test_vst3q_lane_s16 10555 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10556 void test_vst3q_lane_s16(int16_t * a, int16x8x3_t b) { 10557 vst3q_lane_s16(a, b, 7); 10558 } 10559 10560 // CHECK-LABEL: test_vst3q_lane_s32 10561 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10562 void test_vst3q_lane_s32(int32_t * a, int32x4x3_t b) { 10563 vst3q_lane_s32(a, b, 3); 10564 } 10565 10566 // CHECK-LABEL: test_vst3q_lane_f16 10567 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10568 void test_vst3q_lane_f16(float16_t * a, float16x8x3_t b) { 10569 vst3q_lane_f16(a, b, 7); 10570 } 10571 10572 // CHECK-LABEL: test_vst3q_lane_f32 10573 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10574 void test_vst3q_lane_f32(float32_t * a, float32x4x3_t b) { 10575 vst3q_lane_f32(a, b, 3); 10576 } 10577 10578 // CHECK-LABEL: test_vst3q_lane_p16 10579 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10580 void test_vst3q_lane_p16(poly16_t * a, poly16x8x3_t b) { 10581 vst3q_lane_p16(a, b, 7); 10582 } 10583 10584 // CHECK-LABEL: test_vst3_lane_u8 10585 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10586 void test_vst3_lane_u8(uint8_t * a, uint8x8x3_t b) { 10587 vst3_lane_u8(a, b, 7); 10588 } 10589 10590 // CHECK-LABEL: test_vst3_lane_u16 10591 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10592 void test_vst3_lane_u16(uint16_t * a, uint16x4x3_t b) { 10593 vst3_lane_u16(a, b, 3); 10594 } 10595 10596 // CHECK-LABEL: test_vst3_lane_u32 10597 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10598 void test_vst3_lane_u32(uint32_t * a, uint32x2x3_t b) { 10599 vst3_lane_u32(a, b, 1); 10600 } 10601 10602 // CHECK-LABEL: test_vst3_lane_s8 10603 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10604 void test_vst3_lane_s8(int8_t * a, int8x8x3_t b) { 10605 vst3_lane_s8(a, b, 7); 10606 } 10607 10608 // CHECK-LABEL: test_vst3_lane_s16 10609 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10610 void test_vst3_lane_s16(int16_t * a, int16x4x3_t b) { 10611 vst3_lane_s16(a, b, 3); 10612 } 10613 10614 // CHECK-LABEL: test_vst3_lane_s32 10615 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10616 void test_vst3_lane_s32(int32_t * a, int32x2x3_t b) { 10617 vst3_lane_s32(a, b, 1); 10618 } 10619 10620 // CHECK-LABEL: test_vst3_lane_f16 10621 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10622 void test_vst3_lane_f16(float16_t * a, float16x4x3_t b) { 10623 vst3_lane_f16(a, b, 3); 10624 } 10625 10626 // CHECK-LABEL: test_vst3_lane_f32 10627 // CHECK: vst3.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10628 void test_vst3_lane_f32(float32_t * a, float32x2x3_t b) { 10629 vst3_lane_f32(a, b, 1); 10630 } 10631 10632 // CHECK-LABEL: test_vst3_lane_p8 10633 // CHECK: vst3.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10634 void test_vst3_lane_p8(poly8_t * a, poly8x8x3_t b) { 10635 vst3_lane_p8(a, b, 7); 10636 } 10637 10638 // CHECK-LABEL: test_vst3_lane_p16 10639 // CHECK: vst3.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] 10640 void test_vst3_lane_p16(poly16_t * a, poly16x4x3_t b) { 10641 vst3_lane_p16(a, b, 3); 10642 } 10643 10644 10645 // CHECK-LABEL: test_vst4q_u8 10646 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10647 void test_vst4q_u8(uint8_t * a, uint8x16x4_t b) { 10648 vst4q_u8(a, b); 10649 } 10650 10651 // CHECK-LABEL: test_vst4q_u16 10652 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10653 void test_vst4q_u16(uint16_t * a, uint16x8x4_t b) { 10654 vst4q_u16(a, b); 10655 } 10656 10657 // CHECK-LABEL: test_vst4q_u32 10658 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10659 void test_vst4q_u32(uint32_t * a, uint32x4x4_t b) { 10660 vst4q_u32(a, b); 10661 } 10662 10663 // CHECK-LABEL: test_vst4q_s8 10664 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10665 void test_vst4q_s8(int8_t * a, int8x16x4_t b) { 10666 vst4q_s8(a, b); 10667 } 10668 10669 // CHECK-LABEL: test_vst4q_s16 10670 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10671 void test_vst4q_s16(int16_t * a, int16x8x4_t b) { 10672 vst4q_s16(a, b); 10673 } 10674 10675 // CHECK-LABEL: test_vst4q_s32 10676 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10677 void test_vst4q_s32(int32_t * a, int32x4x4_t b) { 10678 vst4q_s32(a, b); 10679 } 10680 10681 // CHECK-LABEL: test_vst4q_f16 10682 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10683 void test_vst4q_f16(float16_t * a, float16x8x4_t b) { 10684 vst4q_f16(a, b); 10685 } 10686 10687 // CHECK-LABEL: test_vst4q_f32 10688 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10689 void test_vst4q_f32(float32_t * a, float32x4x4_t b) { 10690 vst4q_f32(a, b); 10691 } 10692 10693 // CHECK-LABEL: test_vst4q_p8 10694 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10695 void test_vst4q_p8(poly8_t * a, poly8x16x4_t b) { 10696 vst4q_p8(a, b); 10697 } 10698 10699 // CHECK-LABEL: test_vst4q_p16 10700 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}} 10701 void test_vst4q_p16(poly16_t * a, poly16x8x4_t b) { 10702 vst4q_p16(a, b); 10703 } 10704 10705 // CHECK-LABEL: test_vst4_u8 10706 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10707 void test_vst4_u8(uint8_t * a, uint8x8x4_t b) { 10708 vst4_u8(a, b); 10709 } 10710 10711 // CHECK-LABEL: test_vst4_u16 10712 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10713 void test_vst4_u16(uint16_t * a, uint16x4x4_t b) { 10714 vst4_u16(a, b); 10715 } 10716 10717 // CHECK-LABEL: test_vst4_u32 10718 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10719 void test_vst4_u32(uint32_t * a, uint32x2x4_t b) { 10720 vst4_u32(a, b); 10721 } 10722 10723 // CHECK-LABEL: test_vst4_u64 10724 // CHECK: vst1.64 10725 void test_vst4_u64(uint64_t * a, uint64x1x4_t b) { 10726 vst4_u64(a, b); 10727 } 10728 10729 // CHECK-LABEL: test_vst4_s8 10730 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10731 void test_vst4_s8(int8_t * a, int8x8x4_t b) { 10732 vst4_s8(a, b); 10733 } 10734 10735 // CHECK-LABEL: test_vst4_s16 10736 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10737 void test_vst4_s16(int16_t * a, int16x4x4_t b) { 10738 vst4_s16(a, b); 10739 } 10740 10741 // CHECK-LABEL: test_vst4_s32 10742 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10743 void test_vst4_s32(int32_t * a, int32x2x4_t b) { 10744 vst4_s32(a, b); 10745 } 10746 10747 // CHECK-LABEL: test_vst4_s64 10748 // CHECK: vst1.64 10749 void test_vst4_s64(int64_t * a, int64x1x4_t b) { 10750 vst4_s64(a, b); 10751 } 10752 10753 // CHECK-LABEL: test_vst4_f16 10754 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10755 void test_vst4_f16(float16_t * a, float16x4x4_t b) { 10756 vst4_f16(a, b); 10757 } 10758 10759 // CHECK-LABEL: test_vst4_f32 10760 // CHECK: vst4.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10761 void test_vst4_f32(float32_t * a, float32x2x4_t b) { 10762 vst4_f32(a, b); 10763 } 10764 10765 // CHECK-LABEL: test_vst4_p8 10766 // CHECK: vst4.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10767 void test_vst4_p8(poly8_t * a, poly8x8x4_t b) { 10768 vst4_p8(a, b); 10769 } 10770 10771 // CHECK-LABEL: test_vst4_p16 10772 // CHECK: vst4.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] 10773 void test_vst4_p16(poly16_t * a, poly16x4x4_t b) { 10774 vst4_p16(a, b); 10775 } 10776 10777 10778 // CHECK-LABEL: test_vst4q_lane_u16 10779 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10780 void test_vst4q_lane_u16(uint16_t * a, uint16x8x4_t b) { 10781 vst4q_lane_u16(a, b, 7); 10782 } 10783 10784 // CHECK-LABEL: test_vst4q_lane_u32 10785 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10786 void test_vst4q_lane_u32(uint32_t * a, uint32x4x4_t b) { 10787 vst4q_lane_u32(a, b, 3); 10788 } 10789 10790 // CHECK-LABEL: test_vst4q_lane_s16 10791 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10792 void test_vst4q_lane_s16(int16_t * a, int16x8x4_t b) { 10793 vst4q_lane_s16(a, b, 7); 10794 } 10795 10796 // CHECK-LABEL: test_vst4q_lane_s32 10797 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10798 void test_vst4q_lane_s32(int32_t * a, int32x4x4_t b) { 10799 vst4q_lane_s32(a, b, 3); 10800 } 10801 10802 // CHECK-LABEL: test_vst4q_lane_f16 10803 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10804 void test_vst4q_lane_f16(float16_t * a, float16x8x4_t b) { 10805 vst4q_lane_f16(a, b, 7); 10806 } 10807 10808 // CHECK-LABEL: test_vst4q_lane_f32 10809 // CHECK: vst4.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10810 void test_vst4q_lane_f32(float32_t * a, float32x4x4_t b) { 10811 vst4q_lane_f32(a, b, 3); 10812 } 10813 10814 // CHECK-LABEL: test_vst4q_lane_p16 10815 // CHECK: vst4.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]} 10816 void test_vst4q_lane_p16(poly16_t * a, poly16x8x4_t b) { 10817 vst4q_lane_p16(a, b, 7); 10818 } 10819 10820 // CHECK-LABEL: test_vst4_lane_u8 10821 // 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]+}}] 10822 void test_vst4_lane_u8(uint8_t * a, uint8x8x4_t b) { 10823 vst4_lane_u8(a, b, 7); 10824 } 10825 10826 // CHECK-LABEL: test_vst4_lane_u16 10827 // 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]+}}] 10828 void test_vst4_lane_u16(uint16_t * a, uint16x4x4_t b) { 10829 vst4_lane_u16(a, b, 3); 10830 } 10831 10832 // CHECK-LABEL: test_vst4_lane_u32 10833 // 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]+}}] 10834 void test_vst4_lane_u32(uint32_t * a, uint32x2x4_t b) { 10835 vst4_lane_u32(a, b, 1); 10836 } 10837 10838 // CHECK-LABEL: test_vst4_lane_s8 10839 // 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]+}}] 10840 void test_vst4_lane_s8(int8_t * a, int8x8x4_t b) { 10841 vst4_lane_s8(a, b, 7); 10842 } 10843 10844 // CHECK-LABEL: test_vst4_lane_s16 10845 // 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]+}}] 10846 void test_vst4_lane_s16(int16_t * a, int16x4x4_t b) { 10847 vst4_lane_s16(a, b, 3); 10848 } 10849 10850 // CHECK-LABEL: test_vst4_lane_s32 10851 // 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]+}}] 10852 void test_vst4_lane_s32(int32_t * a, int32x2x4_t b) { 10853 vst4_lane_s32(a, b, 1); 10854 } 10855 10856 // CHECK-LABEL: test_vst4_lane_f16 10857 // 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]+}}] 10858 void test_vst4_lane_f16(float16_t * a, float16x4x4_t b) { 10859 vst4_lane_f16(a, b, 3); 10860 } 10861 10862 // CHECK-LABEL: test_vst4_lane_f32 10863 // 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]+}}] 10864 void test_vst4_lane_f32(float32_t * a, float32x2x4_t b) { 10865 vst4_lane_f32(a, b, 1); 10866 } 10867 10868 // CHECK-LABEL: test_vst4_lane_p8 10869 // 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]+}}] 10870 void test_vst4_lane_p8(poly8_t * a, poly8x8x4_t b) { 10871 vst4_lane_p8(a, b, 7); 10872 } 10873 10874 // CHECK-LABEL: test_vst4_lane_p16 10875 // 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]+}}] 10876 void test_vst4_lane_p16(poly16_t * a, poly16x4x4_t b) { 10877 vst4_lane_p16(a, b, 3); 10878 } 10879 10880 10881 // CHECK-LABEL: test_vsub_s8 10882 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10883 int8x8_t test_vsub_s8(int8x8_t a, int8x8_t b) { 10884 return vsub_s8(a, b); 10885 } 10886 10887 // CHECK-LABEL: test_vsub_s16 10888 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10889 int16x4_t test_vsub_s16(int16x4_t a, int16x4_t b) { 10890 return vsub_s16(a, b); 10891 } 10892 10893 // CHECK-LABEL: test_vsub_s32 10894 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10895 int32x2_t test_vsub_s32(int32x2_t a, int32x2_t b) { 10896 return vsub_s32(a, b); 10897 } 10898 10899 // CHECK-LABEL: test_vsub_s64 10900 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10901 int64x1_t test_vsub_s64(int64x1_t a, int64x1_t b) { 10902 return vsub_s64(a, b); 10903 } 10904 10905 // CHECK-LABEL: test_vsub_f32 10906 // CHECK: vsub.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10907 float32x2_t test_vsub_f32(float32x2_t a, float32x2_t b) { 10908 return vsub_f32(a, b); 10909 } 10910 10911 // CHECK-LABEL: test_vsub_u8 10912 // CHECK: vsub.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10913 uint8x8_t test_vsub_u8(uint8x8_t a, uint8x8_t b) { 10914 return vsub_u8(a, b); 10915 } 10916 10917 // CHECK-LABEL: test_vsub_u16 10918 // CHECK: vsub.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10919 uint16x4_t test_vsub_u16(uint16x4_t a, uint16x4_t b) { 10920 return vsub_u16(a, b); 10921 } 10922 10923 // CHECK-LABEL: test_vsub_u32 10924 // CHECK: vsub.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10925 uint32x2_t test_vsub_u32(uint32x2_t a, uint32x2_t b) { 10926 return vsub_u32(a, b); 10927 } 10928 10929 // CHECK-LABEL: test_vsub_u64 10930 // CHECK: vsub.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 10931 uint64x1_t test_vsub_u64(uint64x1_t a, uint64x1_t b) { 10932 return vsub_u64(a, b); 10933 } 10934 10935 // CHECK-LABEL: test_vsubq_s8 10936 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10937 int8x16_t test_vsubq_s8(int8x16_t a, int8x16_t b) { 10938 return vsubq_s8(a, b); 10939 } 10940 10941 // CHECK-LABEL: test_vsubq_s16 10942 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10943 int16x8_t test_vsubq_s16(int16x8_t a, int16x8_t b) { 10944 return vsubq_s16(a, b); 10945 } 10946 10947 // CHECK-LABEL: test_vsubq_s32 10948 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10949 int32x4_t test_vsubq_s32(int32x4_t a, int32x4_t b) { 10950 return vsubq_s32(a, b); 10951 } 10952 10953 // CHECK-LABEL: test_vsubq_s64 10954 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10955 int64x2_t test_vsubq_s64(int64x2_t a, int64x2_t b) { 10956 return vsubq_s64(a, b); 10957 } 10958 10959 // CHECK-LABEL: test_vsubq_f32 10960 // CHECK: vsub.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10961 float32x4_t test_vsubq_f32(float32x4_t a, float32x4_t b) { 10962 return vsubq_f32(a, b); 10963 } 10964 10965 // CHECK-LABEL: test_vsubq_u8 10966 // CHECK: vsub.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10967 uint8x16_t test_vsubq_u8(uint8x16_t a, uint8x16_t b) { 10968 return vsubq_u8(a, b); 10969 } 10970 10971 // CHECK-LABEL: test_vsubq_u16 10972 // CHECK: vsub.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10973 uint16x8_t test_vsubq_u16(uint16x8_t a, uint16x8_t b) { 10974 return vsubq_u16(a, b); 10975 } 10976 10977 // CHECK-LABEL: test_vsubq_u32 10978 // CHECK: vsub.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10979 uint32x4_t test_vsubq_u32(uint32x4_t a, uint32x4_t b) { 10980 return vsubq_u32(a, b); 10981 } 10982 10983 // CHECK-LABEL: test_vsubq_u64 10984 // CHECK: vsub.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10985 uint64x2_t test_vsubq_u64(uint64x2_t a, uint64x2_t b) { 10986 return vsubq_u64(a, b); 10987 } 10988 10989 10990 // CHECK-LABEL: test_vsubhn_s16 10991 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10992 int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) { 10993 return vsubhn_s16(a, b); 10994 } 10995 10996 // CHECK-LABEL: test_vsubhn_s32 10997 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 10998 int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) { 10999 return vsubhn_s32(a, b); 11000 } 11001 11002 // CHECK-LABEL: test_vsubhn_s64 11003 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11004 int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) { 11005 return vsubhn_s64(a, b); 11006 } 11007 11008 // CHECK-LABEL: test_vsubhn_u16 11009 // CHECK: vsubhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11010 uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) { 11011 return vsubhn_u16(a, b); 11012 } 11013 11014 // CHECK-LABEL: test_vsubhn_u32 11015 // CHECK: vsubhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11016 uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) { 11017 return vsubhn_u32(a, b); 11018 } 11019 11020 // CHECK-LABEL: test_vsubhn_u64 11021 // CHECK: vsubhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11022 uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) { 11023 return vsubhn_u64(a, b); 11024 } 11025 11026 11027 // CHECK-LABEL: test_vsubl_s8 11028 // CHECK: vsubl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11029 int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) { 11030 return vsubl_s8(a, b); 11031 } 11032 11033 // CHECK-LABEL: test_vsubl_s16 11034 // CHECK: vsubl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11035 int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) { 11036 return vsubl_s16(a, b); 11037 } 11038 11039 // CHECK-LABEL: test_vsubl_s32 11040 // CHECK: vsubl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11041 int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) { 11042 return vsubl_s32(a, b); 11043 } 11044 11045 // CHECK-LABEL: test_vsubl_u8 11046 // CHECK: vsubl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11047 uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) { 11048 return vsubl_u8(a, b); 11049 } 11050 11051 // CHECK-LABEL: test_vsubl_u16 11052 // CHECK: vsubl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11053 uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) { 11054 return vsubl_u16(a, b); 11055 } 11056 11057 // CHECK-LABEL: test_vsubl_u32 11058 // CHECK: vsubl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11059 uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) { 11060 return vsubl_u32(a, b); 11061 } 11062 11063 11064 // CHECK-LABEL: test_vsubw_s8 11065 // CHECK: vsubw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11066 int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) { 11067 return vsubw_s8(a, b); 11068 } 11069 11070 // CHECK-LABEL: test_vsubw_s16 11071 // CHECK: vsubw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11072 int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) { 11073 return vsubw_s16(a, b); 11074 } 11075 11076 // CHECK-LABEL: test_vsubw_s32 11077 // CHECK: vsubw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11078 int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) { 11079 return vsubw_s32(a, b); 11080 } 11081 11082 // CHECK-LABEL: test_vsubw_u8 11083 // CHECK: vsubw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11084 uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) { 11085 return vsubw_u8(a, b); 11086 } 11087 11088 // CHECK-LABEL: test_vsubw_u16 11089 // CHECK: vsubw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11090 uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) { 11091 return vsubw_u16(a, b); 11092 } 11093 11094 // CHECK-LABEL: test_vsubw_u32 11095 // CHECK: vsubw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} 11096 uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) { 11097 return vsubw_u32(a, b); 11098 } 11099 11100 11101 // CHECK-LABEL: test_vtbl1_u8 11102 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11103 uint8x8_t test_vtbl1_u8(uint8x8_t a, uint8x8_t b) { 11104 return vtbl1_u8(a, b); 11105 } 11106 11107 // CHECK-LABEL: test_vtbl1_s8 11108 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11109 int8x8_t test_vtbl1_s8(int8x8_t a, int8x8_t b) { 11110 return vtbl1_s8(a, b); 11111 } 11112 11113 // CHECK-LABEL: test_vtbl1_p8 11114 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11115 poly8x8_t test_vtbl1_p8(poly8x8_t a, uint8x8_t b) { 11116 return vtbl1_p8(a, b); 11117 } 11118 11119 11120 // CHECK-LABEL: test_vtbl2_u8 11121 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11122 uint8x8_t test_vtbl2_u8(uint8x8x2_t a, uint8x8_t b) { 11123 return vtbl2_u8(a, b); 11124 } 11125 11126 // CHECK-LABEL: test_vtbl2_s8 11127 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11128 int8x8_t test_vtbl2_s8(int8x8x2_t a, int8x8_t b) { 11129 return vtbl2_s8(a, b); 11130 } 11131 11132 // CHECK-LABEL: test_vtbl2_p8 11133 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11134 poly8x8_t test_vtbl2_p8(poly8x8x2_t a, uint8x8_t b) { 11135 return vtbl2_p8(a, b); 11136 } 11137 11138 11139 // CHECK-LABEL: test_vtbl3_u8 11140 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11141 uint8x8_t test_vtbl3_u8(uint8x8x3_t a, uint8x8_t b) { 11142 return vtbl3_u8(a, b); 11143 } 11144 11145 // CHECK-LABEL: test_vtbl3_s8 11146 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11147 int8x8_t test_vtbl3_s8(int8x8x3_t a, int8x8_t b) { 11148 return vtbl3_s8(a, b); 11149 } 11150 11151 // CHECK-LABEL: test_vtbl3_p8 11152 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11153 poly8x8_t test_vtbl3_p8(poly8x8x3_t a, uint8x8_t b) { 11154 return vtbl3_p8(a, b); 11155 } 11156 11157 11158 // CHECK-LABEL: test_vtbl4_u8 11159 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11160 uint8x8_t test_vtbl4_u8(uint8x8x4_t a, uint8x8_t b) { 11161 return vtbl4_u8(a, b); 11162 } 11163 11164 // CHECK-LABEL: test_vtbl4_s8 11165 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11166 int8x8_t test_vtbl4_s8(int8x8x4_t a, int8x8_t b) { 11167 return vtbl4_s8(a, b); 11168 } 11169 11170 // CHECK-LABEL: test_vtbl4_p8 11171 // CHECK: vtbl.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11172 poly8x8_t test_vtbl4_p8(poly8x8x4_t a, uint8x8_t b) { 11173 return vtbl4_p8(a, b); 11174 } 11175 11176 11177 // CHECK-LABEL: test_vtbx1_u8 11178 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11179 uint8x8_t test_vtbx1_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { 11180 return vtbx1_u8(a, b, c); 11181 } 11182 11183 // CHECK-LABEL: test_vtbx1_s8 11184 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11185 int8x8_t test_vtbx1_s8(int8x8_t a, int8x8_t b, int8x8_t c) { 11186 return vtbx1_s8(a, b, c); 11187 } 11188 11189 // CHECK-LABEL: test_vtbx1_p8 11190 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}}, d{{[0-9]+}} 11191 poly8x8_t test_vtbx1_p8(poly8x8_t a, poly8x8_t b, uint8x8_t c) { 11192 return vtbx1_p8(a, b, c); 11193 } 11194 11195 11196 // CHECK-LABEL: test_vtbx2_u8 11197 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11198 uint8x8_t test_vtbx2_u8(uint8x8_t a, uint8x8x2_t b, uint8x8_t c) { 11199 return vtbx2_u8(a, b, c); 11200 } 11201 11202 // CHECK-LABEL: test_vtbx2_s8 11203 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11204 int8x8_t test_vtbx2_s8(int8x8_t a, int8x8x2_t b, int8x8_t c) { 11205 return vtbx2_s8(a, b, c); 11206 } 11207 11208 // CHECK-LABEL: test_vtbx2_p8 11209 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11210 poly8x8_t test_vtbx2_p8(poly8x8_t a, poly8x8x2_t b, uint8x8_t c) { 11211 return vtbx2_p8(a, b, c); 11212 } 11213 11214 11215 // CHECK-LABEL: test_vtbx3_u8 11216 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11217 uint8x8_t test_vtbx3_u8(uint8x8_t a, uint8x8x3_t b, uint8x8_t c) { 11218 return vtbx3_u8(a, b, c); 11219 } 11220 11221 // CHECK-LABEL: test_vtbx3_s8 11222 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11223 int8x8_t test_vtbx3_s8(int8x8_t a, int8x8x3_t b, int8x8_t c) { 11224 return vtbx3_s8(a, b, c); 11225 } 11226 11227 // CHECK-LABEL: test_vtbx3_p8 11228 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11229 poly8x8_t test_vtbx3_p8(poly8x8_t a, poly8x8x3_t b, uint8x8_t c) { 11230 return vtbx3_p8(a, b, c); 11231 } 11232 11233 11234 // CHECK-LABEL: test_vtbx4_u8 11235 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11236 uint8x8_t test_vtbx4_u8(uint8x8_t a, uint8x8x4_t b, uint8x8_t c) { 11237 return vtbx4_u8(a, b, c); 11238 } 11239 11240 // CHECK-LABEL: test_vtbx4_s8 11241 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11242 int8x8_t test_vtbx4_s8(int8x8_t a, int8x8x4_t b, int8x8_t c) { 11243 return vtbx4_s8(a, b, c); 11244 } 11245 11246 // CHECK-LABEL: test_vtbx4_p8 11247 // CHECK: vtbx.8 d{{[0-9]+}}, {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, d{{[0-9]+}} 11248 poly8x8_t test_vtbx4_p8(poly8x8_t a, poly8x8x4_t b, uint8x8_t c) { 11249 return vtbx4_p8(a, b, c); 11250 } 11251 11252 11253 // CHECK-LABEL: test_vtrn_s8 11254 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11255 int8x8x2_t test_vtrn_s8(int8x8_t a, int8x8_t b) { 11256 return vtrn_s8(a, b); 11257 } 11258 11259 // CHECK-LABEL: test_vtrn_s16 11260 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11261 int16x4x2_t test_vtrn_s16(int16x4_t a, int16x4_t b) { 11262 return vtrn_s16(a, b); 11263 } 11264 11265 // CHECK-LABEL: test_vtrn_s32 11266 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11267 int32x2x2_t test_vtrn_s32(int32x2_t a, int32x2_t b) { 11268 return vtrn_s32(a, b); 11269 } 11270 11271 // CHECK-LABEL: test_vtrn_u8 11272 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11273 uint8x8x2_t test_vtrn_u8(uint8x8_t a, uint8x8_t b) { 11274 return vtrn_u8(a, b); 11275 } 11276 11277 // CHECK-LABEL: test_vtrn_u16 11278 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11279 uint16x4x2_t test_vtrn_u16(uint16x4_t a, uint16x4_t b) { 11280 return vtrn_u16(a, b); 11281 } 11282 11283 // CHECK-LABEL: test_vtrn_u32 11284 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11285 uint32x2x2_t test_vtrn_u32(uint32x2_t a, uint32x2_t b) { 11286 return vtrn_u32(a, b); 11287 } 11288 11289 // CHECK-LABEL: test_vtrn_f32 11290 // CHECK: vtrn.32 d{{[0-9]+}}, d{{[0-9]+}} 11291 float32x2x2_t test_vtrn_f32(float32x2_t a, float32x2_t b) { 11292 return vtrn_f32(a, b); 11293 } 11294 11295 // CHECK-LABEL: test_vtrn_p8 11296 // CHECK: vtrn.8 d{{[0-9]+}}, d{{[0-9]+}} 11297 poly8x8x2_t test_vtrn_p8(poly8x8_t a, poly8x8_t b) { 11298 return vtrn_p8(a, b); 11299 } 11300 11301 // CHECK-LABEL: test_vtrn_p16 11302 // CHECK: vtrn.16 d{{[0-9]+}}, d{{[0-9]+}} 11303 poly16x4x2_t test_vtrn_p16(poly16x4_t a, poly16x4_t b) { 11304 return vtrn_p16(a, b); 11305 } 11306 11307 // CHECK-LABEL: test_vtrnq_s8 11308 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11309 int8x16x2_t test_vtrnq_s8(int8x16_t a, int8x16_t b) { 11310 return vtrnq_s8(a, b); 11311 } 11312 11313 // CHECK-LABEL: test_vtrnq_s16 11314 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11315 int16x8x2_t test_vtrnq_s16(int16x8_t a, int16x8_t b) { 11316 return vtrnq_s16(a, b); 11317 } 11318 11319 // CHECK-LABEL: test_vtrnq_s32 11320 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11321 int32x4x2_t test_vtrnq_s32(int32x4_t a, int32x4_t b) { 11322 return vtrnq_s32(a, b); 11323 } 11324 11325 // CHECK-LABEL: test_vtrnq_u8 11326 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11327 uint8x16x2_t test_vtrnq_u8(uint8x16_t a, uint8x16_t b) { 11328 return vtrnq_u8(a, b); 11329 } 11330 11331 // CHECK-LABEL: test_vtrnq_u16 11332 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11333 uint16x8x2_t test_vtrnq_u16(uint16x8_t a, uint16x8_t b) { 11334 return vtrnq_u16(a, b); 11335 } 11336 11337 // CHECK-LABEL: test_vtrnq_u32 11338 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11339 uint32x4x2_t test_vtrnq_u32(uint32x4_t a, uint32x4_t b) { 11340 return vtrnq_u32(a, b); 11341 } 11342 11343 // CHECK-LABEL: test_vtrnq_f32 11344 // CHECK: vtrn.32 q{{[0-9]+}}, q{{[0-9]+}} 11345 float32x4x2_t test_vtrnq_f32(float32x4_t a, float32x4_t b) { 11346 return vtrnq_f32(a, b); 11347 } 11348 11349 // CHECK-LABEL: test_vtrnq_p8 11350 // CHECK: vtrn.8 q{{[0-9]+}}, q{{[0-9]+}} 11351 poly8x16x2_t test_vtrnq_p8(poly8x16_t a, poly8x16_t b) { 11352 return vtrnq_p8(a, b); 11353 } 11354 11355 // CHECK-LABEL: test_vtrnq_p16 11356 // CHECK: vtrn.16 q{{[0-9]+}}, q{{[0-9]+}} 11357 poly16x8x2_t test_vtrnq_p16(poly16x8_t a, poly16x8_t b) { 11358 return vtrnq_p16(a, b); 11359 } 11360 11361 11362 // CHECK-LABEL: test_vtst_s8 11363 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11364 uint8x8_t test_vtst_s8(int8x8_t a, int8x8_t b) { 11365 return vtst_s8(a, b); 11366 } 11367 11368 // CHECK-LABEL: test_vtst_s16 11369 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11370 uint16x4_t test_vtst_s16(int16x4_t a, int16x4_t b) { 11371 return vtst_s16(a, b); 11372 } 11373 11374 // CHECK-LABEL: test_vtst_s32 11375 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11376 uint32x2_t test_vtst_s32(int32x2_t a, int32x2_t b) { 11377 return vtst_s32(a, b); 11378 } 11379 11380 // CHECK-LABEL: test_vtst_u8 11381 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11382 uint8x8_t test_vtst_u8(uint8x8_t a, uint8x8_t b) { 11383 return vtst_u8(a, b); 11384 } 11385 11386 // CHECK-LABEL: test_vtst_u16 11387 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11388 uint16x4_t test_vtst_u16(uint16x4_t a, uint16x4_t b) { 11389 return vtst_u16(a, b); 11390 } 11391 11392 // CHECK-LABEL: test_vtst_u32 11393 // CHECK: vtst.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11394 uint32x2_t test_vtst_u32(uint32x2_t a, uint32x2_t b) { 11395 return vtst_u32(a, b); 11396 } 11397 11398 // CHECK-LABEL: test_vtst_p8 11399 // CHECK: vtst.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11400 uint8x8_t test_vtst_p8(poly8x8_t a, poly8x8_t b) { 11401 return vtst_p8(a, b); 11402 } 11403 11404 // CHECK-LABEL: test_vtst_p16 11405 // CHECK: vtst.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} 11406 uint16x4_t test_vtst_p16(poly16x4_t a, poly16x4_t b) { 11407 return vtst_p16(a, b); 11408 } 11409 11410 // CHECK-LABEL: test_vtstq_s8 11411 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11412 uint8x16_t test_vtstq_s8(int8x16_t a, int8x16_t b) { 11413 return vtstq_s8(a, b); 11414 } 11415 11416 // CHECK-LABEL: test_vtstq_s16 11417 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11418 uint16x8_t test_vtstq_s16(int16x8_t a, int16x8_t b) { 11419 return vtstq_s16(a, b); 11420 } 11421 11422 // CHECK-LABEL: test_vtstq_s32 11423 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11424 uint32x4_t test_vtstq_s32(int32x4_t a, int32x4_t b) { 11425 return vtstq_s32(a, b); 11426 } 11427 11428 // CHECK-LABEL: test_vtstq_u8 11429 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11430 uint8x16_t test_vtstq_u8(uint8x16_t a, uint8x16_t b) { 11431 return vtstq_u8(a, b); 11432 } 11433 11434 // CHECK-LABEL: test_vtstq_u16 11435 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11436 uint16x8_t test_vtstq_u16(uint16x8_t a, uint16x8_t b) { 11437 return vtstq_u16(a, b); 11438 } 11439 11440 // CHECK-LABEL: test_vtstq_u32 11441 // CHECK: vtst.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11442 uint32x4_t test_vtstq_u32(uint32x4_t a, uint32x4_t b) { 11443 return vtstq_u32(a, b); 11444 } 11445 11446 // CHECK-LABEL: test_vtstq_p8 11447 // CHECK: vtst.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11448 uint8x16_t test_vtstq_p8(poly8x16_t a, poly8x16_t b) { 11449 return vtstq_p8(a, b); 11450 } 11451 11452 // CHECK-LABEL: test_vtstq_p16 11453 // CHECK: vtst.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} 11454 uint16x8_t test_vtstq_p16(poly16x8_t a, poly16x8_t b) { 11455 return vtstq_p16(a, b); 11456 } 11457 11458 11459 // CHECK-LABEL: test_vuzp_s8 11460 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11461 int8x8x2_t test_vuzp_s8(int8x8_t a, int8x8_t b) { 11462 return vuzp_s8(a, b); 11463 } 11464 11465 // CHECK-LABEL: test_vuzp_s16 11466 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11467 int16x4x2_t test_vuzp_s16(int16x4_t a, int16x4_t b) { 11468 return vuzp_s16(a, b); 11469 } 11470 11471 // CHECK-LABEL: test_vuzp_s32 11472 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11473 int32x2x2_t test_vuzp_s32(int32x2_t a, int32x2_t b) { 11474 return vuzp_s32(a, b); 11475 } 11476 11477 // CHECK-LABEL: test_vuzp_u8 11478 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11479 uint8x8x2_t test_vuzp_u8(uint8x8_t a, uint8x8_t b) { 11480 return vuzp_u8(a, b); 11481 } 11482 11483 // CHECK-LABEL: test_vuzp_u16 11484 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11485 uint16x4x2_t test_vuzp_u16(uint16x4_t a, uint16x4_t b) { 11486 return vuzp_u16(a, b); 11487 } 11488 11489 // CHECK-LABEL: test_vuzp_u32 11490 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11491 uint32x2x2_t test_vuzp_u32(uint32x2_t a, uint32x2_t b) { 11492 return vuzp_u32(a, b); 11493 } 11494 11495 // CHECK-LABEL: test_vuzp_f32 11496 // CHECK: {{vtrn|vuzp}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11497 float32x2x2_t test_vuzp_f32(float32x2_t a, float32x2_t b) { 11498 return vuzp_f32(a, b); 11499 } 11500 11501 // CHECK-LABEL: test_vuzp_p8 11502 // CHECK: vuzp.8 d{{[0-9]+}}, d{{[0-9]+}} 11503 poly8x8x2_t test_vuzp_p8(poly8x8_t a, poly8x8_t b) { 11504 return vuzp_p8(a, b); 11505 } 11506 11507 // CHECK-LABEL: test_vuzp_p16 11508 // CHECK: vuzp.16 d{{[0-9]+}}, d{{[0-9]+}} 11509 poly16x4x2_t test_vuzp_p16(poly16x4_t a, poly16x4_t b) { 11510 return vuzp_p16(a, b); 11511 } 11512 11513 // CHECK-LABEL: test_vuzpq_s8 11514 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11515 int8x16x2_t test_vuzpq_s8(int8x16_t a, int8x16_t b) { 11516 return vuzpq_s8(a, b); 11517 } 11518 11519 // CHECK-LABEL: test_vuzpq_s16 11520 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11521 int16x8x2_t test_vuzpq_s16(int16x8_t a, int16x8_t b) { 11522 return vuzpq_s16(a, b); 11523 } 11524 11525 // CHECK-LABEL: test_vuzpq_s32 11526 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11527 int32x4x2_t test_vuzpq_s32(int32x4_t a, int32x4_t b) { 11528 return vuzpq_s32(a, b); 11529 } 11530 11531 // CHECK-LABEL: test_vuzpq_u8 11532 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11533 uint8x16x2_t test_vuzpq_u8(uint8x16_t a, uint8x16_t b) { 11534 return vuzpq_u8(a, b); 11535 } 11536 11537 // CHECK-LABEL: test_vuzpq_u16 11538 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11539 uint16x8x2_t test_vuzpq_u16(uint16x8_t a, uint16x8_t b) { 11540 return vuzpq_u16(a, b); 11541 } 11542 11543 // CHECK-LABEL: test_vuzpq_u32 11544 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11545 uint32x4x2_t test_vuzpq_u32(uint32x4_t a, uint32x4_t b) { 11546 return vuzpq_u32(a, b); 11547 } 11548 11549 // CHECK-LABEL: test_vuzpq_f32 11550 // CHECK: {{vtrn|vuzp}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11551 float32x4x2_t test_vuzpq_f32(float32x4_t a, float32x4_t b) { 11552 return vuzpq_f32(a, b); 11553 } 11554 11555 // CHECK-LABEL: test_vuzpq_p8 11556 // CHECK: vuzp.8 q{{[0-9]+}}, q{{[0-9]+}} 11557 poly8x16x2_t test_vuzpq_p8(poly8x16_t a, poly8x16_t b) { 11558 return vuzpq_p8(a, b); 11559 } 11560 11561 // CHECK-LABEL: test_vuzpq_p16 11562 // CHECK: vuzp.16 q{{[0-9]+}}, q{{[0-9]+}} 11563 poly16x8x2_t test_vuzpq_p16(poly16x8_t a, poly16x8_t b) { 11564 return vuzpq_p16(a, b); 11565 } 11566 11567 11568 // CHECK-LABEL: test_vzip_s8 11569 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11570 int8x8x2_t test_vzip_s8(int8x8_t a, int8x8_t b) { 11571 return vzip_s8(a, b); 11572 } 11573 11574 // CHECK-LABEL: test_vzip_s16 11575 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11576 int16x4x2_t test_vzip_s16(int16x4_t a, int16x4_t b) { 11577 return vzip_s16(a, b); 11578 } 11579 11580 // CHECK-LABEL: test_vzip_s32 11581 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11582 int32x2x2_t test_vzip_s32(int32x2_t a, int32x2_t b) { 11583 return vzip_s32(a, b); 11584 } 11585 11586 // CHECK-LABEL: test_vzip_u8 11587 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11588 uint8x8x2_t test_vzip_u8(uint8x8_t a, uint8x8_t b) { 11589 return vzip_u8(a, b); 11590 } 11591 11592 // CHECK-LABEL: test_vzip_u16 11593 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11594 uint16x4x2_t test_vzip_u16(uint16x4_t a, uint16x4_t b) { 11595 return vzip_u16(a, b); 11596 } 11597 11598 // CHECK-LABEL: test_vzip_u32 11599 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11600 uint32x2x2_t test_vzip_u32(uint32x2_t a, uint32x2_t b) { 11601 return vzip_u32(a, b); 11602 } 11603 11604 // CHECK-LABEL: test_vzip_f32 11605 // CHECK: {{vtrn|vzip}}.32 d{{[0-9]+}}, d{{[0-9]+}} 11606 float32x2x2_t test_vzip_f32(float32x2_t a, float32x2_t b) { 11607 return vzip_f32(a, b); 11608 } 11609 11610 // CHECK-LABEL: test_vzip_p8 11611 // CHECK: vzip.8 d{{[0-9]+}}, d{{[0-9]+}} 11612 poly8x8x2_t test_vzip_p8(poly8x8_t a, poly8x8_t b) { 11613 return vzip_p8(a, b); 11614 } 11615 11616 // CHECK-LABEL: test_vzip_p16 11617 // CHECK: vzip.16 d{{[0-9]+}}, d{{[0-9]+}} 11618 poly16x4x2_t test_vzip_p16(poly16x4_t a, poly16x4_t b) { 11619 return vzip_p16(a, b); 11620 } 11621 11622 // CHECK-LABEL: test_vzipq_s8 11623 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11624 int8x16x2_t test_vzipq_s8(int8x16_t a, int8x16_t b) { 11625 return vzipq_s8(a, b); 11626 } 11627 11628 // CHECK-LABEL: test_vzipq_s16 11629 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11630 int16x8x2_t test_vzipq_s16(int16x8_t a, int16x8_t b) { 11631 return vzipq_s16(a, b); 11632 } 11633 11634 // CHECK-LABEL: test_vzipq_s32 11635 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11636 int32x4x2_t test_vzipq_s32(int32x4_t a, int32x4_t b) { 11637 return vzipq_s32(a, b); 11638 } 11639 11640 // CHECK-LABEL: test_vzipq_u8 11641 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11642 uint8x16x2_t test_vzipq_u8(uint8x16_t a, uint8x16_t b) { 11643 return vzipq_u8(a, b); 11644 } 11645 11646 // CHECK-LABEL: test_vzipq_u16 11647 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11648 uint16x8x2_t test_vzipq_u16(uint16x8_t a, uint16x8_t b) { 11649 return vzipq_u16(a, b); 11650 } 11651 11652 // CHECK-LABEL: test_vzipq_u32 11653 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11654 uint32x4x2_t test_vzipq_u32(uint32x4_t a, uint32x4_t b) { 11655 return vzipq_u32(a, b); 11656 } 11657 11658 // CHECK-LABEL: test_vzipq_f32 11659 // CHECK: {{vtrn|vzip}}.32 q{{[0-9]+}}, q{{[0-9]+}} 11660 float32x4x2_t test_vzipq_f32(float32x4_t a, float32x4_t b) { 11661 return vzipq_f32(a, b); 11662 } 11663 11664 // CHECK-LABEL: test_vzipq_p8 11665 // CHECK: vzip.8 q{{[0-9]+}}, q{{[0-9]+}} 11666 poly8x16x2_t test_vzipq_p8(poly8x16_t a, poly8x16_t b) { 11667 return vzipq_p8(a, b); 11668 } 11669 11670 // CHECK-LABEL: test_vzipq_p16 11671 // CHECK: vzip.16 q{{[0-9]+}}, q{{[0-9]+}} 11672 poly16x8x2_t test_vzipq_p16(poly16x8_t a, poly16x8_t b) { 11673 return vzipq_p16(a, b); 11674 } 11675 11676 11677
