1 // REQUIRES: aarch64-registered-target 2 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +neon \ 3 // RUN: -ffp-contract=fast -S -O3 -o - %s | FileCheck %s 4 5 // Test new aarch64 intrinsics and types 6 7 #include <arm_neon.h> 8 9 int8x8_t test_vadd_s8(int8x8_t v1, int8x8_t v2) { 10 // CHECK: test_vadd_s8 11 return vadd_s8(v1, v2); 12 // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 13 } 14 15 int16x4_t test_vadd_s16(int16x4_t v1, int16x4_t v2) { 16 // CHECK: test_vadd_s16 17 return vadd_s16(v1, v2); 18 // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 19 } 20 21 int32x2_t test_vadd_s32(int32x2_t v1, int32x2_t v2) { 22 // CHECK: test_vadd_s32 23 return vadd_s32(v1, v2); 24 // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 25 } 26 27 int64x1_t test_vadd_s64(int64x1_t v1, int64x1_t v2) { 28 // CHECK: test_vadd_s64 29 return vadd_s64(v1, v2); 30 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 31 } 32 33 float32x2_t test_vadd_f32(float32x2_t v1, float32x2_t v2) { 34 // CHECK: test_vadd_f32 35 return vadd_f32(v1, v2); 36 // CHECK: fadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 37 } 38 39 uint8x8_t test_vadd_u8(uint8x8_t v1, uint8x8_t v2) { 40 // CHECK: test_vadd_u8 41 return vadd_u8(v1, v2); 42 // CHECK: add {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 43 } 44 45 uint16x4_t test_vadd_u16(uint16x4_t v1, uint16x4_t v2) { 46 // CHECK: test_vadd_u16 47 return vadd_u16(v1, v2); 48 // CHECK: add {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 49 } 50 51 uint32x2_t test_vadd_u32(uint32x2_t v1, uint32x2_t v2) { 52 // CHECK: test_vadd_u32 53 return vadd_u32(v1, v2); 54 // CHECK: add {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 55 } 56 57 uint64x1_t test_vadd_u64(uint64x1_t v1, uint64x1_t v2) { 58 // CHECK: test_vadd_u64 59 return vadd_u64(v1, v2); 60 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 61 } 62 63 int8x16_t test_vaddq_s8(int8x16_t v1, int8x16_t v2) { 64 // CHECK: test_vaddq_s8 65 return vaddq_s8(v1, v2); 66 // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 67 } 68 69 int16x8_t test_vaddq_s16(int16x8_t v1, int16x8_t v2) { 70 // CHECK: test_vaddq_s16 71 return vaddq_s16(v1, v2); 72 // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 73 } 74 75 int32x4_t test_vaddq_s32(int32x4_t v1,int32x4_t v2) { 76 // CHECK: test_vaddq_s32 77 return vaddq_s32(v1, v2); 78 // CHECK: add {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 79 } 80 81 int64x2_t test_vaddq_s64(int64x2_t v1, int64x2_t v2) { 82 // CHECK: test_vaddq_s64 83 return vaddq_s64(v1, v2); 84 // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 85 } 86 87 float32x4_t test_vaddq_f32(float32x4_t v1, float32x4_t v2) { 88 // CHECK: test_vaddq_f32 89 return vaddq_f32(v1, v2); 90 // CHECK: fadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 91 } 92 93 float64x2_t test_vaddq_f64(float64x2_t v1, float64x2_t v2) { 94 // CHECK: test_vaddq_f64 95 return vaddq_f64(v1, v2); 96 // CHECK: fadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 97 } 98 99 uint8x16_t test_vaddq_u8(uint8x16_t v1, uint8x16_t v2) { 100 // CHECK: test_vaddq_u8 101 return vaddq_u8(v1, v2); 102 // CHECK: add {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 103 } 104 105 uint16x8_t test_vaddq_u16(uint16x8_t v1, uint16x8_t v2) { 106 // CHECK: test_vaddq_u16 107 return vaddq_u16(v1, v2); 108 // CHECK: add {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 109 } 110 111 uint32x4_t test_vaddq_u32(uint32x4_t v1, uint32x4_t v2) { 112 // CHECK: vaddq_u32 113 return vaddq_u32(v1, v2); 114 // CHECK: add {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 115 } 116 117 uint64x2_t test_vaddq_u64(uint64x2_t v1, uint64x2_t v2) { 118 // CHECK: test_vaddq_u64 119 return vaddq_u64(v1, v2); 120 // CHECK: add {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 121 } 122 123 int8x8_t test_vsub_s8(int8x8_t v1, int8x8_t v2) { 124 // CHECK: test_vsub_s8 125 return vsub_s8(v1, v2); 126 // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 127 } 128 int16x4_t test_vsub_s16(int16x4_t v1, int16x4_t v2) { 129 // CHECK: test_vsub_s16 130 return vsub_s16(v1, v2); 131 // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 132 } 133 int32x2_t test_vsub_s32(int32x2_t v1, int32x2_t v2) { 134 // CHECK: test_vsub_s32 135 return vsub_s32(v1, v2); 136 // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 137 } 138 139 int64x1_t test_vsub_s64(int64x1_t v1, int64x1_t v2) { 140 // CHECK: test_vsub_s64 141 return vsub_s64(v1, v2); 142 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 143 } 144 145 float32x2_t test_vsub_f32(float32x2_t v1, float32x2_t v2) { 146 // CHECK: test_vsub_f32 147 return vsub_f32(v1, v2); 148 // CHECK: fsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 149 } 150 151 uint8x8_t test_vsub_u8(uint8x8_t v1, uint8x8_t v2) { 152 // CHECK: test_vsub_u8 153 return vsub_u8(v1, v2); 154 // CHECK: sub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 155 } 156 157 uint16x4_t test_vsub_u16(uint16x4_t v1, uint16x4_t v2) { 158 // CHECK: test_vsub_u16 159 return vsub_u16(v1, v2); 160 // CHECK: sub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 161 } 162 163 uint32x2_t test_vsub_u32(uint32x2_t v1, uint32x2_t v2) { 164 // CHECK: test_vsub_u32 165 return vsub_u32(v1, v2); 166 // CHECK: sub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 167 } 168 169 uint64x1_t test_vsub_u64(uint64x1_t v1, uint64x1_t v2) { 170 // CHECK: test_vsub_u64 171 return vsub_u64(v1, v2); 172 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 173 } 174 175 int8x16_t test_vsubq_s8(int8x16_t v1, int8x16_t v2) { 176 // CHECK: test_vsubq_s8 177 return vsubq_s8(v1, v2); 178 // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 179 } 180 181 int16x8_t test_vsubq_s16(int16x8_t v1, int16x8_t v2) { 182 // CHECK: test_vsubq_s16 183 return vsubq_s16(v1, v2); 184 // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 185 } 186 187 int32x4_t test_vsubq_s32(int32x4_t v1,int32x4_t v2) { 188 // CHECK: test_vsubq_s32 189 return vsubq_s32(v1, v2); 190 // CHECK: sub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 191 } 192 193 int64x2_t test_vsubq_s64(int64x2_t v1, int64x2_t v2) { 194 // CHECK: test_vsubq_s64 195 return vsubq_s64(v1, v2); 196 // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 197 } 198 199 float32x4_t test_vsubq_f32(float32x4_t v1, float32x4_t v2) { 200 // CHECK: test_vsubq_f32 201 return vsubq_f32(v1, v2); 202 // CHECK: fsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 203 } 204 205 float64x2_t test_vsubq_f64(float64x2_t v1, float64x2_t v2) { 206 // CHECK: test_vsubq_f64 207 return vsubq_f64(v1, v2); 208 // CHECK: fsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 209 } 210 211 uint8x16_t test_vsubq_u8(uint8x16_t v1, uint8x16_t v2) { 212 // CHECK: test_vsubq_u8 213 return vsubq_u8(v1, v2); 214 // CHECK: sub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 215 } 216 217 uint16x8_t test_vsubq_u16(uint16x8_t v1, uint16x8_t v2) { 218 // CHECK: test_vsubq_u16 219 return vsubq_u16(v1, v2); 220 // CHECK: sub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 221 } 222 223 uint32x4_t test_vsubq_u32(uint32x4_t v1, uint32x4_t v2) { 224 // CHECK: vsubq_u32 225 return vsubq_u32(v1, v2); 226 // CHECK: sub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 227 } 228 229 uint64x2_t test_vsubq_u64(uint64x2_t v1, uint64x2_t v2) { 230 // CHECK: test_vsubq_u64 231 return vsubq_u64(v1, v2); 232 // CHECK: sub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 233 } 234 235 int8x8_t test_vmul_s8(int8x8_t v1, int8x8_t v2) { 236 // CHECK: test_vmul_s8 237 return vmul_s8(v1, v2); 238 // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 239 } 240 241 int16x4_t test_vmul_s16(int16x4_t v1, int16x4_t v2) { 242 // CHECK: test_vmul_s16 243 return vmul_s16(v1, v2); 244 // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 245 } 246 247 int32x2_t test_vmul_s32(int32x2_t v1, int32x2_t v2) { 248 // CHECK: test_vmul_s32 249 return vmul_s32(v1, v2); 250 // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 251 } 252 253 float32x2_t test_vmul_f32(float32x2_t v1, float32x2_t v2) { 254 // CHECK: test_vmul_f32 255 return vmul_f32(v1, v2); 256 // CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 257 } 258 259 260 uint8x8_t test_vmul_u8(uint8x8_t v1, uint8x8_t v2) { 261 // CHECK: test_vmul_u8 262 return vmul_u8(v1, v2); 263 // CHECK: mul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 264 } 265 266 uint16x4_t test_vmul_u16(uint16x4_t v1, uint16x4_t v2) { 267 // CHECK: test_vmul_u16 268 return vmul_u16(v1, v2); 269 // CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 270 } 271 272 uint32x2_t test_vmul_u32(uint32x2_t v1, uint32x2_t v2) { 273 // CHECK: test_vmul_u32 274 return vmul_u32(v1, v2); 275 // CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 276 } 277 278 int8x16_t test_vmulq_s8(int8x16_t v1, int8x16_t v2) { 279 // CHECK: test_vmulq_s8 280 return vmulq_s8(v1, v2); 281 // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 282 } 283 284 int16x8_t test_vmulq_s16(int16x8_t v1, int16x8_t v2) { 285 // CHECK: test_vmulq_s16 286 return vmulq_s16(v1, v2); 287 // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 288 } 289 290 int32x4_t test_vmulq_s32(int32x4_t v1, int32x4_t v2) { 291 // CHECK: test_vmulq_s32 292 return vmulq_s32(v1, v2); 293 // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 294 } 295 296 uint8x16_t test_vmulq_u8(uint8x16_t v1, uint8x16_t v2) { 297 // CHECK: test_vmulq_u8 298 return vmulq_u8(v1, v2); 299 // CHECK: mul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 300 } 301 302 uint16x8_t test_vmulq_u16(uint16x8_t v1, uint16x8_t v2) { 303 // CHECK: test_vmulq_u16 304 return vmulq_u16(v1, v2); 305 // CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 306 } 307 308 uint32x4_t test_vmulq_u32(uint32x4_t v1, uint32x4_t v2) { 309 // CHECK: test_vmulq_u32 310 return vmulq_u32(v1, v2); 311 // CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 312 } 313 314 float32x4_t test_vmulq_f32(float32x4_t v1, float32x4_t v2) { 315 // CHECK: test_vmulq_f32 316 return vmulq_f32(v1, v2); 317 // CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 318 } 319 320 float64x2_t test_vmulq_f64(float64x2_t v1, float64x2_t v2) { 321 // CHECK: test_vmulq_f64 322 return vmulq_f64(v1, v2); 323 // CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 324 } 325 326 poly8x8_t test_vmul_p8(poly8x8_t v1, poly8x8_t v2) { 327 // test_vmul_p8 328 return vmul_p8(v1, v2); 329 // pmul {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 330 } 331 332 poly8x16_t test_vmulq_p8(poly8x16_t v1, poly8x16_t v2) { 333 // test_vmulq_p8 334 return vmulq_p8(v1, v2); 335 // pmul {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 336 } 337 338 339 int8x8_t test_vmla_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) { 340 // CHECK: test_vmla_s8 341 return vmla_s8(v1, v2, v3); 342 // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 343 } 344 345 int8x8_t test_vmla_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) { 346 // CHECK: test_vmla_s16 347 return vmla_s16(v1, v2, v3); 348 // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 349 } 350 351 int32x2_t test_vmla_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) { 352 // CHECK: test_vmla_s32 353 return vmla_s32(v1, v2, v3); 354 // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 355 } 356 357 float32x2_t test_vmla_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) { 358 // CHECK: test_vmla_f32 359 return vmla_f32(v1, v2, v3); 360 // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 361 } 362 363 uint8x8_t test_vmla_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) { 364 // CHECK: test_vmla_u8 365 return vmla_u8(v1, v2, v3); 366 // CHECK: mla {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 367 } 368 369 uint16x4_t test_vmla_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) { 370 // CHECK: test_vmla_u16 371 return vmla_u16(v1, v2, v3); 372 // CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 373 } 374 375 uint32x2_t test_vmla_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) { 376 // CHECK: test_vmla_u32 377 return vmla_u32(v1, v2, v3); 378 // CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 379 } 380 381 int8x16_t test_vmlaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) { 382 // CHECK: test_vmlaq_s8 383 return vmlaq_s8(v1, v2, v3); 384 // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 385 } 386 387 int16x8_t test_vmlaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) { 388 // CHECK: test_vmlaq_s16 389 return vmlaq_s16(v1, v2, v3); 390 // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 391 } 392 393 int32x4_t test_vmlaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) { 394 // CHECK: test_vmlaq_s32 395 return vmlaq_s32(v1, v2, v3); 396 // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 397 } 398 399 float32x4_t test_vmlaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) { 400 // CHECK: test_vmlaq_f32 401 return vmlaq_f32(v1, v2, v3); 402 // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 403 } 404 405 uint8x16_t test_vmlaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) { 406 // CHECK: test_vmlaq_u8 407 return vmlaq_u8(v1, v2, v3); 408 // CHECK: mla {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 409 } 410 411 uint16x8_t test_vmlaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) { 412 // CHECK: test_vmlaq_u16 413 return vmlaq_u16(v1, v2, v3); 414 // CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 415 } 416 417 uint32x4_t test_vmlaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) { 418 // CHECK: test_vmlaq_u32 419 return vmlaq_u32(v1, v2, v3); 420 // CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 421 } 422 423 float64x2_t test_vmlaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) { 424 // CHECK: test_vmlaq_f64 425 return vmlaq_f64(v1, v2, v3); 426 // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 427 } 428 429 int8x8_t test_vmls_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) { 430 // CHECK: test_vmls_s8 431 return vmls_s8(v1, v2, v3); 432 // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 433 } 434 435 int8x8_t test_vmls_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) { 436 // CHECK: test_vmls_s16 437 return vmls_s16(v1, v2, v3); 438 // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 439 } 440 441 int32x2_t test_vmls_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) { 442 // CHECK: test_vmls_s32 443 return vmls_s32(v1, v2, v3); 444 // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 445 } 446 447 float32x2_t test_vmls_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) { 448 // CHECK: test_vmls_f32 449 return vmls_f32(v1, v2, v3); 450 // CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 451 } 452 453 uint8x8_t test_vmls_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) { 454 // CHECK: test_vmls_u8 455 return vmls_u8(v1, v2, v3); 456 // CHECK: mls {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 457 } 458 459 uint16x4_t test_vmls_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) { 460 // CHECK: test_vmls_u16 461 return vmls_u16(v1, v2, v3); 462 // CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 463 } 464 465 uint32x2_t test_vmls_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) { 466 // CHECK: test_vmls_u32 467 return vmls_u32(v1, v2, v3); 468 // CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 469 } 470 int8x16_t test_vmlsq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) { 471 // CHECK: test_vmlsq_s8 472 return vmlsq_s8(v1, v2, v3); 473 // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 474 } 475 476 int16x8_t test_vmlsq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) { 477 // CHECK: test_vmlsq_s16 478 return vmlsq_s16(v1, v2, v3); 479 // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 480 } 481 482 int32x4_t test_vmlsq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) { 483 // CHECK: test_vmlsq_s32 484 return vmlsq_s32(v1, v2, v3); 485 // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 486 } 487 488 float32x4_t test_vmlsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) { 489 // CHECK: test_vmlsq_f32 490 return vmlsq_f32(v1, v2, v3); 491 // CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 492 } 493 uint8x16_t test_vmlsq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) { 494 // CHECK: test_vmlsq_u8 495 return vmlsq_u8(v1, v2, v3); 496 // CHECK: mls {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 497 } 498 499 uint16x8_t test_vmlsq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) { 500 // CHECK: test_vmlsq_u16 501 return vmlsq_u16(v1, v2, v3); 502 // CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 503 } 504 505 uint32x4_t test_vmlsq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) { 506 // CHECK: test_vmlsq_u32 507 return vmlsq_u32(v1, v2, v3); 508 // CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 509 } 510 511 float64x2_t test_vmlsq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) { 512 // CHECK: test_vmlsq_f64 513 return vmlsq_f64(v1, v2, v3); 514 // CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 515 } 516 float32x2_t test_vfma_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) { 517 // CHECK: test_vfma_f32 518 return vfma_f32(v1, v2, v3); 519 // CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 520 } 521 522 float32x4_t test_vfmaq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) { 523 // CHECK: test_vfmaq_f32 524 return vfmaq_f32(v1, v2, v3); 525 // CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 526 } 527 528 float64x2_t test_vfmaq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) { 529 // CHECK: test_vfmaq_f64 530 return vfmaq_f64(v1, v2, v3); 531 // CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 532 } 533 float32x2_t test_vfms_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) { 534 // CHECK: test_vfms_f32 535 return vfms_f32(v1, v2, v3); 536 // CHECK: fmls v0.2s, v1.2s, v2.2s 537 } 538 539 float32x4_t test_vfmsq_f32(float32x4_t v1, float32x4_t v2, float32x4_t v3) { 540 // CHECK: test_vfmsq_f32 541 return vfmsq_f32(v1, v2, v3); 542 // CHECK: fmls v0.4s, v1.4s, v2.4s 543 } 544 545 float64x2_t test_vfmsq_f64(float64x2_t v1, float64x2_t v2, float64x2_t v3) { 546 // CHECK: vfmsq_f64 547 return vfmsq_f64(v1, v2, v3); 548 // CHECK: fmls v0.2d, v1.2d, v2.2d 549 } 550 551 float64x2_t test_vdivq_f64(float64x2_t v1, float64x2_t v2) { 552 // CHECK: test_vdivq_f64 553 return vdivq_f64(v1, v2); 554 // CHECK: fdiv {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 555 } 556 557 float32x4_t test_vdivq_f32(float32x4_t v1, float32x4_t v2) { 558 // CHECK: test_vdivq_f32 559 return vdivq_f32(v1, v2); 560 // CHECK: fdiv {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 561 } 562 563 float32x2_t test_vdiv_f32(float32x2_t v1, float32x2_t v2) { 564 // CHECK: test_vdiv_f32 565 return vdiv_f32(v1, v2); 566 // CHECK: fdiv {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 567 } 568 569 int8x8_t test_vaba_s8(int8x8_t v1, int8x8_t v2, int8x8_t v3) { 570 // CHECK: test_vaba_s8 571 return vaba_s8(v1, v2, v3); 572 // CHECK: saba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 573 } 574 575 int16x4_t test_vaba_s16(int16x4_t v1, int16x4_t v2, int16x4_t v3) { 576 // CHECK: test_vaba_s16 577 return vaba_s16(v1, v2, v3); 578 // CHECK: saba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 579 } 580 581 int32x2_t test_vaba_s32(int32x2_t v1, int32x2_t v2, int32x2_t v3) { 582 // CHECK: test_vaba_s32 583 return vaba_s32(v1, v2, v3); 584 // CHECK: saba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 585 } 586 587 uint8x8_t test_vaba_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) { 588 // CHECK: test_vaba_u8 589 return vaba_u8(v1, v2, v3); 590 // CHECK: uaba {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 591 } 592 593 uint16x4_t test_vaba_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) { 594 // CHECK: test_vaba_u16 595 return vaba_u16(v1, v2, v3); 596 // CHECK: uaba {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 597 } 598 599 uint32x2_t test_vaba_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) { 600 // CHECK: test_vaba_u32 601 return vaba_u32(v1, v2, v3); 602 // CHECK: uaba {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 603 } 604 605 int8x16_t test_vabaq_s8(int8x16_t v1, int8x16_t v2, int8x16_t v3) { 606 // CHECK: test_vabaq_s8 607 return vabaq_s8(v1, v2, v3); 608 // CHECK: saba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 609 } 610 611 int16x8_t test_vabaq_s16(int16x8_t v1, int16x8_t v2, int16x8_t v3) { 612 // CHECK: test_vabaq_s16 613 return vabaq_s16(v1, v2, v3); 614 // CHECK: saba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 615 } 616 617 int32x4_t test_vabaq_s32(int32x4_t v1, int32x4_t v2, int32x4_t v3) { 618 // CHECK: test_vabaq_s32 619 return vabaq_s32(v1, v2, v3); 620 // CHECK: saba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 621 } 622 623 uint8x16_t test_vabaq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) { 624 // CHECK: test_vabaq_u8 625 return vabaq_u8(v1, v2, v3); 626 // CHECK: uaba {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 627 } 628 629 uint16x8_t test_vabaq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) { 630 // CHECK: test_vabaq_u16 631 return vabaq_u16(v1, v2, v3); 632 // CHECK: uaba {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 633 } 634 635 uint32x4_t test_vabaq_u32(uint32x4_t v1, uint32x4_t v2, uint32x4_t v3) { 636 // CHECK: test_vabaq_u32 637 return vabaq_u32(v1, v2, v3); 638 // CHECK: uaba {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 639 } 640 641 int8x8_t test_vabd_s8(int8x8_t v1, int8x8_t v2) { 642 // CHECK: test_vabd_s8 643 return vabd_s8(v1, v2); 644 // CHECK: sabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 645 } 646 647 int16x4_t test_vabd_s16(int16x4_t v1, int16x4_t v2) { 648 // CHECK: test_vabd_s16 649 return vabd_s16(v1, v2); 650 // CHECK: sabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 651 } 652 653 int32x2_t test_vabd_s32(int32x2_t v1, int32x2_t v2) { 654 // CHECK: test_vabd_s32 655 return vabd_s32(v1, v2); 656 // CHECK: sabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 657 } 658 659 uint8x8_t test_vabd_u8(uint8x8_t v1, uint8x8_t v2) { 660 // CHECK: test_vabd_u8 661 return vabd_u8(v1, v2); 662 // CHECK: uabd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 663 } 664 665 uint16x4_t test_vabd_u16(uint16x4_t v1, uint16x4_t v2) { 666 // CHECK: test_vabd_u16 667 return vabd_u16(v1, v2); 668 // CHECK: uabd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 669 } 670 671 uint32x2_t test_vabd_u32(uint32x2_t v1, uint32x2_t v2) { 672 // CHECK: test_vabd_u32 673 return vabd_u32(v1, v2); 674 // CHECK: uabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 675 } 676 677 float32x2_t test_vabd_f32(float32x2_t v1, float32x2_t v2) { 678 // CHECK: test_vabd_f32 679 return vabd_f32(v1, v2); 680 // CHECK: fabd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 681 } 682 683 int8x16_t test_vabdq_s8(int8x16_t v1, int8x16_t v2) { 684 // CHECK: test_vabdq_s8 685 return vabdq_s8(v1, v2); 686 // CHECK: sabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 687 } 688 689 int16x8_t test_vabdq_s16(int16x8_t v1, int16x8_t v2) { 690 // CHECK: test_vabdq_s16 691 return vabdq_s16(v1, v2); 692 // CHECK: sabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 693 } 694 695 int32x4_t test_vabdq_s32(int32x4_t v1, int32x4_t v2) { 696 // CHECK: test_vabdq_s32 697 return vabdq_s32(v1, v2); 698 // CHECK: sabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 699 } 700 701 uint8x16_t test_vabdq_u8(uint8x16_t v1, uint8x16_t v2) { 702 // CHECK: test_vabdq_u8 703 return vabdq_u8(v1, v2); 704 // CHECK: uabd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 705 } 706 707 uint16x8_t test_vabdq_u16(uint16x8_t v1, uint16x8_t v2) { 708 // CHECK: test_vabdq_u16 709 return vabdq_u16(v1, v2); 710 // CHECK: uabd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 711 } 712 713 uint32x4_t test_vabdq_u32(uint32x4_t v1, uint32x4_t v2) { 714 // CHECK: test_vabdq_u32 715 return vabdq_u32(v1, v2); 716 // CHECK: uabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 717 } 718 719 float32x4_t test_vabdq_f32(float32x4_t v1, float32x4_t v2) { 720 // CHECK: test_vabdq_f32 721 return vabdq_f32(v1, v2); 722 // CHECK: fabd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 723 } 724 725 float64x2_t test_vabdq_f64(float64x2_t v1, float64x2_t v2) { 726 // CHECK: test_vabdq_f64 727 return vabdq_f64(v1, v2); 728 // CHECK: fabd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 729 } 730 731 732 int8x8_t test_vbsl_s8(uint8x8_t v1, int8x8_t v2, int8x8_t v3) { 733 // CHECK: test_vbsl_s8 734 return vbsl_s8(v1, v2, v3); 735 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 736 } 737 738 int8x8_t test_vbsl_s16(uint16x4_t v1, int16x4_t v2, int16x4_t v3) { 739 // CHECK: test_vbsl_s16 740 return vbsl_s16(v1, v2, v3); 741 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 742 } 743 744 int32x2_t test_vbsl_s32(uint32x2_t v1, int32x2_t v2, int32x2_t v3) { 745 // CHECK: test_vbsl_s32 746 return vbsl_s32(v1, v2, v3); 747 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 748 } 749 750 uint64x1_t test_vbsl_s64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) { 751 // CHECK: test_vbsl_s64 752 return vbsl_s64(v1, v2, v3); 753 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 754 } 755 756 uint8x8_t test_vbsl_u8(uint8x8_t v1, uint8x8_t v2, uint8x8_t v3) { 757 // CHECK: test_vbsl_u8 758 return vbsl_u8(v1, v2, v3); 759 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 760 } 761 762 uint16x4_t test_vbsl_u16(uint16x4_t v1, uint16x4_t v2, uint16x4_t v3) { 763 // CHECK: test_vbsl_u16 764 return vbsl_u16(v1, v2, v3); 765 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 766 } 767 768 uint32x2_t test_vbsl_u32(uint32x2_t v1, uint32x2_t v2, uint32x2_t v3) { 769 // CHECK: test_vbsl_u32 770 return vbsl_u32(v1, v2, v3); 771 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 772 } 773 774 uint64x1_t test_vbsl_u64(uint64x1_t v1, uint64x1_t v2, uint64x1_t v3) { 775 // CHECK: test_vbsl_u64 776 return vbsl_u64(v1, v2, v3); 777 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 778 } 779 780 float32x2_t test_vbsl_f32(float32x2_t v1, float32x2_t v2, float32x2_t v3) { 781 // CHECK: test_vbsl_f32 782 return vbsl_f32(v1, v2, v3); 783 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 784 } 785 786 poly8x8_t test_vbsl_p8(uint8x8_t v1, poly8x8_t v2, poly8x8_t v3) { 787 // CHECK: test_vbsl_p8 788 return vbsl_p8(v1, v2, v3); 789 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 790 } 791 792 poly16x4_t test_vbsl_p16(uint16x4_t v1, poly16x4_t v2, poly16x4_t v3) { 793 // CHECK: test_vbsl_p16 794 return vbsl_p16(v1, v2, v3); 795 // CHECK: bsl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 796 } 797 798 int8x16_t test_vbslq_s8(uint8x16_t v1, int8x16_t v2, int8x16_t v3) { 799 // CHECK: test_vbslq_s8 800 return vbslq_s8(v1, v2, v3); 801 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 802 } 803 804 int16x8_t test_vbslq_s16(uint16x8_t v1, int16x8_t v2, int16x8_t v3) { 805 // CHECK: test_vbslq_s16 806 return vbslq_s16(v1, v2, v3); 807 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 808 } 809 810 int32x4_t test_vbslq_s32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) { 811 // CHECK: test_vbslq_s32 812 return vbslq_s32(v1, v2, v3); 813 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 814 } 815 816 int64x2_t test_vbslq_s64(uint64x2_t v1, int64x2_t v2, int64x2_t v3) { 817 // CHECK: test_vbslq_s64 818 return vbslq_s64(v1, v2, v3); 819 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 820 } 821 822 uint8x16_t test_vbslq_u8(uint8x16_t v1, uint8x16_t v2, uint8x16_t v3) { 823 // CHECK: test_vbslq_u8 824 return vbslq_u8(v1, v2, v3); 825 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 826 } 827 828 uint16x8_t test_vbslq_u16(uint16x8_t v1, uint16x8_t v2, uint16x8_t v3) { 829 // CHECK: test_vbslq_u16 830 return vbslq_u16(v1, v2, v3); 831 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 832 } 833 834 int32x4_t test_vbslq_u32(uint32x4_t v1, int32x4_t v2, int32x4_t v3) { 835 // CHECK: test_vbslq_u32 836 return vbslq_s32(v1, v2, v3); 837 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 838 } 839 840 uint64x2_t test_vbslq_u64(uint64x2_t v1, uint64x2_t v2, uint64x2_t v3) { 841 // CHECK: test_vbslq_u64 842 return vbslq_u64(v1, v2, v3); 843 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 844 } 845 846 float32x4_t test_vbslq_f32(uint32x4_t v1, float32x4_t v2, float32x4_t v3) { 847 // CHECK: test_vbslq_f32 848 return vbslq_f32(v1, v2, v3); 849 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 850 } 851 852 poly8x16_t test_vbslq_p8(uint8x16_t v1, poly8x16_t v2, poly8x16_t v3) { 853 // CHECK: test_vbslq_p8 854 return vbslq_p8(v1, v2, v3); 855 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 856 } 857 858 poly16x8_t test_vbslq_p16(uint16x8_t v1, poly16x8_t v2, poly16x8_t v3) { 859 // CHECK: test_vbslq_p16 860 return vbslq_p16(v1, v2, v3); 861 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 862 } 863 864 float64x2_t test_vbslq_f64(uint64x2_t v1, float64x2_t v2, float64x2_t v3) { 865 // CHECK: test_vbslq_f64 866 return vbslq_f64(v1, v2, v3); 867 // CHECK: bsl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 868 } 869 870 float32x2_t test_vrecps_f32(float32x2_t v1, float32x2_t v2) { 871 // CHECK: test_vrecps_f32 872 return vrecps_f32(v1, v2); 873 // CHECK: frecps {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 874 } 875 876 float32x4_t test_vrecpsq_f32(float32x4_t v1, float32x4_t v2) { 877 // CHECK: test_vrecpsq_f32 878 return vrecpsq_f32(v1, v2); 879 // CHECK: frecps {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 880 } 881 882 float64x2_t test_vrecpsq_f64(float64x2_t v1, float64x2_t v2) { 883 // CHECK: test_vrecpsq_f64 884 return vrecpsq_f64(v1, v2); 885 // CHECK: frecps {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 886 } 887 888 float32x2_t test_vrsqrts_f32(float32x2_t v1, float32x2_t v2) { 889 // CHECK: test_vrsqrts_f32 890 return vrsqrts_f32(v1, v2); 891 // CHECK: frsqrts {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 892 } 893 894 float32x4_t test_vrsqrtsq_f32(float32x4_t v1, float32x4_t v2) { 895 // CHECK: test_vrsqrtsq_f32 896 return vrsqrtsq_f32(v1, v2); 897 // CHECK: frsqrts {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 898 } 899 900 float64x2_t test_vrsqrtsq_f64(float64x2_t v1, float64x2_t v2) { 901 // CHECK: test_vrsqrtsq_f64 902 return vrsqrtsq_f64(v1, v2); 903 // CHECK: frsqrts {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 904 } 905 906 uint32x2_t test_vcage_f32(float32x2_t v1, float32x2_t v2) { 907 // CHECK: test_vcage_f32 908 return vcage_f32(v1, v2); 909 // CHECK: facge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 910 } 911 912 uint32x4_t test_vcageq_f32(float32x4_t v1, float32x4_t v2) { 913 // CHECK: test_vcageq_f32 914 return vcageq_f32(v1, v2); 915 // CHECK: facge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 916 } 917 918 uint64x2_t test_vcageq_f64(float64x2_t v1, float64x2_t v2) { 919 // CHECK: test_vcageq_f64 920 return vcageq_f64(v1, v2); 921 // CHECK: facge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 922 } 923 924 uint32x2_t test_vcagt_f32(float32x2_t v1, float32x2_t v2) { 925 // CHECK: test_vcagt_f32 926 return vcagt_f32(v1, v2); 927 // CHECK: facgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 928 } 929 930 uint32x4_t test_vcagtq_f32(float32x4_t v1, float32x4_t v2) { 931 // CHECK: test_vcagtq_f32 932 return vcagtq_f32(v1, v2); 933 // CHECK: facgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 934 } 935 936 uint64x2_t test_vcagtq_f64(float64x2_t v1, float64x2_t v2) { 937 // CHECK: test_vcagtq_f64 938 return vcagtq_f64(v1, v2); 939 // CHECK: facgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 940 } 941 942 uint32x2_t test_vcale_f32(float32x2_t v1, float32x2_t v2) { 943 // CHECK: test_vcale_f32 944 return vcale_f32(v1, v2); 945 // Using registers other than v0, v1 are possible, but would be odd. 946 // CHECK: facge {{v[0-9]+}}.2s, v1.2s, v0.2s 947 } 948 949 uint32x4_t test_vcaleq_f32(float32x4_t v1, float32x4_t v2) { 950 // CHECK: test_vcaleq_f32 951 return vcaleq_f32(v1, v2); 952 // Using registers other than v0, v1 are possible, but would be odd. 953 // CHECK: facge {{v[0-9]+}}.4s, v1.4s, v0.4s 954 } 955 956 uint64x2_t test_vcaleq_f64(float64x2_t v1, float64x2_t v2) { 957 // CHECK: test_vcaleq_f64 958 return vcaleq_f64(v1, v2); 959 // Using registers other than v0, v1 are possible, but would be odd. 960 // CHECK: facge {{v[0-9]+}}.2d, v1.2d, v0.2d 961 } 962 963 uint32x2_t test_vcalt_f32(float32x2_t v1, float32x2_t v2) { 964 // CHECK: test_vcalt_f32 965 return vcalt_f32(v1, v2); 966 // Using registers other than v0, v1 are possible, but would be odd. 967 // CHECK: facgt {{v[0-9]+}}.2s, v1.2s, v0.2s 968 } 969 970 uint32x4_t test_vcaltq_f32(float32x4_t v1, float32x4_t v2) { 971 // CHECK: test_vcaltq_f32 972 return vcaltq_f32(v1, v2); 973 // Using registers other than v0, v1 are possible, but would be odd. 974 // CHECK: facgt {{v[0-9]+}}.4s, v1.4s, v0.4s 975 } 976 977 uint64x2_t test_vcaltq_f64(float64x2_t v1, float64x2_t v2) { 978 // CHECK: test_vcaltq_f64 979 return vcaltq_f64(v1, v2); 980 // Using registers other than v0, v1 are possible, but would be odd. 981 // CHECK: facgt {{v[0-9]+}}.2d, v1.2d, v0.2d 982 } 983 984 uint8x8_t test_vtst_s8(int8x8_t v1, int8x8_t v2) { 985 // CHECK: test_vtst_s8 986 return vtst_s8(v1, v2); 987 // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 988 } 989 990 uint16x4_t test_vtst_s16(int16x4_t v1, int16x4_t v2) { 991 // CHECK: test_vtst_s16 992 return vtst_s16(v1, v2); 993 // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 994 } 995 996 uint32x2_t test_vtst_s32(int32x2_t v1, int32x2_t v2) { 997 // CHECK: test_vtst_s32 998 return vtst_s32(v1, v2); 999 // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1000 } 1001 1002 uint8x8_t test_vtst_u8(uint8x8_t v1, uint8x8_t v2) { 1003 // CHECK: test_vtst_u8 1004 return vtst_u8(v1, v2); 1005 // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1006 } 1007 1008 uint16x4_t test_vtst_u16(uint16x4_t v1, uint16x4_t v2) { 1009 // CHECK: test_vtst_u16 1010 return vtst_u16(v1, v2); 1011 // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1012 } 1013 1014 uint32x2_t test_vtst_u32(uint32x2_t v1, uint32x2_t v2) { 1015 // CHECK: test_vtst_u32 1016 return vtst_u32(v1, v2); 1017 // CHECK: cmtst {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1018 } 1019 1020 uint8x16_t test_vtstq_s8(int8x16_t v1, int8x16_t v2) { 1021 // CHECK: test_vtstq_s8 1022 return vtstq_s8(v1, v2); 1023 // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1024 } 1025 1026 uint16x8_t test_vtstq_s16(int16x8_t v1, int16x8_t v2) { 1027 // CHECK: test_vtstq_s16 1028 return vtstq_s16(v1, v2); 1029 // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1030 } 1031 1032 uint32x4_t test_vtstq_s32(int32x4_t v1, int32x4_t v2) { 1033 // CHECK: test_vtstq_s32 1034 return vtstq_s32(v1, v2); 1035 // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1036 } 1037 1038 uint8x16_t test_vtstq_u8(uint8x16_t v1, uint8x16_t v2) { 1039 // CHECK: test_vtstq_u8 1040 return vtstq_u8(v1, v2); 1041 // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1042 } 1043 1044 uint16x8_t test_vtstq_u16(uint16x8_t v1, uint16x8_t v2) { 1045 // CHECK: test_vtstq_u16 1046 return vtstq_u16(v1, v2); 1047 // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1048 } 1049 1050 uint32x4_t test_vtstq_u32(uint32x4_t v1, uint32x4_t v2) { 1051 // CHECK: test_vtstq_u32 1052 return vtstq_u32(v1, v2); 1053 // CHECK: cmtst {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1054 } 1055 1056 uint64x2_t test_vtstq_s64(int64x2_t v1, int64x2_t v2) { 1057 // CHECK: test_vtstq_s64 1058 return vtstq_s64(v1, v2); 1059 // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1060 } 1061 1062 uint64x2_t test_vtstq_u64(uint64x2_t v1, uint64x2_t v2) { 1063 // CHECK: test_vtstq_u64 1064 return vtstq_u64(v1, v2); 1065 // CHECK: cmtst {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1066 } 1067 1068 uint8x8_t test_vtst_p8(poly8x8_t v1, poly8x8_t v2) { 1069 // CHECK: test_vtst_p8 1070 return vtst_p8(v1, v2); 1071 // CHECK: cmtst {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1072 } 1073 1074 uint16x4_t test_vtst_p16(poly16x4_t v1, poly16x4_t v2) { 1075 // CHECK: test_vtst_p16 1076 return vtst_p16(v1, v2); 1077 // CHECK: cmtst {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1078 } 1079 1080 uint8x16_t test_vtstq_p8(poly8x16_t v1, poly8x16_t v2) { 1081 // CHECK: test_vtstq_p8 1082 return vtstq_p8(v1, v2); 1083 // CHECK: cmtst {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1084 } 1085 1086 uint16x8_t test_vtstq_p16(poly16x8_t v1, poly16x8_t v2) { 1087 // CHECK: test_vtstq_p16 1088 return vtstq_p16(v1, v2); 1089 // CHECK: cmtst {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1090 } 1091 1092 1093 uint8x8_t test_vceq_s8(int8x8_t v1, int8x8_t v2) { 1094 // CHECK: test_vceq_s8 1095 return vceq_s8(v1, v2); 1096 // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1097 } 1098 1099 uint16x4_t test_vceq_s16(int16x4_t v1, int16x4_t v2) { 1100 // CHECK: test_vceq_s16 1101 return vceq_s16(v1, v2); 1102 // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1103 } 1104 1105 uint32x2_t test_vceq_s32(int32x2_t v1, int32x2_t v2) { 1106 // CHECK: test_vceq_s32 1107 return vceq_s32(v1, v2); 1108 // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1109 } 1110 1111 uint32x2_t test_vceq_f32(float32x2_t v1, float32x2_t v2) { 1112 // CHECK: test_vceq_f32 1113 return vceq_f32(v1, v2); 1114 // CHECK: fcmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1115 } 1116 1117 uint8x8_t test_vceq_u8(uint8x8_t v1, uint8x8_t v2) { 1118 // CHECK: test_vceq_u8 1119 return vceq_u8(v1, v2); 1120 // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1121 } 1122 1123 uint16x4_t test_vceq_u16(uint16x4_t v1, uint16x4_t v2) { 1124 // CHECK: test_vceq_u16 1125 return vceq_u16(v1, v2); 1126 // CHECK: cmeq {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1127 } 1128 1129 uint32x2_t test_vceq_u32(uint32x2_t v1, uint32x2_t v2) { 1130 // CHECK: test_vceq_u32 1131 return vceq_u32(v1, v2); 1132 // CHECK: cmeq {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1133 } 1134 1135 uint8x8_t test_vceq_p8(poly8x8_t v1, poly8x8_t v2) { 1136 // CHECK: test_vceq_p8 1137 return vceq_p8(v1, v2); 1138 // CHECK: cmeq {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1139 } 1140 1141 uint8x16_t test_vceqq_s8(int8x16_t v1, int8x16_t v2) { 1142 // CHECK: test_vceqq_s8 1143 return vceqq_s8(v1, v2); 1144 // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1145 } 1146 1147 uint16x8_t test_vceqq_s16(int16x8_t v1, int16x8_t v2) { 1148 // CHECK: test_vceqq_s16 1149 return vceqq_s16(v1, v2); 1150 // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1151 } 1152 1153 uint32x4_t test_vceqq_s32(int32x4_t v1, int32x4_t v2) { 1154 // CHECK: test_vceqq_s32 1155 return vceqq_s32(v1, v2); 1156 // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1157 } 1158 1159 uint32x4_t test_vceqq_f32(float32x4_t v1, float32x4_t v2) { 1160 // CHECK: test_vceqq_f32 1161 return vceqq_f32(v1, v2); 1162 // CHECK: fcmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1163 } 1164 1165 uint8x16_t test_vceqq_u8(uint8x16_t v1, uint8x16_t v2) { 1166 // CHECK: test_vceqq_u8 1167 return vceqq_u8(v1, v2); 1168 // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1169 } 1170 1171 uint16x8_t test_vceqq_u16(uint16x8_t v1, uint16x8_t v2) { 1172 // CHECK: test_vceqq_u16 1173 return vceqq_u16(v1, v2); 1174 // CHECK: cmeq {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1175 } 1176 1177 uint32x4_t test_vceqq_u32(uint32x4_t v1, uint32x4_t v2) { 1178 // CHECK: test_vceqq_u32 1179 return vceqq_u32(v1, v2); 1180 // CHECK: cmeq {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1181 } 1182 1183 uint8x16_t test_vceqq_p8(poly8x16_t v1, poly8x16_t v2) { 1184 // CHECK: test_vceqq_p8 1185 return vceqq_p8(v1, v2); 1186 // CHECK: cmeq {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1187 } 1188 1189 1190 uint64x2_t test_vceqq_s64(int64x2_t v1, int64x2_t v2) { 1191 // CHECK: test_vceqq_s64 1192 return vceqq_s64(v1, v2); 1193 // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1194 } 1195 1196 uint64x2_t test_vceqq_u64(uint64x2_t v1, uint64x2_t v2) { 1197 // CHECK: test_vceqq_u64 1198 return vceqq_u64(v1, v2); 1199 // CHECK: cmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1200 } 1201 1202 uint64x2_t test_vceqq_f64(float64x2_t v1, float64x2_t v2) { 1203 // CHECK: test_vceqq_f64 1204 return vceqq_f64(v1, v2); 1205 // CHECK: fcmeq {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1206 } 1207 uint8x8_t test_vcge_s8(int8x8_t v1, int8x8_t v2) { 1208 // CHECK: test_vcge_s8 1209 return vcge_s8(v1, v2); 1210 // CHECK: cmge {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1211 } 1212 1213 uint16x4_t test_vcge_s16(int16x4_t v1, int16x4_t v2) { 1214 // CHECK: test_vcge_s16 1215 return vcge_s16(v1, v2); 1216 // CHECK: cmge {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1217 } 1218 1219 uint32x2_t test_vcge_s32(int32x2_t v1, int32x2_t v2) { 1220 // CHECK: test_vcge_s32 1221 return vcge_s32(v1, v2); 1222 // CHECK: cmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1223 } 1224 1225 uint32x2_t test_vcge_f32(float32x2_t v1, float32x2_t v2) { 1226 // CHECK: test_vcge_f32 1227 return vcge_f32(v1, v2); 1228 // CHECK: fcmge {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1229 } 1230 1231 uint8x8_t test_vcge_u8(uint8x8_t v1, uint8x8_t v2) { 1232 // CHECK: test_vcge_u8 1233 return vcge_u8(v1, v2); 1234 // CHECK: cmhs {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1235 } 1236 1237 uint16x4_t test_vcge_u16(uint16x4_t v1, uint16x4_t v2) { 1238 // CHECK: test_vcge_u16 1239 return vcge_u16(v1, v2); 1240 // CHECK: cmhs {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1241 } 1242 1243 uint32x2_t test_vcge_u32(uint32x2_t v1, uint32x2_t v2) { 1244 // CHECK: test_vcge_u32 1245 return vcge_u32(v1, v2); 1246 // CHECK: cmhs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1247 } 1248 1249 uint8x16_t test_vcgeq_s8(int8x16_t v1, int8x16_t v2) { 1250 // CHECK: test_vcgeq_s8 1251 return vcgeq_s8(v1, v2); 1252 // CHECK: cmge {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1253 } 1254 1255 uint16x8_t test_vcgeq_s16(int16x8_t v1, int16x8_t v2) { 1256 // CHECK: test_vcgeq_s16 1257 return vcgeq_s16(v1, v2); 1258 // CHECK: cmge {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1259 } 1260 1261 uint32x4_t test_vcgeq_s32(int32x4_t v1, int32x4_t v2) { 1262 // CHECK: test_vcgeq_s32 1263 return vcgeq_s32(v1, v2); 1264 // CHECK: cmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1265 } 1266 1267 uint32x4_t test_vcgeq_f32(float32x4_t v1, float32x4_t v2) { 1268 // CHECK: test_vcgeq_f32 1269 return vcgeq_f32(v1, v2); 1270 // CHECK: fcmge {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1271 } 1272 1273 uint8x16_t test_vcgeq_u8(uint8x16_t v1, uint8x16_t v2) { 1274 // CHECK: test_vcgeq_u8 1275 return vcgeq_u8(v1, v2); 1276 // CHECK: cmhs {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1277 } 1278 1279 uint16x8_t test_vcgeq_u16(uint16x8_t v1, uint16x8_t v2) { 1280 // CHECK: test_vcgeq_u16 1281 return vcgeq_u16(v1, v2); 1282 // CHECK: cmhs {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1283 } 1284 1285 uint32x4_t test_vcgeq_u32(uint32x4_t v1, uint32x4_t v2) { 1286 // CHECK: test_vcgeq_u32 1287 return vcgeq_u32(v1, v2); 1288 // CHECK: cmhs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1289 } 1290 1291 uint64x2_t test_vcgeq_s64(int64x2_t v1, int64x2_t v2) { 1292 // CHECK: test_vcgeq_s64 1293 return vcgeq_s64(v1, v2); 1294 // CHECK: cmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1295 } 1296 1297 uint64x2_t test_vcgeq_u64(uint64x2_t v1, uint64x2_t v2) { 1298 // CHECK: test_vcgeq_u64 1299 return vcgeq_u64(v1, v2); 1300 // CHECK: cmhs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1301 } 1302 1303 uint64x2_t test_vcgeq_f64(float64x2_t v1, float64x2_t v2) { 1304 // CHECK: test_vcgeq_f64 1305 return vcgeq_f64(v1, v2); 1306 // CHECK: fcmge {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1307 } 1308 1309 // Notes about vcle: 1310 // LE condition predicate implemented as GE, so check reversed operands. 1311 // Using registers other than v0, v1 are possible, but would be odd. 1312 uint8x8_t test_vcle_s8(int8x8_t v1, int8x8_t v2) { 1313 // CHECK: test_vcle_s8 1314 return vcle_s8(v1, v2); 1315 // CHECK: cmge {{v[0-9]+}}.8b, v1.8b, v0.8b 1316 } 1317 1318 uint16x4_t test_vcle_s16(int16x4_t v1, int16x4_t v2) { 1319 // CHECK: test_vcle_s16 1320 return vcle_s16(v1, v2); 1321 // CHECK: cmge {{v[0-9]+}}.4h, v1.4h, v0.4h 1322 } 1323 1324 uint32x2_t test_vcle_s32(int32x2_t v1, int32x2_t v2) { 1325 // CHECK: test_vcle_s32 1326 return vcle_s32(v1, v2); 1327 // CHECK: cmge {{v[0-9]+}}.2s, v1.2s, v0.2s 1328 } 1329 1330 uint32x2_t test_vcle_f32(float32x2_t v1, float32x2_t v2) { 1331 // CHECK: test_vcle_f32 1332 return vcle_f32(v1, v2); 1333 // CHECK: fcmge {{v[0-9]+}}.2s, v1.2s, v0.2s 1334 } 1335 1336 uint8x8_t test_vcle_u8(uint8x8_t v1, uint8x8_t v2) { 1337 // CHECK: test_vcle_u8 1338 return vcle_u8(v1, v2); 1339 // CHECK: cmhs {{v[0-9]+}}.8b, v1.8b, v0.8b 1340 } 1341 1342 uint16x4_t test_vcle_u16(uint16x4_t v1, uint16x4_t v2) { 1343 // CHECK: test_vcle_u16 1344 return vcle_u16(v1, v2); 1345 // CHECK: cmhs {{v[0-9]+}}.4h, v1.4h, v0.4h 1346 } 1347 1348 uint32x2_t test_vcle_u32(uint32x2_t v1, uint32x2_t v2) { 1349 // CHECK: test_vcle_u32 1350 return vcle_u32(v1, v2); 1351 // CHECK: cmhs {{v[0-9]+}}.2s, v1.2s, v0.2s 1352 } 1353 1354 uint8x16_t test_vcleq_s8(int8x16_t v1, int8x16_t v2) { 1355 // CHECK: test_vcleq_s8 1356 return vcleq_s8(v1, v2); 1357 // CHECK: cmge {{v[0-9]+}}.16b, v1.16b, v0.16b 1358 } 1359 1360 uint16x8_t test_vcleq_s16(int16x8_t v1, int16x8_t v2) { 1361 // CHECK: test_vcleq_s16 1362 return vcleq_s16(v1, v2); 1363 // CHECK: cmge {{v[0-9]+}}.8h, v1.8h, v0.8h 1364 } 1365 1366 uint32x4_t test_vcleq_s32(int32x4_t v1, int32x4_t v2) { 1367 // CHECK: test_vcleq_s32 1368 return vcleq_s32(v1, v2); 1369 // CHECK: cmge {{v[0-9]+}}.4s, v1.4s, v0.4s 1370 } 1371 1372 uint32x4_t test_vcleq_f32(float32x4_t v1, float32x4_t v2) { 1373 // CHECK: test_vcleq_f32 1374 return vcleq_f32(v1, v2); 1375 // CHECK: fcmge {{v[0-9]+}}.4s, v1.4s, v0.4s 1376 } 1377 1378 uint8x16_t test_vcleq_u8(uint8x16_t v1, uint8x16_t v2) { 1379 // CHECK: test_vcleq_u8 1380 return vcleq_u8(v1, v2); 1381 // CHECK: cmhs {{v[0-9]+}}.16b, v1.16b, v0.16b 1382 } 1383 1384 uint16x8_t test_vcleq_u16(uint16x8_t v1, uint16x8_t v2) { 1385 // CHECK: test_vcleq_u16 1386 return vcleq_u16(v1, v2); 1387 // CHECK: cmhs {{v[0-9]+}}.8h, v1.8h, v0.8h 1388 } 1389 1390 uint32x4_t test_vcleq_u32(uint32x4_t v1, uint32x4_t v2) { 1391 // CHECK: test_vcleq_u32 1392 return vcleq_u32(v1, v2); 1393 // CHECK: cmhs {{v[0-9]+}}.4s, v1.4s, v0.4s 1394 } 1395 1396 uint64x2_t test_vcleq_s64(int64x2_t v1, int64x2_t v2) { 1397 // CHECK: test_vcleq_s64 1398 return vcleq_s64(v1, v2); 1399 // CHECK: cmge {{v[0-9]+}}.2d, v1.2d, v0.2d 1400 } 1401 1402 uint64x2_t test_vcleq_u64(uint64x2_t v1, uint64x2_t v2) { 1403 // CHECK: test_vcleq_u64 1404 return vcleq_u64(v1, v2); 1405 // CHECK: cmhs {{v[0-9]+}}.2d, v1.2d, v0.2d 1406 } 1407 1408 uint64x2_t test_vcleq_f64(float64x2_t v1, float64x2_t v2) { 1409 // CHECK: test_vcleq_f64 1410 return vcleq_f64(v1, v2); 1411 // CHECK: fcmge {{v[0-9]+}}.2d, v1.2d, v0.2d 1412 } 1413 1414 1415 uint8x8_t test_vcgt_s8(int8x8_t v1, int8x8_t v2) { 1416 // CHECK: test_vcgt_s8 1417 return vcgt_s8(v1, v2); 1418 // CHECK: cmgt {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1419 } 1420 1421 uint16x4_t test_vcgt_s16(int16x4_t v1, int16x4_t v2) { 1422 // CHECK: test_vcgt_s16 1423 return vcgt_s16(v1, v2); 1424 // CHECK: cmgt {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1425 } 1426 1427 uint32x2_t test_vcgt_s32(int32x2_t v1, int32x2_t v2) { 1428 // CHECK: test_vcgt_s32 1429 return vcgt_s32(v1, v2); 1430 // CHECK: cmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1431 } 1432 1433 uint32x2_t test_vcgt_f32(float32x2_t v1, float32x2_t v2) { 1434 // CHECK: test_vcgt_f32 1435 return vcgt_f32(v1, v2); 1436 // CHECK: fcmgt {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1437 } 1438 1439 uint8x8_t test_vcgt_u8(uint8x8_t v1, uint8x8_t v2) { 1440 // CHECK: test_vcgt_u8 1441 return vcgt_u8(v1, v2); 1442 // CHECK: cmhi {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1443 } 1444 1445 uint16x4_t test_vcgt_u16(uint16x4_t v1, uint16x4_t v2) { 1446 // CHECK: test_vcgt_u16 1447 return vcgt_u16(v1, v2); 1448 // CHECK: cmhi {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1449 } 1450 1451 uint32x2_t test_vcgt_u32(uint32x2_t v1, uint32x2_t v2) { 1452 // CHECK: test_vcgt_u32 1453 return vcgt_u32(v1, v2); 1454 // CHECK: cmhi {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1455 } 1456 1457 uint8x16_t test_vcgtq_s8(int8x16_t v1, int8x16_t v2) { 1458 // CHECK: test_vcgtq_s8 1459 return vcgtq_s8(v1, v2); 1460 // CHECK: cmgt {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1461 } 1462 1463 uint16x8_t test_vcgtq_s16(int16x8_t v1, int16x8_t v2) { 1464 // CHECK: test_vcgtq_s16 1465 return vcgtq_s16(v1, v2); 1466 // CHECK: cmgt {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1467 } 1468 1469 uint32x4_t test_vcgtq_s32(int32x4_t v1, int32x4_t v2) { 1470 // CHECK: test_vcgtq_s32 1471 return vcgtq_s32(v1, v2); 1472 // CHECK: cmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1473 } 1474 1475 uint32x4_t test_vcgtq_f32(float32x4_t v1, float32x4_t v2) { 1476 // CHECK: test_vcgtq_f32 1477 return vcgtq_f32(v1, v2); 1478 // CHECK: fcmgt {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1479 } 1480 1481 uint8x16_t test_vcgtq_u8(uint8x16_t v1, uint8x16_t v2) { 1482 // CHECK: test_vcgtq_u8 1483 return vcgtq_u8(v1, v2); 1484 // CHECK: cmhi {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1485 } 1486 1487 uint16x8_t test_vcgtq_u16(uint16x8_t v1, uint16x8_t v2) { 1488 // CHECK: test_vcgtq_u16 1489 return vcgtq_u16(v1, v2); 1490 // CHECK: cmhi {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1491 } 1492 1493 uint32x4_t test_vcgtq_u32(uint32x4_t v1, uint32x4_t v2) { 1494 // CHECK: test_vcgtq_u32 1495 return vcgtq_u32(v1, v2); 1496 // CHECK: cmhi {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1497 } 1498 1499 uint64x2_t test_vcgtq_s64(int64x2_t v1, int64x2_t v2) { 1500 // CHECK: test_vcgtq_s64 1501 return vcgtq_s64(v1, v2); 1502 // CHECK: cmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1503 } 1504 1505 uint64x2_t test_vcgtq_u64(uint64x2_t v1, uint64x2_t v2) { 1506 // CHECK: test_vcgtq_u64 1507 return vcgtq_u64(v1, v2); 1508 // CHECK: cmhi {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1509 } 1510 1511 uint64x2_t test_vcgtq_f64(float64x2_t v1, float64x2_t v2) { 1512 // CHECK: test_vcgtq_f64 1513 return vcgtq_f64(v1, v2); 1514 // CHECK: fcmgt {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1515 } 1516 1517 1518 // Notes about vclt: 1519 // LT condition predicate implemented as GT, so check reversed operands. 1520 // Using registers other than v0, v1 are possible, but would be odd. 1521 1522 uint8x8_t test_vclt_s8(int8x8_t v1, int8x8_t v2) { 1523 // CHECK: test_vclt_s8 1524 return vclt_s8(v1, v2); 1525 // CHECK: cmgt {{v[0-9]+}}.8b, v1.8b, v0.8b 1526 } 1527 1528 uint16x4_t test_vclt_s16(int16x4_t v1, int16x4_t v2) { 1529 // CHECK: test_vclt_s16 1530 return vclt_s16(v1, v2); 1531 // CHECK: cmgt {{v[0-9]+}}.4h, v1.4h, v0.4h 1532 } 1533 1534 uint32x2_t test_vclt_s32(int32x2_t v1, int32x2_t v2) { 1535 // CHECK: test_vclt_s32 1536 return vclt_s32(v1, v2); 1537 // CHECK: cmgt {{v[0-9]+}}.2s, v1.2s, v0.2s 1538 } 1539 1540 uint32x2_t test_vclt_f32(float32x2_t v1, float32x2_t v2) { 1541 // CHECK: test_vclt_f32 1542 return vclt_f32(v1, v2); 1543 // CHECK: fcmgt {{v[0-9]+}}.2s, v1.2s, v0.2s 1544 } 1545 1546 uint8x8_t test_vclt_u8(uint8x8_t v1, uint8x8_t v2) { 1547 // CHECK: test_vclt_u8 1548 return vclt_u8(v1, v2); 1549 // CHECK: cmhi {{v[0-9]+}}.8b, v1.8b, v0.8b 1550 } 1551 1552 uint16x4_t test_vclt_u16(uint16x4_t v1, uint16x4_t v2) { 1553 // CHECK: test_vclt_u16 1554 return vclt_u16(v1, v2); 1555 // CHECK: cmhi {{v[0-9]+}}.4h, v1.4h, v0.4h 1556 } 1557 1558 uint32x2_t test_vclt_u32(uint32x2_t v1, uint32x2_t v2) { 1559 // CHECK: test_vclt_u32 1560 return vclt_u32(v1, v2); 1561 // CHECK: cmhi {{v[0-9]+}}.2s, v1.2s, v0.2s 1562 } 1563 1564 uint8x16_t test_vcltq_s8(int8x16_t v1, int8x16_t v2) { 1565 // CHECK: test_vcltq_s8 1566 return vcltq_s8(v1, v2); 1567 // CHECK: cmgt {{v[0-9]+}}.16b, v1.16b, v0.16b 1568 } 1569 1570 uint16x8_t test_vcltq_s16(int16x8_t v1, int16x8_t v2) { 1571 // CHECK: test_vcltq_s16 1572 return vcltq_s16(v1, v2); 1573 // CHECK: cmgt {{v[0-9]+}}.8h, v1.8h, v0.8h 1574 } 1575 1576 uint32x4_t test_vcltq_s32(int32x4_t v1, int32x4_t v2) { 1577 // CHECK: test_vcltq_s32 1578 return vcltq_s32(v1, v2); 1579 // CHECK: cmgt {{v[0-9]+}}.4s, v1.4s, v0.4s 1580 } 1581 1582 uint32x4_t test_vcltq_f32(float32x4_t v1, float32x4_t v2) { 1583 // CHECK: test_vcltq_f32 1584 return vcltq_f32(v1, v2); 1585 // CHECK: fcmgt {{v[0-9]+}}.4s, v1.4s, v0.4s 1586 } 1587 1588 uint8x16_t test_vcltq_u8(uint8x16_t v1, uint8x16_t v2) { 1589 // CHECK: test_vcltq_u8 1590 return vcltq_u8(v1, v2); 1591 // CHECK: cmhi {{v[0-9]+}}.16b, v1.16b, v0.16b 1592 } 1593 1594 uint16x8_t test_vcltq_u16(uint16x8_t v1, uint16x8_t v2) { 1595 // CHECK: test_vcltq_u16 1596 return vcltq_u16(v1, v2); 1597 // CHECK: cmhi {{v[0-9]+}}.8h, v1.8h, v0.8h 1598 } 1599 1600 uint32x4_t test_vcltq_u32(uint32x4_t v1, uint32x4_t v2) { 1601 // CHECK: test_vcltq_u32 1602 return vcltq_u32(v1, v2); 1603 // CHECK: cmhi {{v[0-9]+}}.4s, v1.4s, v0.4s 1604 } 1605 1606 uint64x2_t test_vcltq_s64(int64x2_t v1, int64x2_t v2) { 1607 // CHECK: test_vcltq_s64 1608 return vcltq_s64(v1, v2); 1609 // CHECK: cmgt {{v[0-9]+}}.2d, v1.2d, v0.2d 1610 } 1611 1612 uint64x2_t test_vcltq_u64(uint64x2_t v1, uint64x2_t v2) { 1613 // CHECK: test_vcltq_u64 1614 return vcltq_u64(v1, v2); 1615 // CHECK: cmhi {{v[0-9]+}}.2d, v1.2d, v0.2d 1616 } 1617 1618 uint64x2_t test_vcltq_f64(float64x2_t v1, float64x2_t v2) { 1619 // CHECK: test_vcltq_f64 1620 return vcltq_f64(v1, v2); 1621 // CHECK: fcmgt {{v[0-9]+}}.2d, v1.2d, v0.2d 1622 } 1623 1624 1625 int8x8_t test_vhadd_s8(int8x8_t v1, int8x8_t v2) { 1626 // CHECK: test_vhadd_s8 1627 return vhadd_s8(v1, v2); 1628 // CHECK: shadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1629 } 1630 1631 int16x4_t test_vhadd_s16(int16x4_t v1, int16x4_t v2) { 1632 // CHECK: test_vhadd_s16 1633 return vhadd_s16(v1, v2); 1634 // CHECK: shadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1635 } 1636 1637 int32x2_t test_vhadd_s32(int32x2_t v1, int32x2_t v2) { 1638 // CHECK: test_vhadd_s32 1639 return vhadd_s32(v1, v2); 1640 // CHECK: shadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1641 } 1642 1643 uint8x8_t test_vhadd_u8(uint8x8_t v1, uint8x8_t v2) { 1644 // CHECK: test_vhadd_u8 1645 return vhadd_u8(v1, v2); 1646 // CHECK: uhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1647 } 1648 1649 uint16x4_t test_vhadd_u16(uint16x4_t v1, uint16x4_t v2) { 1650 // CHECK: test_vhadd_u16 1651 return vhadd_u16(v1, v2); 1652 // CHECK: uhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1653 } 1654 1655 uint32x2_t test_vhadd_u32(uint32x2_t v1, uint32x2_t v2) { 1656 // CHECK: test_vhadd_u32 1657 return vhadd_u32(v1, v2); 1658 // CHECK: uhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1659 } 1660 1661 int8x16_t test_vhaddq_s8(int8x16_t v1, int8x16_t v2) { 1662 // CHECK: test_vhaddq_s8 1663 return vhaddq_s8(v1, v2); 1664 // CHECK: shadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1665 } 1666 1667 int16x8_t test_vhaddq_s16(int16x8_t v1, int16x8_t v2) { 1668 // CHECK: test_vhaddq_s16 1669 return vhaddq_s16(v1, v2); 1670 // CHECK: shadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1671 } 1672 1673 int32x4_t test_vhaddq_s32(int32x4_t v1, int32x4_t v2) { 1674 // CHECK: test_vhaddq_s32 1675 return vhaddq_s32(v1, v2); 1676 // CHECK: shadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1677 } 1678 1679 uint8x16_t test_vhaddq_u8(uint8x16_t v1, uint8x16_t v2) { 1680 // CHECK: test_vhaddq_u8 1681 return vhaddq_u8(v1, v2); 1682 // CHECK: uhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1683 } 1684 1685 uint16x8_t test_vhaddq_u16(uint16x8_t v1, uint16x8_t v2) { 1686 // CHECK: test_vhaddq_u16 1687 return vhaddq_u16(v1, v2); 1688 // CHECK: uhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1689 } 1690 1691 uint32x4_t test_vhaddq_u32(uint32x4_t v1, uint32x4_t v2) { 1692 // CHECK: test_vhaddq_u32 1693 return vhaddq_u32(v1, v2); 1694 // CHECK: uhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1695 } 1696 1697 1698 int8x8_t test_vhsub_s8(int8x8_t v1, int8x8_t v2) { 1699 // CHECK: test_vhsub_s8 1700 return vhsub_s8(v1, v2); 1701 // CHECK: shsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1702 } 1703 1704 int16x4_t test_vhsub_s16(int16x4_t v1, int16x4_t v2) { 1705 // CHECK: test_vhsub_s16 1706 return vhsub_s16(v1, v2); 1707 // CHECK: shsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1708 } 1709 1710 int32x2_t test_vhsub_s32(int32x2_t v1, int32x2_t v2) { 1711 // CHECK: test_vhsub_s32 1712 return vhsub_s32(v1, v2); 1713 // CHECK: shsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1714 } 1715 1716 uint8x8_t test_vhsub_u8(uint8x8_t v1, uint8x8_t v2) { 1717 // CHECK: test_vhsub_u8 1718 return vhsub_u8(v1, v2); 1719 // CHECK: uhsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1720 } 1721 1722 uint16x4_t test_vhsub_u16(uint16x4_t v1, uint16x4_t v2) { 1723 // CHECK: test_vhsub_u16 1724 return vhsub_u16(v1, v2); 1725 // CHECK: uhsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1726 } 1727 1728 uint32x2_t test_vhsub_u32(uint32x2_t v1, uint32x2_t v2) { 1729 // CHECK: test_vhsub_u32 1730 return vhsub_u32(v1, v2); 1731 // CHECK: uhsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1732 } 1733 1734 int8x16_t test_vhsubq_s8(int8x16_t v1, int8x16_t v2) { 1735 // CHECK: test_vhsubq_s8 1736 return vhsubq_s8(v1, v2); 1737 // CHECK: shsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1738 } 1739 1740 int16x8_t test_vhsubq_s16(int16x8_t v1, int16x8_t v2) { 1741 // CHECK: test_vhsubq_s16 1742 return vhsubq_s16(v1, v2); 1743 // CHECK: shsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1744 } 1745 1746 int32x4_t test_vhsubq_s32(int32x4_t v1, int32x4_t v2) { 1747 // CHECK: test_vhsubq_s32 1748 return vhsubq_s32(v1, v2); 1749 // CHECK: shsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1750 } 1751 1752 uint8x16_t test_vhsubq_u8(uint8x16_t v1, uint8x16_t v2) { 1753 // CHECK: test_vhsubq_u8 1754 return vhsubq_u8(v1, v2); 1755 // CHECK: uhsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1756 } 1757 1758 uint16x8_t test_vhsubq_u16(uint16x8_t v1, uint16x8_t v2) { 1759 // CHECK: test_vhsubq_u16 1760 return vhsubq_u16(v1, v2); 1761 // CHECK: uhsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1762 } 1763 1764 uint32x4_t test_vhsubq_u32(uint32x4_t v1, uint32x4_t v2) { 1765 // CHECK: test_vhsubq_u32 1766 return vhsubq_u32(v1, v2); 1767 // CHECK: uhsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1768 } 1769 1770 1771 int8x8_t test_vrhadd_s8(int8x8_t v1, int8x8_t v2) { 1772 // CHECK: test_vrhadd_s8 1773 return vrhadd_s8(v1, v2); 1774 // CHECK: srhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1775 } 1776 1777 int16x4_t test_vrhadd_s16(int16x4_t v1, int16x4_t v2) { 1778 // CHECK: test_vrhadd_s16 1779 return vrhadd_s16(v1, v2); 1780 // CHECK: srhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1781 } 1782 1783 int32x2_t test_vrhadd_s32(int32x2_t v1, int32x2_t v2) { 1784 // CHECK: test_vrhadd_s32 1785 return vrhadd_s32(v1, v2); 1786 // CHECK: srhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1787 } 1788 1789 uint8x8_t test_vrhadd_u8(uint8x8_t v1, uint8x8_t v2) { 1790 // CHECK: test_vrhadd_u8 1791 return vrhadd_u8(v1, v2); 1792 // CHECK: urhadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1793 } 1794 1795 uint16x4_t test_vrhadd_u16(uint16x4_t v1, uint16x4_t v2) { 1796 // CHECK: test_vrhadd_u16 1797 return vrhadd_u16(v1, v2); 1798 // CHECK: urhadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1799 } 1800 1801 uint32x2_t test_vrhadd_u32(uint32x2_t v1, uint32x2_t v2) { 1802 // CHECK: test_vrhadd_u32 1803 return vrhadd_u32(v1, v2); 1804 // CHECK: urhadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1805 } 1806 1807 int8x16_t test_vrhaddq_s8(int8x16_t v1, int8x16_t v2) { 1808 // CHECK: test_vrhaddq_s8 1809 return vrhaddq_s8(v1, v2); 1810 // CHECK: srhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1811 } 1812 1813 int16x8_t test_vrhaddq_s16(int16x8_t v1, int16x8_t v2) { 1814 // CHECK: test_vrhaddq_s16 1815 return vrhaddq_s16(v1, v2); 1816 // CHECK: srhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1817 } 1818 1819 int32x4_t test_vrhaddq_s32(int32x4_t v1, int32x4_t v2) { 1820 // CHECK: test_vrhaddq_s32 1821 return vrhaddq_s32(v1, v2); 1822 // CHECK: srhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1823 } 1824 1825 uint8x16_t test_vrhaddq_u8(uint8x16_t v1, uint8x16_t v2) { 1826 // CHECK: test_vrhaddq_u8 1827 return vrhaddq_u8(v1, v2); 1828 // CHECK: urhadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1829 } 1830 1831 uint16x8_t test_vrhaddq_u16(uint16x8_t v1, uint16x8_t v2) { 1832 // CHECK: test_vrhaddq_u16 1833 return vrhaddq_u16(v1, v2); 1834 // CHECK: urhadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1835 } 1836 1837 uint32x4_t test_vrhaddq_u32(uint32x4_t v1, uint32x4_t v2) { 1838 // CHECK: test_vrhaddq_u32 1839 return vrhaddq_u32(v1, v2); 1840 // CHECK: urhadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1841 } 1842 int8x8_t test_vqadd_s8(int8x8_t a, int8x8_t b) { 1843 // CHECK: test_vqadd_s8 1844 return vqadd_s8(a, b); 1845 // CHECK: sqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1846 } 1847 1848 int16x4_t test_vqadd_s16(int16x4_t a, int16x4_t b) { 1849 // CHECK: test_vqadd_s16 1850 return vqadd_s16(a, b); 1851 // CHECK: sqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1852 } 1853 1854 int32x2_t test_vqadd_s32(int32x2_t a, int32x2_t b) { 1855 // CHECK: test_vqadd_s32 1856 return vqadd_s32(a, b); 1857 // CHECK: sqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1858 } 1859 1860 int64x1_t test_vqadd_s64(int64x1_t a, int64x1_t b) { 1861 // CHECK: test_vqadd_s64 1862 return vqadd_s64(a, b); 1863 // CHECK: sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 1864 } 1865 1866 uint8x8_t test_vqadd_u8(uint8x8_t a, uint8x8_t b) { 1867 // CHECK: test_vqadd_u8 1868 return vqadd_u8(a, b); 1869 // CHECK: uqadd {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1870 } 1871 1872 uint16x4_t test_vqadd_u16(uint16x4_t a, uint16x4_t b) { 1873 // CHECK: test_vqadd_u16 1874 return vqadd_u16(a, b); 1875 // CHECK: uqadd {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1876 } 1877 1878 uint32x2_t test_vqadd_u32(uint32x2_t a, uint32x2_t b) { 1879 // CHECK: test_vqadd_u32 1880 return vqadd_u32(a, b); 1881 // CHECK: uqadd {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1882 } 1883 1884 uint64x1_t test_vqadd_u64(uint64x1_t a, uint64x1_t b) { 1885 // CHECK: test_vqadd_u64 1886 return vqadd_u64(a, b); 1887 // CHECK: uqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 1888 } 1889 1890 int8x16_t test_vqaddq_s8(int8x16_t a, int8x16_t b) { 1891 // CHECK: test_vqaddq_s8 1892 return vqaddq_s8(a, b); 1893 // CHECK: sqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1894 } 1895 1896 int16x8_t test_vqaddq_s16(int16x8_t a, int16x8_t b) { 1897 // CHECK: test_vqaddq_s16 1898 return vqaddq_s16(a, b); 1899 // CHECK: sqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1900 } 1901 1902 int32x4_t test_vqaddq_s32(int32x4_t a, int32x4_t b) { 1903 // CHECK: test_vqaddq_s32 1904 return vqaddq_s32(a, b); 1905 // CHECK: sqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1906 } 1907 1908 int64x2_t test_vqaddq_s64(int64x2_t a, int64x2_t b) { 1909 // CHECK: test_vqaddq_s64 1910 return vqaddq_s64(a, b); 1911 // CHECK: sqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1912 } 1913 1914 uint8x16_t test_vqaddq_u8(uint8x16_t a, uint8x16_t b) { 1915 // CHECK: test_vqaddq_u8 1916 return vqaddq_u8(a, b); 1917 // CHECK: uqadd {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1918 } 1919 1920 uint16x8_t test_vqaddq_u16(uint16x8_t a, uint16x8_t b) { 1921 // CHECK: test_vqaddq_u16 1922 return vqaddq_u16(a, b); 1923 // CHECK: uqadd {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1924 } 1925 1926 uint32x4_t test_vqaddq_u32(uint32x4_t a, uint32x4_t b) { 1927 // CHECK: test_vqaddq_u32 1928 return vqaddq_u32(a, b); 1929 // CHECK: uqadd {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 1930 } 1931 1932 uint64x2_t test_vqaddq_u64(uint64x2_t a, uint64x2_t b) { 1933 // CHECK: test_vqaddq_u64 1934 return vqaddq_u64(a, b); 1935 // CHECK: uqadd {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 1936 } 1937 1938 1939 int8x8_t test_vqsub_s8(int8x8_t a, int8x8_t b) { 1940 // CHECK: test_vqsub_s8 1941 return vqsub_s8(a, b); 1942 // CHECK: sqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1943 } 1944 1945 int16x4_t test_vqsub_s16(int16x4_t a, int16x4_t b) { 1946 // CHECK: test_vqsub_s16 1947 return vqsub_s16(a, b); 1948 // CHECK: sqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1949 } 1950 1951 int32x2_t test_vqsub_s32(int32x2_t a, int32x2_t b) { 1952 // CHECK: test_vqsub_s32 1953 return vqsub_s32(a, b); 1954 // CHECK: sqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1955 } 1956 1957 int64x1_t test_vqsub_s64(int64x1_t a, int64x1_t b) { 1958 // CHECK: test_vqsub_s64 1959 return vqsub_s64(a, b); 1960 // CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 1961 } 1962 1963 uint8x8_t test_vqsub_u8(uint8x8_t a, uint8x8_t b) { 1964 // CHECK: test_vqsub_u8 1965 return vqsub_u8(a, b); 1966 // CHECK: uqsub {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 1967 } 1968 1969 uint16x4_t test_vqsub_u16(uint16x4_t a, uint16x4_t b) { 1970 // CHECK: test_vqsub_u16 1971 return vqsub_u16(a, b); 1972 // CHECK: uqsub {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 1973 } 1974 1975 uint32x2_t test_vqsub_u32(uint32x2_t a, uint32x2_t b) { 1976 // CHECK: test_vqsub_u32 1977 return vqsub_u32(a, b); 1978 // CHECK: uqsub {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 1979 } 1980 1981 uint64x1_t test_vqsub_u64(uint64x1_t a, uint64x1_t b) { 1982 // CHECK: test_vqsub_u64 1983 return vqsub_u64(a, b); 1984 // CHECK: uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 1985 } 1986 1987 int8x16_t test_vqsubq_s8(int8x16_t a, int8x16_t b) { 1988 // CHECK: test_vqsubq_s8 1989 return vqsubq_s8(a, b); 1990 // CHECK: sqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 1991 } 1992 1993 int16x8_t test_vqsubq_s16(int16x8_t a, int16x8_t b) { 1994 // CHECK: test_vqsubq_s16 1995 return vqsubq_s16(a, b); 1996 // CHECK: sqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 1997 } 1998 1999 int32x4_t test_vqsubq_s32(int32x4_t a, int32x4_t b) { 2000 // CHECK: test_vqsubq_s32 2001 return vqsubq_s32(a, b); 2002 // CHECK: sqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2003 } 2004 2005 int64x2_t test_vqsubq_s64(int64x2_t a, int64x2_t b) { 2006 // CHECK: test_vqsubq_s64 2007 return vqsubq_s64(a, b); 2008 // CHECK: sqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2009 } 2010 2011 uint8x16_t test_vqsubq_u8(uint8x16_t a, uint8x16_t b) { 2012 // CHECK: test_vqsubq_u8 2013 return vqsubq_u8(a, b); 2014 // CHECK: uqsub {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2015 } 2016 2017 uint16x8_t test_vqsubq_u16(uint16x8_t a, uint16x8_t b) { 2018 // CHECK: test_vqsubq_u16 2019 return vqsubq_u16(a, b); 2020 // CHECK: uqsub {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2021 } 2022 2023 uint32x4_t test_vqsubq_u32(uint32x4_t a, uint32x4_t b) { 2024 // CHECK: test_vqsubq_u32 2025 return vqsubq_u32(a, b); 2026 // CHECK: uqsub {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2027 } 2028 2029 uint64x2_t test_vqsubq_u64(uint64x2_t a, uint64x2_t b) { 2030 // CHECK: test_vqsubq_u64 2031 return vqsubq_u64(a, b); 2032 // CHECK: uqsub {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2033 } 2034 2035 2036 int8x8_t test_vshl_s8(int8x8_t a, int8x8_t b) { 2037 // CHECK: test_vshl_s8 2038 return vshl_s8(a, b); 2039 // CHECK: sshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2040 } 2041 2042 int16x4_t test_vshl_s16(int16x4_t a, int16x4_t b) { 2043 // CHECK: test_vshl_s16 2044 return vshl_s16(a, b); 2045 // CHECK: sshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2046 } 2047 2048 int32x2_t test_vshl_s32(int32x2_t a, int32x2_t b) { 2049 // CHECK: test_vshl_s32 2050 return vshl_s32(a, b); 2051 // CHECK: sshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2052 } 2053 2054 int64x1_t test_vshl_s64(int64x1_t a, int64x1_t b) { 2055 // CHECK: test_vshl_s64 2056 return vshl_s64(a, b); 2057 // CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2058 } 2059 2060 uint8x8_t test_vshl_u8(uint8x8_t a, int8x8_t b) { 2061 // CHECK: test_vshl_u8 2062 return vshl_u8(a, b); 2063 // CHECK: ushl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2064 } 2065 2066 uint16x4_t test_vshl_u16(uint16x4_t a, int16x4_t b) { 2067 // CHECK: test_vshl_u16 2068 return vshl_u16(a, b); 2069 // CHECK: ushl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2070 } 2071 2072 uint32x2_t test_vshl_u32(uint32x2_t a, int32x2_t b) { 2073 // CHECK: test_vshl_u32 2074 return vshl_u32(a, b); 2075 // CHECK: ushl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2076 } 2077 2078 uint64x1_t test_vshl_u64(uint64x1_t a, int64x1_t b) { 2079 // CHECK: test_vshl_u64 2080 return vshl_u64(a, b); 2081 // CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2082 } 2083 2084 int8x16_t test_vshlq_s8(int8x16_t a, int8x16_t b) { 2085 // CHECK: test_vshlq_s8 2086 return vshlq_s8(a, b); 2087 // CHECK: sshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2088 } 2089 2090 int16x8_t test_vshlq_s16(int16x8_t a, int16x8_t b) { 2091 // CHECK: test_vshlq_s16 2092 return vshlq_s16(a, b); 2093 // CHECK: sshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2094 } 2095 2096 int32x4_t test_vshlq_s32(int32x4_t a, int32x4_t b) { 2097 // CHECK: test_vshlq_s32 2098 return vshlq_s32(a, b); 2099 // CHECK: sshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2100 } 2101 2102 int64x2_t test_vshlq_s64(int64x2_t a, int64x2_t b) { 2103 // CHECK: test_vshlq_s64 2104 return vshlq_s64(a, b); 2105 // CHECK: sshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2106 } 2107 2108 uint8x16_t test_vshlq_u8(uint8x16_t a, int8x16_t b) { 2109 // CHECK: test_vshlq_u8 2110 return vshlq_u8(a, b); 2111 // CHECK: ushl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2112 } 2113 2114 uint16x8_t test_vshlq_u16(uint16x8_t a, int16x8_t b) { 2115 // CHECK: test_vshlq_u16 2116 return vshlq_u16(a, b); 2117 // CHECK: ushl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2118 } 2119 2120 uint32x4_t test_vshlq_u32(uint32x4_t a, int32x4_t b) { 2121 // CHECK: test_vshlq_u32 2122 return vshlq_u32(a, b); 2123 // CHECK: ushl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2124 } 2125 2126 uint64x2_t test_vshlq_u64(uint64x2_t a, int64x2_t b) { 2127 // CHECK: test_vshlq_u64 2128 return vshlq_u64(a, b); 2129 // CHECK: ushl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2130 } 2131 2132 2133 int8x8_t test_vqshl_s8(int8x8_t a, int8x8_t b) { 2134 // CHECK: test_vqshl_s8 2135 return vqshl_s8(a, b); 2136 // CHECK: sqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2137 } 2138 2139 int16x4_t test_vqshl_s16(int16x4_t a, int16x4_t b) { 2140 // CHECK: test_vqshl_s16 2141 return vqshl_s16(a, b); 2142 // CHECK: sqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2143 } 2144 2145 int32x2_t test_vqshl_s32(int32x2_t a, int32x2_t b) { 2146 // CHECK: test_vqshl_s32 2147 return vqshl_s32(a, b); 2148 // CHECK: sqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2149 } 2150 2151 int64x1_t test_vqshl_s64(int64x1_t a, int64x1_t b) { 2152 // CHECK: test_vqshl_s64 2153 return vqshl_s64(a, b); 2154 // CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2155 } 2156 2157 uint8x8_t test_vqshl_u8(uint8x8_t a, int8x8_t b) { 2158 // CHECK: test_vqshl_u8 2159 return vqshl_u8(a, b); 2160 // CHECK: uqshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2161 } 2162 2163 uint16x4_t test_vqshl_u16(uint16x4_t a, int16x4_t b) { 2164 // CHECK: test_vqshl_u16 2165 return vqshl_u16(a, b); 2166 // CHECK: uqshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2167 } 2168 2169 uint32x2_t test_vqshl_u32(uint32x2_t a, int32x2_t b) { 2170 // CHECK: test_vqshl_u32 2171 return vqshl_u32(a, b); 2172 // CHECK: uqshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2173 } 2174 2175 uint64x1_t test_vqshl_u64(uint64x1_t a, int64x1_t b) { 2176 // CHECK: test_vqshl_u64 2177 return vqshl_u64(a, b); 2178 // CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2179 } 2180 2181 int8x16_t test_vqshlq_s8(int8x16_t a, int8x16_t b) { 2182 // CHECK: test_vqshlq_s8 2183 return vqshlq_s8(a, b); 2184 // CHECK: sqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2185 } 2186 2187 int16x8_t test_vqshlq_s16(int16x8_t a, int16x8_t b) { 2188 // CHECK: test_vqshlq_s16 2189 return vqshlq_s16(a, b); 2190 // CHECK: sqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2191 } 2192 2193 int32x4_t test_vqshlq_s32(int32x4_t a, int32x4_t b) { 2194 // CHECK: test_vqshlq_s32 2195 return vqshlq_s32(a, b); 2196 // CHECK: sqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2197 } 2198 2199 int64x2_t test_vqshlq_s64(int64x2_t a, int64x2_t b) { 2200 // CHECK: test_vqshlq_s64 2201 return vqshlq_s64(a, b); 2202 // CHECK: sqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2203 } 2204 2205 uint8x16_t test_vqshlq_u8(uint8x16_t a, int8x16_t b) { 2206 // CHECK: test_vqshlq_u8 2207 return vqshlq_u8(a, b); 2208 // CHECK: uqshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2209 } 2210 2211 uint16x8_t test_vqshlq_u16(uint16x8_t a, int16x8_t b) { 2212 // CHECK: test_vqshlq_u16 2213 return vqshlq_u16(a, b); 2214 // CHECK: uqshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2215 } 2216 2217 uint32x4_t test_vqshlq_u32(uint32x4_t a, int32x4_t b) { 2218 // CHECK: test_vqshlq_u32 2219 return vqshlq_u32(a, b); 2220 // CHECK: uqshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2221 } 2222 2223 uint64x2_t test_vqshlq_u64(uint64x2_t a, int64x2_t b) { 2224 // CHECK: test_vqshlq_u32 2225 return vqshlq_u64(a, b); 2226 // CHECK: uqshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2227 } 2228 2229 int8x8_t test_vrshl_s8(int8x8_t a, int8x8_t b) { 2230 // CHECK: test_vrshl_s8 2231 return vrshl_s8(a, b); 2232 // CHECK: srshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2233 } 2234 2235 int16x4_t test_vrshl_s16(int16x4_t a, int16x4_t b) { 2236 // CHECK: test_vrshl_s16 2237 return vrshl_s16(a, b); 2238 // CHECK: srshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2239 } 2240 2241 int32x2_t test_vrshl_s32(int32x2_t a, int32x2_t b) { 2242 // CHECK: test_vrshl_s32 2243 return vrshl_s32(a, b); 2244 // CHECK: srshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2245 } 2246 2247 int64x1_t test_vrshl_s64(int64x1_t a, int64x1_t b) { 2248 // CHECK: test_vrshl_s64 2249 return vrshl_s64(a, b); 2250 // CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2251 } 2252 2253 uint8x8_t test_vrshl_u8(uint8x8_t a, int8x8_t b) { 2254 // CHECK: test_vrshl_u8 2255 return vrshl_u8(a, b); 2256 // CHECK: urshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2257 } 2258 2259 uint16x4_t test_vrshl_u16(uint16x4_t a, int16x4_t b) { 2260 // CHECK: test_vrshl_u16 2261 return vrshl_u16(a, b); 2262 // CHECK: urshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2263 } 2264 2265 uint32x2_t test_vrshl_u32(uint32x2_t a, int32x2_t b) { 2266 // CHECK: test_vrshl_u32 2267 return vrshl_u32(a, b); 2268 // CHECK: urshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2269 } 2270 2271 uint64x1_t test_vrshl_u64(uint64x1_t a, int64x1_t b) { 2272 // CHECK: test_vrshl_u64 2273 return vrshl_u64(a, b); 2274 // CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2275 } 2276 2277 int8x16_t test_vrshlq_s8(int8x16_t a, int8x16_t b) { 2278 // CHECK: test_vrshlq_s8 2279 return vrshlq_s8(a, b); 2280 // CHECK: srshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2281 } 2282 2283 int16x8_t test_vrshlq_s16(int16x8_t a, int16x8_t b) { 2284 // CHECK: test_vrshlq_s16 2285 return vrshlq_s16(a, b); 2286 // CHECK: srshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2287 } 2288 2289 int32x4_t test_vrshlq_s32(int32x4_t a, int32x4_t b) { 2290 // CHECK: test_vrshlq_s32 2291 return vrshlq_s32(a, b); 2292 // CHECK: srshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2293 } 2294 2295 int64x2_t test_vrshlq_s64(int64x2_t a, int64x2_t b) { 2296 // CHECK: test_vrshlq_s64 2297 return vrshlq_s64(a, b); 2298 // CHECK: srshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2299 } 2300 2301 uint8x16_t test_vrshlq_u8(uint8x16_t a, int8x16_t b) { 2302 // CHECK: test_vrshlq_u8 2303 return vrshlq_u8(a, b); 2304 // CHECK: urshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2305 } 2306 2307 uint16x8_t test_vrshlq_u16(uint16x8_t a, int16x8_t b) { 2308 // CHECK: test_vrshlq_u16 2309 return vrshlq_u16(a, b); 2310 // CHECK: urshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2311 } 2312 2313 uint32x4_t test_vrshlq_u32(uint32x4_t a, int32x4_t b) { 2314 // CHECK: test_vrshlq_u32 2315 return vrshlq_u32(a, b); 2316 // CHECK: urshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2317 } 2318 2319 uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) { 2320 // CHECK: test_vrshlq_u64 2321 return vrshlq_u64(a, b); 2322 // CHECK: urshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2323 } 2324 2325 2326 int8x8_t test_vqrshl_s8(int8x8_t a, int8x8_t b) { 2327 // CHECK: test_vqrshl_s8 2328 return vqrshl_s8(a, b); 2329 // CHECK: sqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2330 } 2331 2332 int16x4_t test_vqrshl_s16(int16x4_t a, int16x4_t b) { 2333 // CHECK: test_vqrshl_s16 2334 return vqrshl_s16(a, b); 2335 // CHECK: sqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2336 } 2337 2338 int32x2_t test_vqrshl_s32(int32x2_t a, int32x2_t b) { 2339 // CHECK: test_vqrshl_s32 2340 return vqrshl_s32(a, b); 2341 // CHECK: sqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2342 } 2343 2344 int64x1_t test_vqrshl_s64(int64x1_t a, int64x1_t b) { 2345 // CHECK: test_vqrshl_s64 2346 return vqrshl_s64(a, b); 2347 // CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2348 } 2349 2350 uint8x8_t test_vqrshl_u8(uint8x8_t a, int8x8_t b) { 2351 // CHECK: test_vqrshl_u8 2352 return vqrshl_u8(a, b); 2353 // CHECK: uqrshl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2354 } 2355 2356 uint16x4_t test_vqrshl_u16(uint16x4_t a, int16x4_t b) { 2357 // CHECK: test_vqrshl_u16 2358 return vqrshl_u16(a, b); 2359 // CHECK: uqrshl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2360 } 2361 2362 uint32x2_t test_vqrshl_u32(uint32x2_t a, int32x2_t b) { 2363 // CHECK: test_vqrshl_u32 2364 return vqrshl_u32(a, b); 2365 // CHECK: uqrshl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2366 } 2367 2368 uint64x1_t test_vqrshl_u64(uint64x1_t a, int64x1_t b) { 2369 // CHECK: test_vqrshl_u64 2370 return vqrshl_u64(a, b); 2371 // CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 2372 } 2373 2374 int8x16_t test_vqrshlq_s8(int8x16_t a, int8x16_t b) { 2375 // CHECK: test_vqrshlq_s8 2376 return vqrshlq_s8(a, b); 2377 // CHECK: sqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2378 } 2379 2380 int16x8_t test_vqrshlq_s16(int16x8_t a, int16x8_t b) { 2381 // CHECK: test_vqrshlq_s16 2382 return vqrshlq_s16(a, b); 2383 // CHECK: sqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2384 } 2385 2386 int32x4_t test_vqrshlq_s32(int32x4_t a, int32x4_t b) { 2387 // CHECK: test_vqrshlq_s32 2388 return vqrshlq_s32(a, b); 2389 // CHECK: sqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2390 } 2391 2392 int64x2_t test_vqrshlq_s64(int64x2_t a, int64x2_t b) { 2393 // CHECK: test_vqrshlq_s64 2394 return vqrshlq_s64(a, b); 2395 // CHECK: sqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2396 } 2397 2398 // CHECK: test_vqrshlq_u8 2399 uint8x16_t test_vqrshlq_u8(uint8x16_t a, int8x16_t b) { 2400 return vqrshlq_u8(a, b); 2401 // CHECK: uqrshl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2402 } 2403 2404 uint16x8_t test_vqrshlq_u16(uint16x8_t a, int16x8_t b) { 2405 // CHECK: test_vqrshlq_u16 2406 return vqrshlq_u16(a, b); 2407 // CHECK: uqrshl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2408 } 2409 2410 uint32x4_t test_vqrshlq_u32(uint32x4_t a, int32x4_t b) { 2411 // CHECK: test_vqrshlq_u32 2412 return vqrshlq_u32(a, b); 2413 // CHECK: uqrshl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2414 } 2415 2416 uint64x2_t test_vqrshlq_u64(uint64x2_t a, int64x2_t b) { 2417 // CHECK: test_vqrshlq_u64 2418 return vqrshlq_u64(a, b); 2419 // CHECK: uqrshl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2420 } 2421 2422 int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) { 2423 // CHECK: test_vmax_s8 2424 return vmax_s8(a, b); 2425 // CHECK: smax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2426 } 2427 2428 int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) { 2429 // CHECK: test_vmax_s16 2430 return vmax_s16(a, b); 2431 // CHECK: smax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2432 } 2433 2434 int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) { 2435 // CHECK: test_vmax_s32 2436 return vmax_s32(a, b); 2437 // CHECK: smax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2438 } 2439 2440 uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) { 2441 // CHECK: test_vmax_u8 2442 return vmax_u8(a, b); 2443 // CHECK: umax {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2444 } 2445 2446 uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) { 2447 // CHECK: test_vmax_u16 2448 return vmax_u16(a, b); 2449 // CHECK: umax {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2450 } 2451 2452 uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) { 2453 // CHECK: test_vmax_u32 2454 return vmax_u32(a, b); 2455 // CHECK: umax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2456 } 2457 2458 float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) { 2459 // CHECK: test_vmax_f32 2460 return vmax_f32(a, b); 2461 // CHECK: fmax {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2462 } 2463 2464 int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) { 2465 // CHECK: test_vmaxq_s8 2466 return vmaxq_s8(a, b); 2467 // CHECK: smax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2468 } 2469 2470 int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) { 2471 // CHECK: test_vmaxq_s16 2472 return vmaxq_s16(a, b); 2473 // CHECK: smax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2474 } 2475 2476 int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) { 2477 // CHECK: test_vmaxq_s32 2478 return vmaxq_s32(a, b); 2479 // CHECK: smax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2480 } 2481 2482 uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) { 2483 // CHECK: test_vmaxq_u8 2484 return vmaxq_u8(a, b); 2485 // CHECK: umax {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2486 } 2487 2488 uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) { 2489 // CHECK: test_vmaxq_u16 2490 return vmaxq_u16(a, b); 2491 // CHECK: umax {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2492 } 2493 2494 uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) { 2495 // CHECK: test_vmaxq_u32 2496 return vmaxq_u32(a, b); 2497 // CHECK: umax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2498 } 2499 2500 float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) { 2501 // CHECK: test_vmaxq_f32 2502 return vmaxq_f32(a, b); 2503 // CHECK: fmax {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2504 } 2505 2506 float64x2_t test_vmaxq_f64(float64x2_t a, float64x2_t b) { 2507 // CHECK: test_vmaxq_f64 2508 return vmaxq_f64(a, b); 2509 // CHECK: fmax {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2510 } 2511 2512 2513 int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) { 2514 // CHECK: test_vmin_s8 2515 return vmin_s8(a, b); 2516 // CHECK: smin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2517 } 2518 2519 int16x4_t test_vmin_s16(int16x4_t a, int16x4_t b) { 2520 // CHECK: test_vmin_s16 2521 return vmin_s16(a, b); 2522 // CHECK: smin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2523 } 2524 2525 int32x2_t test_vmin_s32(int32x2_t a, int32x2_t b) { 2526 // CHECK: test_vmin_s32 2527 return vmin_s32(a, b); 2528 // CHECK: smin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2529 } 2530 2531 uint8x8_t test_vmin_u8(uint8x8_t a, uint8x8_t b) { 2532 // CHECK: test_vmin_u8 2533 return vmin_u8(a, b); 2534 // CHECK: umin {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2535 } 2536 2537 uint16x4_t test_vmin_u16(uint16x4_t a, uint16x4_t b) { 2538 // CHECK: test_vmin_u16 2539 return vmin_u16(a, b); 2540 // CHECK: umin {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2541 } 2542 2543 uint32x2_t test_vmin_u32(uint32x2_t a, uint32x2_t b) { 2544 // CHECK: test_vmin_u32 2545 return vmin_u32(a, b); 2546 // CHECK: umin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2547 } 2548 2549 float32x2_t test_vmin_f32(float32x2_t a, float32x2_t b) { 2550 // CHECK: test_vmin_f32 2551 return vmin_f32(a, b); 2552 // CHECK: fmin {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2553 } 2554 2555 int8x16_t test_vminq_s8(int8x16_t a, int8x16_t b) { 2556 // CHECK: test_vminq_s8 2557 return vminq_s8(a, b); 2558 // CHECK: smin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2559 } 2560 2561 int16x8_t test_vminq_s16(int16x8_t a, int16x8_t b) { 2562 // CHECK: test_vminq_s16 2563 return vminq_s16(a, b); 2564 // CHECK: smin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2565 } 2566 2567 int32x4_t test_vminq_s32(int32x4_t a, int32x4_t b) { 2568 // CHECK: test_vminq_s32 2569 return vminq_s32(a, b); 2570 // CHECK: smin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2571 } 2572 2573 uint8x16_t test_vminq_u8(uint8x16_t a, uint8x16_t b) { 2574 // CHECK: test_vminq_u8 2575 return vminq_u8(a, b); 2576 // CHECK: umin {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2577 } 2578 2579 uint16x8_t test_vminq_u16(uint16x8_t a, uint16x8_t b) { 2580 // CHECK: test_vminq_u16 2581 return vminq_u16(a, b); 2582 // CHECK: umin {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2583 } 2584 2585 uint32x4_t test_vminq_u32(uint32x4_t a, uint32x4_t b) { 2586 // CHECK: test_vminq_u32 2587 return vminq_u32(a, b); 2588 // CHECK: umin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2589 } 2590 2591 float32x4_t test_vminq_f32(float32x4_t a, float32x4_t b) { 2592 // CHECK: test_vminq_f32 2593 return vminq_f32(a, b); 2594 // CHECK: fmin {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2595 } 2596 2597 float64x2_t test_vminq_f64(float64x2_t a, float64x2_t b) { 2598 // CHECK: test_vminq_f64 2599 return vminq_f64(a, b); 2600 // CHECK: fmin {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2601 } 2602 2603 float32x2_t test_vmaxnm_f32(float32x2_t a, float32x2_t b) { 2604 // CHECK: test_vmaxnm_f32 2605 return vmaxnm_f32(a, b); 2606 // CHECK: fmaxnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2607 } 2608 2609 float32x4_t test_vmaxnmq_f32(float32x4_t a, float32x4_t b) { 2610 // CHECK: test_vmaxnmq_f32 2611 return vmaxnmq_f32(a, b); 2612 // CHECK: fmaxnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2613 } 2614 2615 float64x2_t test_vmaxnmq_f64(float64x2_t a, float64x2_t b) { 2616 // CHECK: test_vmaxnmq_f64 2617 return vmaxnmq_f64(a, b); 2618 // CHECK: fmaxnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2619 } 2620 2621 float32x2_t test_vminnm_f32(float32x2_t a, float32x2_t b) { 2622 // CHECK: test_vminnm_f32 2623 return vminnm_f32(a, b); 2624 // CHECK: fminnm {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2625 } 2626 2627 float32x4_t test_vminnmq_f32(float32x4_t a, float32x4_t b) { 2628 // CHECK: test_vminnmq_f32 2629 return vminnmq_f32(a, b); 2630 // CHECK: fminnm {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2631 } 2632 2633 float64x2_t test_vminnmq_f64(float64x2_t a, float64x2_t b) { 2634 // CHECK: test_vminnmq_f64 2635 return vminnmq_f64(a, b); 2636 // CHECK: fminnm {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2637 } 2638 2639 int8x8_t test_vpmax_s8(int8x8_t a, int8x8_t b) { 2640 // CHECK: test_vpmax_s8 2641 return vpmax_s8(a, b); 2642 // CHECK: smaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2643 } 2644 2645 int16x4_t test_vpmax_s16(int16x4_t a, int16x4_t b) { 2646 // CHECK: test_vpmax_s16 2647 return vpmax_s16(a, b); 2648 // CHECK: smaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2649 } 2650 2651 int32x2_t test_vpmax_s32(int32x2_t a, int32x2_t b) { 2652 // CHECK: test_vpmax_s32 2653 return vpmax_s32(a, b); 2654 // CHECK: smaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2655 } 2656 2657 uint8x8_t test_vpmax_u8(uint8x8_t a, uint8x8_t b) { 2658 // CHECK: test_vpmax_u8 2659 return vpmax_u8(a, b); 2660 // CHECK: umaxp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2661 } 2662 2663 uint16x4_t test_vpmax_u16(uint16x4_t a, uint16x4_t b) { 2664 // CHECK: test_vpmax_u16 2665 return vpmax_u16(a, b); 2666 // CHECK: umaxp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2667 } 2668 2669 uint32x2_t test_vpmax_u32(uint32x2_t a, uint32x2_t b) { 2670 // CHECK: test_vpmax_u32 2671 return vpmax_u32(a, b); 2672 // CHECK: umaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2673 } 2674 2675 float32x2_t test_vpmax_f32(float32x2_t a, float32x2_t b) { 2676 // CHECK: test_vpmax_f32 2677 return vpmax_f32(a, b); 2678 // CHECK: fmaxp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2679 } 2680 2681 int8x16_t test_vpmaxq_s8(int8x16_t a, int8x16_t b) { 2682 // CHECK: test_vpmaxq_s8 2683 return vpmaxq_s8(a, b); 2684 // CHECK: smaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2685 } 2686 2687 int16x8_t test_vpmaxq_s16(int16x8_t a, int16x8_t b) { 2688 // CHECK: test_vpmaxq_s16 2689 return vpmaxq_s16(a, b); 2690 // CHECK: smaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2691 } 2692 2693 int32x4_t test_vpmaxq_s32(int32x4_t a, int32x4_t b) { 2694 // CHECK: test_vpmaxq_s32 2695 return vpmaxq_s32(a, b); 2696 // CHECK: smaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2697 } 2698 2699 uint8x16_t test_vpmaxq_u8(uint8x16_t a, uint8x16_t b) { 2700 // CHECK: test_vpmaxq_u8 2701 return vpmaxq_u8(a, b); 2702 // CHECK: umaxp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2703 } 2704 2705 uint16x8_t test_vpmaxq_u16(uint16x8_t a, uint16x8_t b) { 2706 // CHECK: test_vpmaxq_u16 2707 return vpmaxq_u16(a, b); 2708 // CHECK: umaxp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2709 } 2710 2711 uint32x4_t test_vpmaxq_u32(uint32x4_t a, uint32x4_t b) { 2712 // CHECK: test_vpmaxq_u32 2713 return vpmaxq_u32(a, b); 2714 // CHECK: umaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2715 } 2716 2717 float32x4_t test_vpmaxq_f32(float32x4_t a, float32x4_t b) { 2718 // CHECK: test_vpmaxq_f32 2719 return vpmaxq_f32(a, b); 2720 // CHECK: fmaxp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2721 } 2722 2723 float64x2_t test_vpmaxq_f64(float64x2_t a, float64x2_t b) { 2724 // CHECK: test_vpmaxq_f64 2725 return vpmaxq_f64(a, b); 2726 // CHECK: fmaxp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2727 } 2728 2729 int8x8_t test_vpmin_s8(int8x8_t a, int8x8_t b) { 2730 // CHECK: test_vpmin_s8 2731 return vpmin_s8(a, b); 2732 // CHECK: sminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2733 } 2734 2735 int16x4_t test_vpmin_s16(int16x4_t a, int16x4_t b) { 2736 // CHECK: test_vpmin_s16 2737 return vpmin_s16(a, b); 2738 // CHECK: sminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2739 } 2740 2741 int32x2_t test_vpmin_s32(int32x2_t a, int32x2_t b) { 2742 // CHECK: test_vpmin_s32 2743 return vpmin_s32(a, b); 2744 // CHECK: sminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2745 } 2746 2747 uint8x8_t test_vpmin_u8(uint8x8_t a, uint8x8_t b) { 2748 // CHECK: test_vpmin_u8 2749 return vpmin_u8(a, b); 2750 // CHECK: uminp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2751 } 2752 2753 uint16x4_t test_vpmin_u16(uint16x4_t a, uint16x4_t b) { 2754 // CHECK: test_vpmin_u16 2755 return vpmin_u16(a, b); 2756 // CHECK: uminp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2757 } 2758 2759 uint32x2_t test_vpmin_u32(uint32x2_t a, uint32x2_t b) { 2760 // CHECK: test_vpmin_u32 2761 return vpmin_u32(a, b); 2762 // CHECK: uminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2763 } 2764 2765 float32x2_t test_vpmin_f32(float32x2_t a, float32x2_t b) { 2766 // CHECK: test_vpmin_f32 2767 return vpmin_f32(a, b); 2768 // CHECK: fminp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2769 } 2770 2771 int8x16_t test_vpminq_s8(int8x16_t a, int8x16_t b) { 2772 // CHECK: test_vpminq_s8 2773 return vpminq_s8(a, b); 2774 // CHECK: sminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2775 } 2776 2777 int16x8_t test_vpminq_s16(int16x8_t a, int16x8_t b) { 2778 // CHECK: test_vpminq_s16 2779 return vpminq_s16(a, b); 2780 // CHECK: sminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2781 } 2782 2783 int32x4_t test_vpminq_s32(int32x4_t a, int32x4_t b) { 2784 // CHECK: test_vpminq_s32 2785 return vpminq_s32(a, b); 2786 // CHECK: sminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2787 } 2788 2789 uint8x16_t test_vpminq_u8(uint8x16_t a, uint8x16_t b) { 2790 // CHECK: test_vpminq_u8 2791 return vpminq_u8(a, b); 2792 // CHECK: uminp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2793 } 2794 2795 uint16x8_t test_vpminq_u16(uint16x8_t a, uint16x8_t b) { 2796 // CHECK: test_vpminq_u16 2797 return vpminq_u16(a, b); 2798 // CHECK: uminp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2799 } 2800 2801 uint32x4_t test_vpminq_u32(uint32x4_t a, uint32x4_t b) { 2802 // CHECK: test_vpminq_u32 2803 return vpminq_u32(a, b); 2804 // CHECK: uminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2805 } 2806 2807 float32x4_t test_vpminq_f32(float32x4_t a, float32x4_t b) { 2808 // CHECK: test_vpminq_f32 2809 return vpminq_f32(a, b); 2810 // CHECK: fminp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2811 } 2812 2813 float64x2_t test_vpminq_f64(float64x2_t a, float64x2_t b) { 2814 // CHECK: test_vpminq_f64 2815 return vpminq_f64(a, b); 2816 // CHECK: fminp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2817 } 2818 2819 float32x2_t test_vpmaxnm_f32(float32x2_t a, float32x2_t b) { 2820 // CHECK: test_vpmaxnm_f32 2821 return vpmaxnm_f32(a, b); 2822 // CHECK: fmaxnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2823 } 2824 2825 float32x4_t test_vpmaxnmq_f32(float32x4_t a, float32x4_t b) { 2826 // CHECK: test_vpmaxnmq_f32 2827 return vpmaxnmq_f32(a, b); 2828 // CHECK: fmaxnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2829 } 2830 2831 float64x2_t test_vpmaxnmq_f64(float64x2_t a, float64x2_t b) { 2832 // CHECK: test_vpmaxnmq_f64 2833 return vpmaxnmq_f64(a, b); 2834 // CHECK: fmaxnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2835 } 2836 2837 float32x2_t test_vpminnm_f32(float32x2_t a, float32x2_t b) { 2838 // CHECK: test_vpminnm_f32 2839 return vpminnm_f32(a, b); 2840 // CHECK: fminnmp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2841 } 2842 2843 float32x4_t test_vpminnmq_f32(float32x4_t a, float32x4_t b) { 2844 // CHECK: test_vpminnmq_f32 2845 return vpminnmq_f32(a, b); 2846 // CHECK: fminnmp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2847 } 2848 2849 float64x2_t test_vpminnmq_f64(float64x2_t a, float64x2_t b) { 2850 // CHECK: test_vpminnmq_f64 2851 return vpminnmq_f64(a, b); 2852 // CHECK: fminnmp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2853 } 2854 2855 int8x8_t test_vpadd_s8(int8x8_t a, int8x8_t b) { 2856 // CHECK: test_vpadd_s8 2857 return vpadd_s8(a, b); 2858 // CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2859 } 2860 2861 int16x4_t test_vpadd_s16(int16x4_t a, int16x4_t b) { 2862 // CHECK: test_vpadd_s16 2863 return vpadd_s16(a, b); 2864 // CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2865 } 2866 2867 int32x2_t test_vpadd_s32(int32x2_t a, int32x2_t b) { 2868 // CHECK: test_vpadd_s32 2869 return vpadd_s32(a, b); 2870 // CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2871 } 2872 2873 uint8x8_t test_vpadd_u8(uint8x8_t a, uint8x8_t b) { 2874 // CHECK: test_vpadd_u8 2875 return vpadd_u8(a, b); 2876 // CHECK: addp {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, {{v[0-9]+}}.8b 2877 } 2878 2879 uint16x4_t test_vpadd_u16(uint16x4_t a, uint16x4_t b) { 2880 // CHECK: test_vpadd_u16 2881 return vpadd_u16(a, b); 2882 // CHECK: addp {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2883 } 2884 2885 uint32x2_t test_vpadd_u32(uint32x2_t a, uint32x2_t b) { 2886 // CHECK: test_vpadd_u32 2887 return vpadd_u32(a, b); 2888 // CHECK: addp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2889 } 2890 2891 float32x2_t test_vpadd_f32(float32x2_t a, float32x2_t b) { 2892 // CHECK: test_vpadd_f32 2893 return vpadd_f32(a, b); 2894 // CHECK: faddp {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2895 } 2896 2897 int8x16_t test_vpaddq_s8(int8x16_t a, int8x16_t b) { 2898 // CHECK: test_vpaddq_s8 2899 return vpaddq_s8(a, b); 2900 // CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2901 } 2902 2903 int16x8_t test_vpaddq_s16(int16x8_t a, int16x8_t b) { 2904 // CHECK: test_vpaddq_s16 2905 return vpaddq_s16(a, b); 2906 // CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2907 } 2908 2909 int32x4_t test_vpaddq_s32(int32x4_t a, int32x4_t b) { 2910 // CHECK: test_vpaddq_s32 2911 return vpaddq_s32(a, b); 2912 // CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2913 } 2914 2915 uint8x16_t test_vpaddq_u8(uint8x16_t a, uint8x16_t b) { 2916 // CHECK: test_vpaddq_u8 2917 return vpaddq_u8(a, b); 2918 // CHECK: addp {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, {{v[0-9]+}}.16b 2919 } 2920 2921 uint16x8_t test_vpaddq_u16(uint16x8_t a, uint16x8_t b) { 2922 // CHECK: test_vpaddq_u16 2923 return vpaddq_u16(a, b); 2924 // CHECK: addp {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2925 } 2926 2927 uint32x4_t test_vpaddq_u32(uint32x4_t a, uint32x4_t b) { 2928 // CHECK: test_vpaddq_u32 2929 return vpaddq_u32(a, b); 2930 // CHECK: addp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2931 } 2932 2933 float32x4_t test_vpaddq_f32(float32x4_t a, float32x4_t b) { 2934 // CHECK: test_vpaddq_f32 2935 return vpaddq_f32(a, b); 2936 // CHECK: faddp {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2937 } 2938 2939 float64x2_t test_vpaddq_f64(float64x2_t a, float64x2_t b) { 2940 // CHECK: test_vpaddq_f64 2941 return vpaddq_f64(a, b); 2942 // CHECK: faddp {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 2943 } 2944 2945 int16x4_t test_vqdmulh_s16(int16x4_t a, int16x4_t b) { 2946 // CHECK: test_vqdmulh_s16 2947 return vqdmulh_s16(a, b); 2948 // CHECK: sqdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2949 } 2950 2951 int32x2_t test_vqdmulh_s32(int32x2_t a, int32x2_t b) { 2952 // CHECK: test_vqdmulh_s32 2953 return vqdmulh_s32(a, b); 2954 // CHECK: sqdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2955 } 2956 2957 int16x8_t test_vqdmulhq_s16(int16x8_t a, int16x8_t b) { 2958 // CHECK: test_vqdmulhq_s16 2959 return vqdmulhq_s16(a, b); 2960 // CHECK: sqdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2961 } 2962 2963 int32x4_t test_vqdmulhq_s32(int32x4_t a, int32x4_t b) { 2964 // CHECK: test_vqdmulhq_s32 2965 return vqdmulhq_s32(a, b); 2966 // CHECK: sqdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2967 } 2968 2969 int16x4_t test_vqrdmulh_s16(int16x4_t a, int16x4_t b) { 2970 // CHECK: test_vqrdmulh_s16 2971 return vqrdmulh_s16(a, b); 2972 // CHECK: sqrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.4h 2973 } 2974 2975 int32x2_t test_vqrdmulh_s32(int32x2_t a, int32x2_t b) { 2976 // CHECK: test_vqrdmulh_s32 2977 return vqrdmulh_s32(a, b); 2978 // CHECK: sqrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2979 } 2980 2981 int16x8_t test_vqrdmulhq_s16(int16x8_t a, int16x8_t b) { 2982 // CHECK: test_vqrdmulhq_s16 2983 return vqrdmulhq_s16(a, b); 2984 // CHECK: sqrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.8h 2985 } 2986 2987 int32x4_t test_vqrdmulhq_s32(int32x4_t a, int32x4_t b) { 2988 // CHECK: test_vqrdmulhq_s32 2989 return vqrdmulhq_s32(a, b); 2990 // CHECK: sqrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 2991 } 2992 2993 2994 float32x2_t test_vmulx_f32(float32x2_t a, float32x2_t b) { 2995 // CHECK: test_vmulx_f32 2996 return vmulx_f32(a, b); 2997 // CHECK: fmulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.2s 2998 } 2999 3000 float32x4_t test_vmulxq_f32(float32x4_t a, float32x4_t b) { 3001 // CHECK: test_vmulxq_f32 3002 return vmulxq_f32(a, b); 3003 // CHECK: fmulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.4s 3004 } 3005 3006 float64x2_t test_vmulxq_f64(float64x2_t a, float64x2_t b) { 3007 // CHECK: test_vmulxq_f64 3008 return vmulxq_f64(a, b); 3009 // CHECK: fmulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.2d 3010 } 3011 3012 int8x8_t test_vshl_n_s8(int8x8_t a) { 3013 // CHECK: test_vshl_n_s8 3014 return vshl_n_s8(a, 3); 3015 // CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3016 } 3017 3018 int16x4_t test_vshl_n_s16(int16x4_t a) { 3019 // CHECK: test_vshl_n_s16 3020 return vshl_n_s16(a, 3); 3021 // CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3022 } 3023 3024 int32x2_t test_vshl_n_s32(int32x2_t a) { 3025 // CHECK: test_vshl_n_s32 3026 return vshl_n_s32(a, 3); 3027 // CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3028 } 3029 3030 int8x16_t test_vshlq_n_s8(int8x16_t a) { 3031 // CHECK: test_vshlq_n_s8 3032 return vshlq_n_s8(a, 3); 3033 // CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3034 } 3035 3036 int16x8_t test_vshlq_n_s16(int16x8_t a) { 3037 // CHECK: test_vshlq_n_s16 3038 return vshlq_n_s16(a, 3); 3039 // CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3040 } 3041 3042 int32x4_t test_vshlq_n_s32(int32x4_t a) { 3043 // CHECK: test_vshlq_n_s32 3044 return vshlq_n_s32(a, 3); 3045 // CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3046 } 3047 3048 int64x2_t test_vshlq_n_s64(int64x2_t a) { 3049 // CHECK: test_vshlq_n_s64 3050 return vshlq_n_s64(a, 3); 3051 // CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3052 } 3053 3054 int8x8_t test_vshl_n_u8(int8x8_t a) { 3055 // CHECK: test_vshl_n_u8 3056 return vshl_n_u8(a, 3); 3057 // CHECK: shl {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3058 } 3059 3060 int16x4_t test_vshl_n_u16(int16x4_t a) { 3061 // CHECK: test_vshl_n_u16 3062 return vshl_n_u16(a, 3); 3063 // CHECK: shl {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3064 } 3065 3066 int32x2_t test_vshl_n_u32(int32x2_t a) { 3067 // CHECK: test_vshl_n_u32 3068 return vshl_n_u32(a, 3); 3069 // CHECK: shl {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3070 } 3071 3072 int8x16_t test_vshlq_n_u8(int8x16_t a) { 3073 // CHECK: test_vshlq_n_u8 3074 return vshlq_n_u8(a, 3); 3075 // CHECK: shl {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3076 } 3077 3078 int16x8_t test_vshlq_n_u16(int16x8_t a) { 3079 // CHECK: test_vshlq_n_u16 3080 return vshlq_n_u16(a, 3); 3081 // CHECK: shl {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3082 } 3083 3084 int32x4_t test_vshlq_n_u32(int32x4_t a) { 3085 // CHECK: test_vshlq_n_u32 3086 return vshlq_n_u32(a, 3); 3087 // CHECK: shl {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3088 } 3089 3090 int64x2_t test_vshlq_n_u64(int64x2_t a) { 3091 // CHECK: test_vshlq_n_u64 3092 return vshlq_n_u64(a, 3); 3093 // CHECK: shl {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3094 } 3095 3096 int8x8_t test_vshr_n_s8(int8x8_t a) { 3097 // CHECK: test_vshr_n_s8 3098 return vshr_n_s8(a, 3); 3099 // CHECK: sshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3100 } 3101 3102 int16x4_t test_vshr_n_s16(int16x4_t a) { 3103 // CHECK: test_vshr_n_s16 3104 return vshr_n_s16(a, 3); 3105 // CHECK: sshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3106 } 3107 3108 int32x2_t test_vshr_n_s32(int32x2_t a) { 3109 // CHECK: test_vshr_n_s32 3110 return vshr_n_s32(a, 3); 3111 // CHECK: sshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3112 } 3113 3114 int8x16_t test_vshrq_n_s8(int8x16_t a) { 3115 // CHECK: test_vshrq_n_s8 3116 return vshrq_n_s8(a, 3); 3117 // CHECK: sshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3118 } 3119 3120 int16x8_t test_vshrq_n_s16(int16x8_t a) { 3121 // CHECK: test_vshrq_n_s16 3122 return vshrq_n_s16(a, 3); 3123 // CHECK: sshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3124 } 3125 3126 int32x4_t test_vshrq_n_s32(int32x4_t a) { 3127 // CHECK: test_vshrq_n_s32 3128 return vshrq_n_s32(a, 3); 3129 // CHECK: sshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3130 } 3131 3132 int64x2_t test_vshrq_n_s64(int64x2_t a) { 3133 // CHECK: test_vshrq_n_s64 3134 return vshrq_n_s64(a, 3); 3135 // CHECK: sshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3136 } 3137 3138 int8x8_t test_vshr_n_u8(int8x8_t a) { 3139 // CHECK: test_vshr_n_u8 3140 return vshr_n_u8(a, 3); 3141 // CHECK: ushr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3142 } 3143 3144 int16x4_t test_vshr_n_u16(int16x4_t a) { 3145 // CHECK: test_vshr_n_u16 3146 return vshr_n_u16(a, 3); 3147 // CHECK: ushr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3148 } 3149 3150 int32x2_t test_vshr_n_u32(int32x2_t a) { 3151 // CHECK: test_vshr_n_u32 3152 return vshr_n_u32(a, 3); 3153 // CHECK: ushr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3154 } 3155 3156 int8x16_t test_vshrq_n_u8(int8x16_t a) { 3157 // CHECK: test_vshrq_n_u8 3158 return vshrq_n_u8(a, 3); 3159 // CHECK: ushr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3160 } 3161 3162 int16x8_t test_vshrq_n_u16(int16x8_t a) { 3163 // CHECK: test_vshrq_n_u16 3164 return vshrq_n_u16(a, 3); 3165 // CHECK: ushr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3166 } 3167 3168 int32x4_t test_vshrq_n_u32(int32x4_t a) { 3169 // CHECK: test_vshrq_n_u32 3170 return vshrq_n_u32(a, 3); 3171 // CHECK: ushr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3172 } 3173 3174 int64x2_t test_vshrq_n_u64(int64x2_t a) { 3175 // CHECK: test_vshrq_n_u64 3176 return vshrq_n_u64(a, 3); 3177 // CHECK: ushr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3178 } 3179 3180 int8x8_t test_vsra_n_s8(int8x8_t a, int8x8_t b) { 3181 // CHECK: test_vsra_n_s8 3182 return vsra_n_s8(a, b, 3); 3183 // CHECK: ssra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3184 } 3185 3186 int16x4_t test_vsra_n_s16(int16x4_t a, int16x4_t b) { 3187 // CHECK: test_vsra_n_s16 3188 return vsra_n_s16(a, b, 3); 3189 // CHECK: ssra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3190 } 3191 3192 int32x2_t test_vsra_n_s32(int32x2_t a, int32x2_t b) { 3193 // CHECK: test_vsra_n_s32 3194 return vsra_n_s32(a, b, 3); 3195 // CHECK: ssra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3196 } 3197 3198 int8x16_t test_vsraq_n_s8(int8x16_t a, int8x16_t b) { 3199 // CHECK: test_vsraq_n_s8 3200 return vsraq_n_s8(a, b, 3); 3201 // CHECK: ssra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3202 } 3203 3204 int16x8_t test_vsraq_n_s16(int16x8_t a, int16x8_t b) { 3205 // CHECK: test_vsraq_n_s16 3206 return vsraq_n_s16(a, b, 3); 3207 // CHECK: ssra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3208 } 3209 3210 int32x4_t test_vsraq_n_s32(int32x4_t a, int32x4_t b) { 3211 // CHECK: test_vsraq_n_s32 3212 return vsraq_n_s32(a, b, 3); 3213 // CHECK: ssra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3214 } 3215 3216 int64x2_t test_vsraq_n_s64(int64x2_t a, int64x2_t b) { 3217 // CHECK: test_vsraq_n_s64 3218 return vsraq_n_s64(a, b, 3); 3219 // CHECK: ssra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3220 } 3221 3222 int8x8_t test_vsra_n_u8(int8x8_t a, int8x8_t b) { 3223 // CHECK: test_vsra_n_u8 3224 return vsra_n_u8(a, b, 3); 3225 // CHECK: usra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3226 } 3227 3228 int16x4_t test_vsra_n_u16(int16x4_t a, int16x4_t b) { 3229 // CHECK: test_vsra_n_u16 3230 return vsra_n_u16(a, b, 3); 3231 // CHECK: usra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3232 } 3233 3234 int32x2_t test_vsra_n_u32(int32x2_t a, int32x2_t b) { 3235 // CHECK: test_vsra_n_u32 3236 return vsra_n_u32(a, b, 3); 3237 // CHECK: usra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3238 } 3239 3240 int8x16_t test_vsraq_n_u8(int8x16_t a, int8x16_t b) { 3241 // CHECK: test_vsraq_n_u8 3242 return vsraq_n_u8(a, b, 3); 3243 // CHECK: usra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3244 } 3245 3246 int16x8_t test_vsraq_n_u16(int16x8_t a, int16x8_t b) { 3247 // CHECK: test_vsraq_n_u16 3248 return vsraq_n_u16(a, b, 3); 3249 // CHECK: usra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3250 } 3251 3252 int32x4_t test_vsraq_n_u32(int32x4_t a, int32x4_t b) { 3253 // CHECK: test_vsraq_n_u32 3254 return vsraq_n_u32(a, b, 3); 3255 // CHECK: usra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3256 } 3257 3258 int64x2_t test_vsraq_n_u64(int64x2_t a, int64x2_t b) { 3259 // CHECK: test_vsraq_n_u64 3260 return vsraq_n_u64(a, b, 3); 3261 // CHECK: usra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3262 } 3263 3264 int8x8_t test_vrshr_n_s8(int8x8_t a) { 3265 // CHECK: test_vrshr_n_s8 3266 return vrshr_n_s8(a, 3); 3267 // CHECK: srshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3268 } 3269 3270 int16x4_t test_vrshr_n_s16(int16x4_t a) { 3271 // CHECK: test_vrshr_n_s16 3272 return vrshr_n_s16(a, 3); 3273 // CHECK: srshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3274 } 3275 3276 int32x2_t test_vrshr_n_s32(int32x2_t a) { 3277 // CHECK: test_vrshr_n_s32 3278 return vrshr_n_s32(a, 3); 3279 // CHECK: srshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3280 } 3281 3282 int8x16_t test_vrshrq_n_s8(int8x16_t a) { 3283 // CHECK: test_vrshrq_n_s8 3284 return vrshrq_n_s8(a, 3); 3285 // CHECK: srshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3286 } 3287 3288 int16x8_t test_vrshrq_n_s16(int16x8_t a) { 3289 // CHECK: test_vrshrq_n_s16 3290 return vrshrq_n_s16(a, 3); 3291 // CHECK: srshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3292 } 3293 3294 int32x4_t test_vrshrq_n_s32(int32x4_t a) { 3295 // CHECK: test_vrshrq_n_s32 3296 return vrshrq_n_s32(a, 3); 3297 // CHECK: srshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3298 } 3299 3300 int64x2_t test_vrshrq_n_s64(int64x2_t a) { 3301 // CHECK: test_vrshrq_n_s64 3302 return vrshrq_n_s64(a, 3); 3303 // CHECK: srshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3304 } 3305 3306 int8x8_t test_vrshr_n_u8(int8x8_t a) { 3307 // CHECK: test_vrshr_n_u8 3308 return vrshr_n_u8(a, 3); 3309 // CHECK: urshr {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3310 } 3311 3312 int16x4_t test_vrshr_n_u16(int16x4_t a) { 3313 // CHECK: test_vrshr_n_u16 3314 return vrshr_n_u16(a, 3); 3315 // CHECK: urshr {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3316 } 3317 3318 int32x2_t test_vrshr_n_u32(int32x2_t a) { 3319 // CHECK: test_vrshr_n_u32 3320 return vrshr_n_u32(a, 3); 3321 // CHECK: urshr {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3322 } 3323 3324 int8x16_t test_vrshrq_n_u8(int8x16_t a) { 3325 // CHECK: test_vrshrq_n_u8 3326 return vrshrq_n_u8(a, 3); 3327 // CHECK: urshr {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3328 } 3329 3330 int16x8_t test_vrshrq_n_u16(int16x8_t a) { 3331 // CHECK: test_vrshrq_n_u16 3332 return vrshrq_n_u16(a, 3); 3333 // CHECK: urshr {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3334 } 3335 3336 int32x4_t test_vrshrq_n_u32(int32x4_t a) { 3337 // CHECK: test_vrshrq_n_u32 3338 return vrshrq_n_u32(a, 3); 3339 // CHECK: urshr {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3340 } 3341 3342 int64x2_t test_vrshrq_n_u64(int64x2_t a) { 3343 // CHECK: test_vrshrq_n_u64 3344 return vrshrq_n_u64(a, 3); 3345 // CHECK: urshr {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3346 } 3347 3348 int8x8_t test_vrsra_n_s8(int8x8_t a, int8x8_t b) { 3349 // CHECK: test_vrsra_n_s8 3350 return vrsra_n_s8(a, b, 3); 3351 // CHECK: srsra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3352 } 3353 3354 int16x4_t test_vrsra_n_s16(int16x4_t a, int16x4_t b) { 3355 // CHECK: test_vrsra_n_s16 3356 return vrsra_n_s16(a, b, 3); 3357 // CHECK: srsra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3358 } 3359 3360 int32x2_t test_vrsra_n_s32(int32x2_t a, int32x2_t b) { 3361 // CHECK: test_vrsra_n_s32 3362 return vrsra_n_s32(a, b, 3); 3363 // CHECK: srsra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3364 } 3365 3366 int8x16_t test_vrsraq_n_s8(int8x16_t a, int8x16_t b) { 3367 // CHECK: test_vrsraq_n_s8 3368 return vrsraq_n_s8(a, b, 3); 3369 // CHECK: srsra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3370 } 3371 3372 int16x8_t test_vrsraq_n_s16(int16x8_t a, int16x8_t b) { 3373 // CHECK: test_vrsraq_n_s16 3374 return vrsraq_n_s16(a, b, 3); 3375 // CHECK: srsra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3376 } 3377 3378 int32x4_t test_vrsraq_n_s32(int32x4_t a, int32x4_t b) { 3379 // CHECK: test_vrsraq_n_s32 3380 return vrsraq_n_s32(a, b, 3); 3381 // CHECK: srsra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3382 } 3383 3384 int64x2_t test_vrsraq_n_s64(int64x2_t a, int64x2_t b) { 3385 // CHECK: test_vrsraq_n_s64 3386 return vrsraq_n_s64(a, b, 3); 3387 // CHECK: srsra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3388 } 3389 3390 int8x8_t test_vrsra_n_u8(int8x8_t a, int8x8_t b) { 3391 // CHECK: test_vrsra_n_u8 3392 return vrsra_n_u8(a, b, 3); 3393 // CHECK: ursra {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3394 } 3395 3396 int16x4_t test_vrsra_n_u16(int16x4_t a, int16x4_t b) { 3397 // CHECK: test_vrsra_n_u16 3398 return vrsra_n_u16(a, b, 3); 3399 // CHECK: ursra {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3400 } 3401 3402 int32x2_t test_vrsra_n_u32(int32x2_t a, int32x2_t b) { 3403 // CHECK: test_vrsra_n_u32 3404 return vrsra_n_u32(a, b, 3); 3405 // CHECK: ursra {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3406 } 3407 3408 int8x16_t test_vrsraq_n_u8(int8x16_t a, int8x16_t b) { 3409 // CHECK: test_vrsraq_n_u8 3410 return vrsraq_n_u8(a, b, 3); 3411 // CHECK: ursra {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3412 } 3413 3414 int16x8_t test_vrsraq_n_u16(int16x8_t a, int16x8_t b) { 3415 // CHECK: test_vrsraq_n_u16 3416 return vrsraq_n_u16(a, b, 3); 3417 // CHECK: ursra {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3418 } 3419 3420 int32x4_t test_vrsraq_n_u32(int32x4_t a, int32x4_t b) { 3421 // CHECK: test_vrsraq_n_u32 3422 return vrsraq_n_u32(a, b, 3); 3423 // CHECK: ursra {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3424 } 3425 3426 int64x2_t test_vrsraq_n_u64(int64x2_t a, int64x2_t b) { 3427 // CHECK: test_vrsraq_n_u64 3428 return vrsraq_n_u64(a, b, 3); 3429 // CHECK: ursra {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3430 } 3431 3432 int8x8_t test_vsri_n_s8(int8x8_t a, int8x8_t b) { 3433 // CHECK: test_vsri_n_s8 3434 return vsri_n_s8(a, b, 3); 3435 // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3436 } 3437 3438 int16x4_t test_vsri_n_s16(int16x4_t a, int16x4_t b) { 3439 // CHECK: test_vsri_n_s16 3440 return vsri_n_s16(a, b, 3); 3441 // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3442 } 3443 3444 int32x2_t test_vsri_n_s32(int32x2_t a, int32x2_t b) { 3445 // CHECK: test_vsri_n_s32 3446 return vsri_n_s32(a, b, 3); 3447 // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3448 } 3449 3450 int8x16_t test_vsriq_n_s8(int8x16_t a, int8x16_t b) { 3451 // CHECK: test_vsriq_n_s8 3452 return vsriq_n_s8(a, b, 3); 3453 // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3454 } 3455 3456 int16x8_t test_vsriq_n_s16(int16x8_t a, int16x8_t b) { 3457 // CHECK: test_vsriq_n_s16 3458 return vsriq_n_s16(a, b, 3); 3459 // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3460 } 3461 3462 int32x4_t test_vsriq_n_s32(int32x4_t a, int32x4_t b) { 3463 // CHECK: test_vsriq_n_s32 3464 return vsriq_n_s32(a, b, 3); 3465 // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3466 } 3467 3468 int64x2_t test_vsriq_n_s64(int64x2_t a, int64x2_t b) { 3469 // CHECK: test_vsriq_n_s64 3470 return vsriq_n_s64(a, b, 3); 3471 // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3472 } 3473 3474 int8x8_t test_vsri_n_u8(int8x8_t a, int8x8_t b) { 3475 // CHECK: test_vsri_n_u8 3476 return vsri_n_u8(a, b, 3); 3477 // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3478 } 3479 3480 int16x4_t test_vsri_n_u16(int16x4_t a, int16x4_t b) { 3481 // CHECK: test_vsri_n_u16 3482 return vsri_n_u16(a, b, 3); 3483 // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3484 } 3485 3486 int32x2_t test_vsri_n_u32(int32x2_t a, int32x2_t b) { 3487 // CHECK: test_vsri_n_u32 3488 return vsri_n_u32(a, b, 3); 3489 // CHECK: sri {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3490 } 3491 3492 int8x16_t test_vsriq_n_u8(int8x16_t a, int8x16_t b) { 3493 // CHECK: test_vsriq_n_u8 3494 return vsriq_n_u8(a, b, 3); 3495 // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3496 } 3497 3498 int16x8_t test_vsriq_n_u16(int16x8_t a, int16x8_t b) { 3499 // CHECK: test_vsriq_n_u16 3500 return vsriq_n_u16(a, b, 3); 3501 // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3502 } 3503 3504 int32x4_t test_vsriq_n_u32(int32x4_t a, int32x4_t b) { 3505 // CHECK: test_vsriq_n_u32 3506 return vsriq_n_u32(a, b, 3); 3507 // CHECK: sri {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3508 } 3509 3510 int64x2_t test_vsriq_n_u64(int64x2_t a, int64x2_t b) { 3511 // CHECK: test_vsriq_n_u64 3512 return vsriq_n_u64(a, b, 3); 3513 // CHECK: sri {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3514 } 3515 3516 poly8x8_t test_vsri_n_p8(poly8x8_t a, poly8x8_t b) { 3517 // CHECK: test_vsri_n_p8 3518 return vsri_n_p8(a, b, 3); 3519 // CHECK: sri {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3520 } 3521 3522 poly16x4_t test_vsri_n_p16(poly16x4_t a, poly16x4_t b) { 3523 // CHECK: test_vsri_n_p16 3524 return vsri_n_p16(a, b, 15); 3525 // CHECK: sri {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15 3526 } 3527 3528 poly8x16_t test_vsriq_n_p8(poly8x16_t a, poly8x16_t b) { 3529 // CHECK: test_vsriq_n_p8 3530 return vsriq_n_p8(a, b, 3); 3531 // CHECK: sri {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3532 } 3533 3534 poly16x8_t test_vsriq_n_p16(poly16x8_t a, poly16x8_t b) { 3535 // CHECK: test_vsriq_n_p16 3536 return vsriq_n_p16(a, b, 15); 3537 // CHECK: sri {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15 3538 } 3539 3540 int8x8_t test_vsli_n_s8(int8x8_t a, int8x8_t b) { 3541 // CHECK: test_vsli_n_s8 3542 return vsli_n_s8(a, b, 3); 3543 // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3544 } 3545 3546 int16x4_t test_vsli_n_s16(int16x4_t a, int16x4_t b) { 3547 // CHECK: test_vsli_n_s16 3548 return vsli_n_s16(a, b, 3); 3549 // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3550 } 3551 3552 int32x2_t test_vsli_n_s32(int32x2_t a, int32x2_t b) { 3553 // CHECK: test_vsli_n_s32 3554 return vsli_n_s32(a, b, 3); 3555 // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3556 } 3557 3558 int8x16_t test_vsliq_n_s8(int8x16_t a, int8x16_t b) { 3559 // CHECK: test_vsliq_n_s8 3560 return vsliq_n_s8(a, b, 3); 3561 // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3562 } 3563 3564 int16x8_t test_vsliq_n_s16(int16x8_t a, int16x8_t b) { 3565 // CHECK: test_vsliq_n_s16 3566 return vsliq_n_s16(a, b, 3); 3567 // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3568 } 3569 3570 int32x4_t test_vsliq_n_s32(int32x4_t a, int32x4_t b) { 3571 // CHECK: test_vsliq_n_s32 3572 return vsliq_n_s32(a, b, 3); 3573 // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3574 } 3575 3576 int64x2_t test_vsliq_n_s64(int64x2_t a, int64x2_t b) { 3577 // CHECK: test_vsliq_n_s64 3578 return vsliq_n_s64(a, b, 3); 3579 // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3580 } 3581 3582 uint8x8_t test_vsli_n_u8(uint8x8_t a, uint8x8_t b) { 3583 // CHECK: test_vsli_n_u8 3584 return vsli_n_u8(a, b, 3); 3585 // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3586 } 3587 3588 uint16x4_t test_vsli_n_u16(uint16x4_t a, uint16x4_t b) { 3589 // CHECK: test_vsli_n_u16 3590 return vsli_n_u16(a, b, 3); 3591 // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3592 } 3593 3594 uint32x2_t test_vsli_n_u32(uint32x2_t a, uint32x2_t b) { 3595 // CHECK: test_vsli_n_u32 3596 return vsli_n_u32(a, b, 3); 3597 // CHECK: sli {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3598 } 3599 3600 uint8x16_t test_vsliq_n_u8(uint8x16_t a, uint8x16_t b) { 3601 // CHECK: test_vsliq_n_u8 3602 return vsliq_n_u8(a, b, 3); 3603 // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3604 } 3605 3606 uint16x8_t test_vsliq_n_u16(uint16x8_t a, uint16x8_t b) { 3607 // CHECK: test_vsliq_n_u16 3608 return vsliq_n_u16(a, b, 3); 3609 // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3610 } 3611 3612 uint32x4_t test_vsliq_n_u32(uint32x4_t a, uint32x4_t b) { 3613 // CHECK: test_vsliq_n_u32 3614 return vsliq_n_u32(a, b, 3); 3615 // CHECK: sli {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3616 } 3617 3618 uint64x2_t test_vsliq_n_u64(uint64x2_t a, uint64x2_t b) { 3619 // CHECK: test_vsliq_n_u64 3620 return vsliq_n_u64(a, b, 3); 3621 // CHECK: sli {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3622 } 3623 3624 poly8x8_t test_vsli_n_p8(poly8x8_t a, poly8x8_t b) { 3625 // CHECK: test_vsli_n_p8 3626 return vsli_n_p8(a, b, 3); 3627 // CHECK: sli {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3628 } 3629 3630 poly16x4_t test_vsli_n_p16(poly16x4_t a, poly16x4_t b) { 3631 // CHECK: test_vsli_n_p16 3632 return vsli_n_p16(a, b, 15); 3633 // CHECK: sli {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #15 3634 } 3635 3636 poly8x16_t test_vsliq_n_p8(poly8x16_t a, poly8x16_t b) { 3637 // CHECK: test_vsliq_n_p8 3638 return vsliq_n_p8(a, b, 3); 3639 // CHECK: sli {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3640 } 3641 3642 poly16x8_t test_vsliq_n_p16(poly16x8_t a, poly16x8_t b) { 3643 // CHECK: test_vsliq_n_p16 3644 return vsliq_n_p16(a, b, 15); 3645 // CHECK: sli {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #15 3646 } 3647 3648 int8x8_t test_vqshlu_n_s8(int8x8_t a) { 3649 // CHECK: test_vqshlu_n_s8 3650 return vqshlu_n_s8(a, 3); 3651 // CHECK: sqshlu {{v[0-9]+}}.8b, {{v[0-9]+}}.8b, #3 3652 } 3653 3654 int16x4_t test_vqshlu_n_s16(int16x4_t a) { 3655 // CHECK: test_vqshlu_n_s16 3656 return vqshlu_n_s16(a, 3); 3657 // CHECK: sqshlu {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, #3 3658 } 3659 3660 int32x2_t test_vqshlu_n_s32(int32x2_t a) { 3661 // CHECK: test_vqshlu_n_s32 3662 return vqshlu_n_s32(a, 3); 3663 // CHECK: sqshlu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #3 3664 } 3665 3666 int8x16_t test_vqshluq_n_s8(int8x16_t a) { 3667 // CHECK: test_vqshluq_n_s8 3668 return vqshluq_n_s8(a, 3); 3669 // CHECK: sqshlu {{v[0-9]+}}.16b, {{v[0-9]+}}.16b, #3 3670 } 3671 3672 int16x8_t test_vqshluq_n_s16(int16x8_t a) { 3673 // CHECK: test_vqshluq_n_s16 3674 return vqshluq_n_s16(a, 3); 3675 // CHECK: sqshlu {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, #3 3676 } 3677 3678 int32x4_t test_vqshluq_n_s32(int32x4_t a) { 3679 // CHECK: test_vqshluq_n_s32 3680 return vqshluq_n_s32(a, 3); 3681 // CHECK: sqshlu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #3 3682 } 3683 3684 int64x2_t test_vqshluq_n_s64(int64x2_t a) { 3685 // CHECK: test_vqshluq_n_s64 3686 return vqshluq_n_s64(a, 3); 3687 // CHECK: sqshlu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #3 3688 } 3689 3690 int8x8_t test_vshrn_n_s16(int16x8_t a) { 3691 // CHECK: test_vshrn_n_s16 3692 return vshrn_n_s16(a, 3); 3693 // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3694 } 3695 3696 int16x4_t test_vshrn_n_s32(int32x4_t a) { 3697 // CHECK: test_vshrn_n_s32 3698 return vshrn_n_s32(a, 9); 3699 // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3700 } 3701 3702 int32x2_t test_vshrn_n_s64(int64x2_t a) { 3703 // CHECK: test_vshrn_n_s64 3704 return vshrn_n_s64(a, 19); 3705 // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3706 } 3707 3708 uint8x8_t test_vshrn_n_u16(uint16x8_t a) { 3709 // CHECK: test_vshrn_n_u16 3710 return vshrn_n_u16(a, 3); 3711 // CHECK: shrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3712 } 3713 3714 uint16x4_t test_vshrn_n_u32(uint32x4_t a) { 3715 // CHECK: test_vshrn_n_u32 3716 return vshrn_n_u32(a, 9); 3717 // CHECK: shrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3718 } 3719 3720 uint32x2_t test_vshrn_n_u64(uint64x2_t a) { 3721 // CHECK: test_vshrn_n_u64 3722 return vshrn_n_u64(a, 19); 3723 // CHECK: shrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3724 } 3725 3726 int8x16_t test_vshrn_high_n_s16(int8x8_t a, int16x8_t b) { 3727 // CHECK: test_vshrn_high_n_s16 3728 return vshrn_high_n_s16(a, b, 3); 3729 // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3730 } 3731 3732 int16x8_t test_vshrn_high_n_s32(int16x4_t a, int32x4_t b) { 3733 // CHECK: test_vshrn_high_n_s32 3734 return vshrn_high_n_s32(a, b, 9); 3735 // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3736 } 3737 3738 int32x4_t test_vshrn_high_n_s64(int32x2_t a, int64x2_t b) { 3739 // CHECK: test_vshrn_high_n_s64 3740 return vshrn_high_n_s64(a, b, 19); 3741 // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3742 } 3743 3744 uint8x16_t test_vshrn_high_n_u16(uint8x8_t a, uint16x8_t b) { 3745 // CHECK: test_vshrn_high_n_u16 3746 return vshrn_high_n_u16(a, b, 3); 3747 // CHECK: shrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3748 } 3749 3750 uint16x8_t test_vshrn_high_n_u32(uint16x4_t a, uint32x4_t b) { 3751 // CHECK: test_vshrn_high_n_u32 3752 return vshrn_high_n_u32(a, b, 9); 3753 // CHECK: shrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3754 } 3755 3756 uint32x4_t test_vshrn_high_n_u64(uint32x2_t a, uint64x2_t b) { 3757 // CHECK: test_vshrn_high_n_u64 3758 return vshrn_high_n_u64(a, b, 19); 3759 // CHECK: shrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3760 } 3761 3762 int8x8_t test_vqshrun_n_s16(int16x8_t a) { 3763 // CHECK: test_vqshrun_n_s16 3764 return vqshrun_n_s16(a, 3); 3765 // CHECK: sqshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3766 } 3767 3768 int16x4_t test_vqshrun_n_s32(int32x4_t a) { 3769 // CHECK: test_vqshrun_n_s32 3770 return vqshrun_n_s32(a, 9); 3771 // CHECK: sqshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3772 } 3773 3774 int32x2_t test_vqshrun_n_s64(int64x2_t a) { 3775 // CHECK: test_vqshrun_n_s64 3776 return vqshrun_n_s64(a, 19); 3777 // CHECK: sqshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3778 } 3779 3780 int8x16_t test_vqshrun_high_n_s16(int8x8_t a, int16x8_t b) { 3781 // CHECK: test_vqshrun_high_n_s16 3782 return vqshrun_high_n_s16(a, b, 3); 3783 // CHECK: sqshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3784 } 3785 3786 int16x8_t test_vqshrun_high_n_s32(int16x4_t a, int32x4_t b) { 3787 // CHECK: test_vqshrun_high_n_s32 3788 return vqshrun_high_n_s32(a, b, 9); 3789 // CHECK: sqshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3790 } 3791 3792 int32x4_t test_vqshrun_high_n_s64(int32x2_t a, int64x2_t b) { 3793 // CHECK: test_vqshrun_high_n_s64 3794 return vqshrun_high_n_s64(a, b, 19); 3795 // CHECK: sqshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3796 } 3797 3798 int8x8_t test_vrshrn_n_s16(int16x8_t a) { 3799 // CHECK: test_vrshrn_n_s16 3800 return vrshrn_n_s16(a, 3); 3801 // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3802 } 3803 3804 int16x4_t test_vrshrn_n_s32(int32x4_t a) { 3805 // CHECK: test_vrshrn_n_s32 3806 return vrshrn_n_s32(a, 9); 3807 // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3808 } 3809 3810 int32x2_t test_vrshrn_n_s64(int64x2_t a) { 3811 // CHECK: test_vrshrn_n_s64 3812 return vrshrn_n_s64(a, 19); 3813 // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3814 } 3815 3816 uint8x8_t test_vrshrn_n_u16(uint16x8_t a) { 3817 // CHECK: test_vrshrn_n_u16 3818 return vrshrn_n_u16(a, 3); 3819 // CHECK: rshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3820 } 3821 3822 uint16x4_t test_vrshrn_n_u32(uint32x4_t a) { 3823 // CHECK: test_vrshrn_n_u32 3824 return vrshrn_n_u32(a, 9); 3825 // CHECK: rshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3826 } 3827 3828 uint32x2_t test_vrshrn_n_u64(uint64x2_t a) { 3829 // CHECK: test_vrshrn_n_u64 3830 return vrshrn_n_u64(a, 19); 3831 // CHECK: rshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3832 } 3833 3834 int8x16_t test_vrshrn_high_n_s16(int8x8_t a, int16x8_t b) { 3835 // CHECK: test_vrshrn_high_n_s16 3836 return vrshrn_high_n_s16(a, b, 3); 3837 // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3838 } 3839 3840 int16x8_t test_vrshrn_high_n_s32(int16x4_t a, int32x4_t b) { 3841 // CHECK: test_vrshrn_high_n_s32 3842 return vrshrn_high_n_s32(a, b, 9); 3843 // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3844 } 3845 3846 int32x4_t test_vrshrn_high_n_s64(int32x2_t a, int64x2_t b) { 3847 // CHECK: test_vrshrn_high_n_s64 3848 return vrshrn_high_n_s64(a, b, 19); 3849 // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3850 } 3851 3852 uint8x16_t test_vrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) { 3853 // CHECK: test_vrshrn_high_n_u16 3854 return vrshrn_high_n_u16(a, b, 3); 3855 // CHECK: rshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3856 } 3857 3858 uint16x8_t test_vrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) { 3859 // CHECK: test_vrshrn_high_n_u32 3860 return vrshrn_high_n_u32(a, b, 9); 3861 // CHECK: rshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3862 } 3863 3864 uint32x4_t test_vrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) { 3865 // CHECK: test_vrshrn_high_n_u64 3866 return vrshrn_high_n_u64(a, b, 19); 3867 // CHECK: rshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3868 } 3869 3870 int8x8_t test_vqrshrun_n_s16(int16x8_t a) { 3871 // CHECK: test_vqrshrun_n_s16 3872 return vqrshrun_n_s16(a, 3); 3873 // CHECK: sqrshrun {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3874 } 3875 3876 int16x4_t test_vqrshrun_n_s32(int32x4_t a) { 3877 // CHECK: test_vqrshrun_n_s32 3878 return vqrshrun_n_s32(a, 9); 3879 // CHECK: sqrshrun {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3880 } 3881 3882 int32x2_t test_vqrshrun_n_s64(int64x2_t a) { 3883 // CHECK: test_vqrshrun_n_s64 3884 return vqrshrun_n_s64(a, 19); 3885 // CHECK: sqrshrun {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3886 } 3887 3888 int8x16_t test_vqrshrun_high_n_s16(int8x8_t a, int16x8_t b) { 3889 // CHECK: test_vqrshrun_high_n_s16 3890 return vqrshrun_high_n_s16(a, b, 3); 3891 // CHECK: sqrshrun2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3892 } 3893 3894 int16x8_t test_vqrshrun_high_n_s32(int16x4_t a, int32x4_t b) { 3895 // CHECK: test_vqrshrun_high_n_s32 3896 return vqrshrun_high_n_s32(a, b, 9); 3897 // CHECK: sqrshrun2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3898 } 3899 3900 int32x4_t test_vqrshrun_high_n_s64(int32x2_t a, int64x2_t b) { 3901 // CHECK: test_vqrshrun_high_n_s64 3902 return vqrshrun_high_n_s64(a, b, 19); 3903 // CHECK: sqrshrun2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3904 } 3905 3906 int8x8_t test_vqshrn_n_s16(int16x8_t a) { 3907 // CHECK: test_vqshrn_n_s16 3908 return vqshrn_n_s16(a, 3); 3909 // CHECK: sqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3910 } 3911 3912 int16x4_t test_vqshrn_n_s32(int32x4_t a) { 3913 // CHECK: test_vqshrn_n_s32 3914 return vqshrn_n_s32(a, 9); 3915 // CHECK: sqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3916 } 3917 3918 int32x2_t test_vqshrn_n_s64(int64x2_t a) { 3919 // CHECK: test_vqshrn_n_s64 3920 return vqshrn_n_s64(a, 19); 3921 // CHECK: sqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3922 } 3923 3924 uint8x8_t test_vqshrn_n_u16(uint16x8_t a) { 3925 // CHECK: test_vqshrn_n_u16 3926 return vqshrn_n_u16(a, 3); 3927 // CHECK: uqshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3928 } 3929 3930 uint16x4_t test_vqshrn_n_u32(uint32x4_t a) { 3931 // CHECK: test_vqshrn_n_u32 3932 return vqshrn_n_u32(a, 9); 3933 // CHECK: uqshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3934 } 3935 3936 uint32x2_t test_vqshrn_n_u64(uint64x2_t a) { 3937 // CHECK: test_vqshrn_n_u64 3938 return vqshrn_n_u64(a, 19); 3939 // CHECK: uqshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3940 } 3941 3942 int8x16_t test_vqshrn_high_n_s16(int8x8_t a, int16x8_t b) { 3943 // CHECK: test_vqshrn_high_n_s16 3944 return vqshrn_high_n_s16(a, b, 3); 3945 // CHECK: sqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3946 } 3947 3948 int16x8_t test_vqshrn_high_n_s32(int16x4_t a, int32x4_t b) { 3949 // CHECK: test_vqshrn_high_n_s32 3950 return vqshrn_high_n_s32(a, b, 9); 3951 // CHECK: sqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3952 } 3953 3954 int32x4_t test_vqshrn_high_n_s64(int32x2_t a, int64x2_t b) { 3955 // CHECK: test_vqshrn_high_n_s64 3956 return vqshrn_high_n_s64(a, b, 19); 3957 // CHECK: sqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3958 } 3959 3960 uint8x16_t test_vqshrn_high_n_u16(uint8x8_t a, uint16x8_t b) { 3961 // CHECK: test_vqshrn_high_n_u16 3962 return vqshrn_high_n_u16(a, b, 3); 3963 // CHECK: uqshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 3964 } 3965 3966 uint16x8_t test_vqshrn_high_n_u32(uint16x4_t a, uint32x4_t b) { 3967 // CHECK: test_vqshrn_high_n_u32 3968 return vqshrn_high_n_u32(a, b, 9); 3969 // CHECK: uqshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 3970 } 3971 3972 uint32x4_t test_vqshrn_high_n_u64(uint32x2_t a, uint64x2_t b) { 3973 // CHECK: test_vqshrn_high_n_u64 3974 return vqshrn_high_n_u64(a, b, 19); 3975 // CHECK: uqshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 3976 } 3977 3978 int8x8_t test_vqrshrn_n_s16(int16x8_t a) { 3979 // CHECK: test_vqrshrn_n_s16 3980 return vqrshrn_n_s16(a, 3); 3981 // CHECK: sqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 3982 } 3983 3984 int16x4_t test_vqrshrn_n_s32(int32x4_t a) { 3985 // CHECK: test_vqrshrn_n_s32 3986 return vqrshrn_n_s32(a, 9); 3987 // CHECK: sqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 3988 } 3989 3990 int32x2_t test_vqrshrn_n_s64(int64x2_t a) { 3991 // CHECK: test_vqrshrn_n_s64 3992 return vqrshrn_n_s64(a, 19); 3993 // CHECK: sqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 3994 } 3995 3996 uint8x8_t test_vqrshrn_n_u16(uint16x8_t a) { 3997 // CHECK: test_vqrshrn_n_u16 3998 return vqrshrn_n_u16(a, 3); 3999 // CHECK: uqrshrn {{v[0-9]+}}.8b, {{v[0-9]+}}.8h, #3 4000 } 4001 4002 uint16x4_t test_vqrshrn_n_u32(uint32x4_t a) { 4003 // CHECK: test_vqrshrn_n_u32 4004 return vqrshrn_n_u32(a, 9); 4005 // CHECK: uqrshrn {{v[0-9]+}}.4h, {{v[0-9]+}}.4s, #9 4006 } 4007 4008 uint32x2_t test_vqrshrn_n_u64(uint64x2_t a) { 4009 // CHECK: test_vqrshrn_n_u64 4010 return vqrshrn_n_u64(a, 19); 4011 // CHECK: uqrshrn {{v[0-9]+}}.2s, {{v[0-9]+}}.2d, #19 4012 } 4013 4014 int8x16_t test_vqrshrn_high_n_s16(int8x8_t a, int16x8_t b) { 4015 // CHECK: test_vqrshrn_high_n_s16 4016 return vqrshrn_high_n_s16(a, b, 3); 4017 // CHECK: sqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 4018 } 4019 4020 int16x8_t test_vqrshrn_high_n_s32(int16x4_t a, int32x4_t b) { 4021 // CHECK: test_vqrshrn_high_n_s32 4022 return vqrshrn_high_n_s32(a, b, 9); 4023 // CHECK: sqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 4024 } 4025 4026 int32x4_t test_vqrshrn_high_n_s64(int32x2_t a, int64x2_t b) { 4027 // CHECK: test_vqrshrn_high_n_s64 4028 return vqrshrn_high_n_s64(a, b, 19); 4029 // CHECK: sqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 4030 } 4031 4032 uint8x16_t test_vqrshrn_high_n_u16(uint8x8_t a, uint16x8_t b) { 4033 // CHECK: test_vqrshrn_high_n_u16 4034 return vqrshrn_high_n_u16(a, b, 3); 4035 // CHECK: uqrshrn2 {{v[0-9]+}}.16b, {{v[0-9]+}}.8h, #3 4036 } 4037 4038 uint16x8_t test_vqrshrn_high_n_u32(uint16x4_t a, uint32x4_t b) { 4039 // CHECK: test_vqrshrn_high_n_u32 4040 return vqrshrn_high_n_u32(a, b, 9); 4041 // CHECK: uqrshrn2 {{v[0-9]+}}.8h, {{v[0-9]+}}.4s, #9 4042 } 4043 4044 uint32x4_t test_vqrshrn_high_n_u64(uint32x2_t a, uint64x2_t b) { 4045 // CHECK: test_vqrshrn_high_n_u64 4046 return vqrshrn_high_n_u64(a, b, 19); 4047 // CHECK: uqrshrn2 {{v[0-9]+}}.4s, {{v[0-9]+}}.2d, #19 4048 } 4049 4050 int16x8_t test_vshll_n_s8(int8x8_t a) { 4051 // CHECK: test_vshll_n_s8 4052 return vshll_n_s8(a, 3); 4053 // CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3 4054 } 4055 4056 int32x4_t test_vshll_n_s16(int16x4_t a) { 4057 // CHECK: test_vshll_n_s16 4058 return vshll_n_s16(a, 9); 4059 // CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9 4060 } 4061 4062 int64x2_t test_vshll_n_s32(int32x2_t a) { 4063 // CHECK: test_vshll_n_s32 4064 return vshll_n_s32(a, 19); 4065 // CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19 4066 } 4067 4068 uint16x8_t test_vshll_n_u8(uint8x8_t a) { 4069 // CHECK: test_vshll_n_u8 4070 return vshll_n_u8(a, 3); 4071 // CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #3 4072 } 4073 4074 uint32x4_t test_vshll_n_u16(uint16x4_t a) { 4075 // CHECK: test_vshll_n_u16 4076 return vshll_n_u16(a, 9); 4077 // CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #9 4078 } 4079 4080 uint64x2_t test_vshll_n_u32(uint32x2_t a) { 4081 // CHECK: test_vshll_n_u32 4082 return vshll_n_u32(a, 19); 4083 // CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #19 4084 } 4085 4086 int16x8_t test_vshll_high_n_s8(int8x16_t a) { 4087 // CHECK: test_vshll_high_n_s8 4088 return vshll_high_n_s8(a, 3); 4089 // CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3 4090 } 4091 4092 int32x4_t test_vshll_high_n_s16(int16x8_t a) { 4093 // CHECK: test_vshll_high_n_s16 4094 return vshll_high_n_s16(a, 9); 4095 // CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9 4096 } 4097 4098 int64x2_t test_vshll_high_n_s32(int32x4_t a) { 4099 // CHECK: test_vshll_high_n_s32 4100 return vshll_high_n_s32(a, 19); 4101 // CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19 4102 } 4103 4104 uint16x8_t test_vshll_high_n_u8(uint8x16_t a) { 4105 // CHECK: test_vshll_high_n_u8 4106 return vshll_high_n_u8(a, 3); 4107 // CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #3 4108 } 4109 4110 uint32x4_t test_vshll_high_n_u16(uint16x8_t a) { 4111 // CHECK: test_vshll_high_n_u16 4112 return vshll_high_n_u16(a, 9); 4113 // CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #9 4114 } 4115 4116 uint64x2_t test_vshll_high_n_u32(uint32x4_t a) { 4117 // CHECK: test_vshll_high_n_u32 4118 return vshll_high_n_u32(a, 19); 4119 // CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #19 4120 } 4121 4122 int16x8_t test_vmovl_s8(int8x8_t a) { 4123 // CHECK: test_vmovl_s8 4124 return vmovl_s8(a); 4125 // CHECK: sshll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0 4126 } 4127 4128 int32x4_t test_vmovl_s16(int16x4_t a) { 4129 // CHECK: test_vmovl_s16 4130 return vmovl_s16(a); 4131 // CHECK: sshll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0 4132 } 4133 4134 int64x2_t test_vmovl_s32(int32x2_t a) { 4135 // CHECK: test_vmovl_s32 4136 return vmovl_s32(a); 4137 // CHECK: sshll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0 4138 } 4139 4140 uint16x8_t test_vmovl_u8(uint8x8_t a) { 4141 // CHECK: test_vmovl_u8 4142 return vmovl_u8(a); 4143 // CHECK: ushll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #0 4144 } 4145 4146 uint32x4_t test_vmovl_u16(uint16x4_t a) { 4147 // CHECK: test_vmovl_u16 4148 return vmovl_u16(a); 4149 // CHECK: ushll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #0 4150 } 4151 4152 uint64x2_t test_vmovl_u32(uint32x2_t a) { 4153 // CHECK: test_vmovl_u32 4154 return vmovl_u32(a); 4155 // CHECK: ushll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #0 4156 } 4157 4158 int16x8_t test_vmovl_high_s8(int8x16_t a) { 4159 // CHECK: test_vmovl_high_s8 4160 return vmovl_high_s8(a); 4161 // CHECK: sshll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0 4162 } 4163 4164 int32x4_t test_vmovl_high_s16(int16x8_t a) { 4165 // CHECK: test_vmovl_high_s16 4166 return vmovl_high_s16(a); 4167 // CHECK: sshll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0 4168 } 4169 4170 int64x2_t test_vmovl_high_s32(int32x4_t a) { 4171 // CHECK: test_vmovl_high_s32 4172 return vmovl_high_s32(a); 4173 // CHECK: sshll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0 4174 } 4175 4176 uint16x8_t test_vmovl_high_u8(uint8x16_t a) { 4177 // CHECK: test_vmovl_high_u8 4178 return vmovl_high_u8(a); 4179 // CHECK: ushll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #0 4180 } 4181 4182 uint32x4_t test_vmovl_high_u16(uint16x8_t a) { 4183 // CHECK: test_vmovl_high_u16 4184 return vmovl_high_u16(a); 4185 // CHECK: ushll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #0 4186 } 4187 4188 uint64x2_t test_vmovl_high_u32(uint32x4_t a) { 4189 // CHECK: test_vmovl_high_u32 4190 return vmovl_high_u32(a); 4191 // CHECK: ushll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #0 4192 } 4193 4194 float32x2_t test_vcvt_n_f32_s32(int32x2_t a) { 4195 // CHECK: test_vcvt_n_f32_s32 4196 return vcvt_n_f32_s32(a, 31); 4197 // CHECK: scvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31 4198 } 4199 4200 float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) { 4201 // CHECK: test_vcvtq_n_f32_s32 4202 return vcvtq_n_f32_s32(a, 31); 4203 // CHECK: scvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31 4204 } 4205 4206 float64x2_t test_vcvtq_n_f64_s64(int64x2_t a) { 4207 // CHECK: test_vcvtq_n_f64_s64 4208 return vcvtq_n_f64_s64(a, 50); 4209 // CHECK: scvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50 4210 } 4211 4212 float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) { 4213 // CHECK: test_vcvt_n_f32_u32 4214 return vcvt_n_f32_u32(a, 31); 4215 // CHECK: ucvtf {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31 4216 } 4217 4218 float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) { 4219 // CHECK: test_vcvtq_n_f32_u32 4220 return vcvtq_n_f32_u32(a, 31); 4221 // CHECK: ucvtf {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31 4222 } 4223 4224 float64x2_t test_vcvtq_n_f64_u64(uint64x2_t a) { 4225 // CHECK: test_vcvtq_n_f64_u64 4226 return vcvtq_n_f64_u64(a, 50); 4227 // CHECK: ucvtf {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50 4228 } 4229 4230 int32x2_t test_vcvt_n_s32_f32(float32x2_t a) { 4231 // CHECK: test_vcvt_n_s32_f32 4232 return vcvt_n_s32_f32(a, 31); 4233 // CHECK: fcvtzs {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31 4234 } 4235 4236 int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) { 4237 // CHECK: test_vcvtq_n_s32_f32 4238 return vcvtq_n_s32_f32(a, 31); 4239 // CHECK: fcvtzs {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31 4240 } 4241 4242 int64x2_t test_vcvtq_n_s64_f64(float64x2_t a) { 4243 // CHECK: test_vcvtq_n_s64_f64 4244 return vcvtq_n_s64_f64(a, 50); 4245 // CHECK: fcvtzs {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50 4246 } 4247 4248 uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) { 4249 // CHECK: test_vcvt_n_u32_f32 4250 return vcvt_n_u32_f32(a, 31); 4251 // CHECK: fcvtzu {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, #31 4252 } 4253 4254 uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) { 4255 // CHECK: test_vcvt_n_u32_f32 4256 return vcvtq_n_u32_f32(a, 31); 4257 // CHECK: fcvtzu {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, #31 4258 } 4259 4260 uint64x2_t test_vcvtq_n_u64_f64(float64x2_t a) { 4261 // CHECK: test_vcvtq_n_u64_f64 4262 return vcvtq_n_u64_f64(a, 50); 4263 // CHECK: fcvtzu {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, #50 4264 } 4265 4266 int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) { 4267 // CHECK: test_vaddl_s8 4268 return vaddl_s8(a, b); 4269 // CHECK: saddl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4270 } 4271 4272 int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) { 4273 // CHECK: test_vaddl_s16 4274 return vaddl_s16(a, b); 4275 // CHECK: saddl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4276 } 4277 4278 int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) { 4279 // CHECK: test_vaddl_s32 4280 return vaddl_s32(a, b); 4281 // CHECK: saddl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4282 } 4283 4284 uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) { 4285 // CHECK: test_vaddl_u8 4286 return vaddl_u8(a, b); 4287 // CHECK: uaddl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4288 } 4289 4290 uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) { 4291 // CHECK: test_vaddl_u16 4292 return vaddl_u16(a, b); 4293 // CHECK: uaddl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4294 } 4295 4296 uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) { 4297 // CHECK: test_vaddl_u32 4298 return vaddl_u32(a, b); 4299 // CHECK: uaddl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4300 } 4301 4302 int16x8_t test_vaddl_high_s8(int8x16_t a, int8x16_t b) { 4303 // CHECK: test_vaddl_high_s8 4304 return vaddl_high_s8(a, b); 4305 // CHECK: saddl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4306 } 4307 4308 int32x4_t test_vaddl_high_s16(int16x8_t a, int16x8_t b) { 4309 // CHECK: test_vaddl_high_s16 4310 return vaddl_high_s16(a, b); 4311 // CHECK: saddl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4312 } 4313 4314 int64x2_t test_vaddl_high_s32(int32x4_t a, int32x4_t b) { 4315 // CHECK: test_vaddl_high_s32 4316 return vaddl_high_s32(a, b); 4317 // CHECK: saddl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4318 } 4319 4320 uint16x8_t test_vaddl_high_u8(uint8x16_t a, uint8x16_t b) { 4321 // CHECK: test_vaddl_high_u8 4322 return vaddl_high_u8(a, b); 4323 // CHECK: uaddl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4324 } 4325 4326 uint32x4_t test_vaddl_high_u16(uint16x8_t a, uint16x8_t b) { 4327 // CHECK: test_vaddl_high_u16 4328 return vaddl_high_u16(a, b); 4329 // CHECK: uaddl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4330 } 4331 4332 uint64x2_t test_vaddl_high_u32(uint32x4_t a, uint32x4_t b) { 4333 // CHECK: test_vaddl_high_u32 4334 return vaddl_high_u32(a, b); 4335 // CHECK: uaddl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4336 } 4337 4338 int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) { 4339 // CHECK: test_vaddw_s8 4340 return vaddw_s8(a, b); 4341 // CHECK: saddw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b 4342 } 4343 4344 int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) { 4345 // CHECK: test_vaddw_s16 4346 return vaddw_s16(a, b); 4347 // CHECK: saddw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h 4348 } 4349 4350 int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) { 4351 // CHECK: test_vaddw_s32 4352 return vaddw_s32(a, b); 4353 // CHECK: saddw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s 4354 } 4355 4356 uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) { 4357 // CHECK: test_vaddw_u8 4358 return vaddw_u8(a, b); 4359 // CHECK: uaddw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b 4360 } 4361 4362 uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) { 4363 // CHECK: test_vaddw_u16 4364 return vaddw_u16(a, b); 4365 // CHECK: uaddw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h 4366 } 4367 4368 uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) { 4369 // CHECK: test_vaddw_u32 4370 return vaddw_u32(a, b); 4371 // CHECK: uaddw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s 4372 } 4373 4374 int16x8_t test_vaddw_high_s8(int16x8_t a, int8x16_t b) { 4375 // CHECK: test_vaddw_high_s8 4376 return vaddw_high_s8(a, b); 4377 // CHECK: saddw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b 4378 } 4379 4380 int32x4_t test_vaddw_high_s16(int32x4_t a, int16x8_t b) { 4381 // CHECK: test_vaddw_high_s16 4382 return vaddw_high_s16(a, b); 4383 // CHECK: saddw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h 4384 } 4385 4386 int64x2_t test_vaddw_high_s32(int64x2_t a, int32x4_t b) { 4387 // CHECK: test_vaddw_high_s32 4388 return vaddw_high_s32(a, b); 4389 // CHECK: saddw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s 4390 } 4391 4392 uint16x8_t test_vaddw_high_u8(uint16x8_t a, uint8x16_t b) { 4393 // CHECK: test_vaddw_high_u8 4394 return vaddw_high_u8(a, b); 4395 // CHECK: uaddw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b 4396 } 4397 4398 uint32x4_t test_vaddw_high_u16(uint32x4_t a, uint16x8_t b) { 4399 // CHECK: test_vaddw_high_u16 4400 return vaddw_high_u16(a, b); 4401 // CHECK: uaddw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h 4402 } 4403 4404 uint64x2_t test_vaddw_high_u32(uint64x2_t a, uint32x4_t b) { 4405 // CHECK: test_vaddw_high_u32 4406 return vaddw_high_u32(a, b); 4407 // CHECK: uaddw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s 4408 } 4409 4410 int16x8_t test_vsubl_s8(int8x8_t a, int8x8_t b) { 4411 // CHECK: test_vsubl_s8 4412 return vsubl_s8(a, b); 4413 // CHECK: ssubl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4414 } 4415 4416 int32x4_t test_vsubl_s16(int16x4_t a, int16x4_t b) { 4417 // CHECK: test_vsubl_s16 4418 return vsubl_s16(a, b); 4419 // CHECK: ssubl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4420 } 4421 4422 int64x2_t test_vsubl_s32(int32x2_t a, int32x2_t b) { 4423 // CHECK: test_vsubl_s32 4424 return vsubl_s32(a, b); 4425 // CHECK: ssubl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4426 } 4427 4428 uint16x8_t test_vsubl_u8(uint8x8_t a, uint8x8_t b) { 4429 // CHECK: test_vsubl_u8 4430 return vsubl_u8(a, b); 4431 // CHECK: usubl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4432 } 4433 4434 uint32x4_t test_vsubl_u16(uint16x4_t a, uint16x4_t b) { 4435 // CHECK: test_vsubl_u16 4436 return vsubl_u16(a, b); 4437 // CHECK: usubl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4438 } 4439 4440 uint64x2_t test_vsubl_u32(uint32x2_t a, uint32x2_t b) { 4441 // CHECK: test_vsubl_u32 4442 return vsubl_u32(a, b); 4443 // CHECK: usubl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4444 } 4445 4446 int16x8_t test_vsubl_high_s8(int8x16_t a, int8x16_t b) { 4447 // CHECK: test_vsubl_high_s8 4448 return vsubl_high_s8(a, b); 4449 // CHECK: ssubl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4450 } 4451 4452 int32x4_t test_vsubl_high_s16(int16x8_t a, int16x8_t b) { 4453 // CHECK: test_vsubl_high_s16 4454 return vsubl_high_s16(a, b); 4455 // CHECK: ssubl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4456 } 4457 4458 int64x2_t test_vsubl_high_s32(int32x4_t a, int32x4_t b) { 4459 // CHECK: test_vsubl_high_s32 4460 return vsubl_high_s32(a, b); 4461 // CHECK: ssubl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4462 } 4463 4464 uint16x8_t test_vsubl_high_u8(uint8x16_t a, uint8x16_t b) { 4465 // CHECK: test_vsubl_high_u8 4466 return vsubl_high_u8(a, b); 4467 // CHECK: usubl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4468 } 4469 4470 uint32x4_t test_vsubl_high_u16(uint16x8_t a, uint16x8_t b) { 4471 // CHECK: test_vsubl_high_u16 4472 return vsubl_high_u16(a, b); 4473 // CHECK: usubl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4474 } 4475 4476 uint64x2_t test_vsubl_high_u32(uint32x4_t a, uint32x4_t b) { 4477 // CHECK: test_vsubl_high_u32 4478 return vsubl_high_u32(a, b); 4479 // CHECK: usubl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4480 } 4481 4482 int16x8_t test_vsubw_s8(int16x8_t a, int8x8_t b) { 4483 // CHECK: test_vsubw_s8 4484 return vsubw_s8(a, b); 4485 // CHECK: ssubw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b 4486 } 4487 4488 int32x4_t test_vsubw_s16(int32x4_t a, int16x4_t b) { 4489 // CHECK: test_vsubw_s16 4490 return vsubw_s16(a, b); 4491 // CHECK: ssubw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h 4492 } 4493 4494 int64x2_t test_vsubw_s32(int64x2_t a, int32x2_t b) { 4495 // CHECK: test_vsubw_s32 4496 return vsubw_s32(a, b); 4497 // CHECK: ssubw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s 4498 } 4499 4500 uint16x8_t test_vsubw_u8(uint16x8_t a, uint8x8_t b) { 4501 // CHECK: test_vsubw_u8 4502 return vsubw_u8(a, b); 4503 // CHECK: usubw {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.8b 4504 } 4505 4506 uint32x4_t test_vsubw_u16(uint32x4_t a, uint16x4_t b) { 4507 // CHECK: test_vsubw_u16 4508 return vsubw_u16(a, b); 4509 // CHECK: usubw {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.4h 4510 } 4511 4512 uint64x2_t test_vsubw_u32(uint64x2_t a, uint32x2_t b) { 4513 // CHECK: test_vsubw_u32 4514 return vsubw_u32(a, b); 4515 // CHECK: usubw {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.2s 4516 } 4517 4518 int16x8_t test_vsubw_high_s8(int16x8_t a, int8x16_t b) { 4519 // CHECK: test_vsubw_high_s8 4520 return vsubw_high_s8(a, b); 4521 // CHECK: ssubw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b 4522 } 4523 4524 int32x4_t test_vsubw_high_s16(int32x4_t a, int16x8_t b) { 4525 // CHECK: test_vsubw_high_s16 4526 return vsubw_high_s16(a, b); 4527 // CHECK: ssubw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h 4528 } 4529 4530 int64x2_t test_vsubw_high_s32(int64x2_t a, int32x4_t b) { 4531 // CHECK: test_vsubw_high_s32 4532 return vsubw_high_s32(a, b); 4533 // CHECK: ssubw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s 4534 } 4535 4536 uint16x8_t test_vsubw_high_u8(uint16x8_t a, uint8x16_t b) { 4537 // CHECK: test_vsubw_high_u8 4538 return vsubw_high_u8(a, b); 4539 // CHECK: usubw2 {{v[0-31]+}}.8h, {{v[0-31]+}}.8h, {{v[0-31]+}}.16b 4540 } 4541 4542 uint32x4_t test_vsubw_high_u16(uint32x4_t a, uint16x8_t b) { 4543 // CHECK: test_vsubw_high_u16 4544 return vsubw_high_u16(a, b); 4545 // CHECK: usubw2 {{v[0-31]+}}.4s, {{v[0-31]+}}.4s, {{v[0-31]+}}.8h 4546 } 4547 4548 uint64x2_t test_vsubw_high_u32(uint64x2_t a, uint32x4_t b) { 4549 // CHECK: test_vsubw_high_u32 4550 return vsubw_high_u32(a, b); 4551 // CHECK: usubw2 {{v[0-31]+}}.2d, {{v[0-31]+}}.2d, {{v[0-31]+}}.4s 4552 } 4553 4554 int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) { 4555 // CHECK: test_vaddhn_s16 4556 return vaddhn_s16(a, b); 4557 // CHECK: addhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4558 } 4559 4560 int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) { 4561 // CHECK: test_vaddhn_s32 4562 return vaddhn_s32(a, b); 4563 // CHECK: addhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4564 } 4565 4566 int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) { 4567 // CHECK: test_vaddhn_s64 4568 return vaddhn_s64(a, b); 4569 // CHECK: addhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4570 } 4571 4572 uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) { 4573 // CHECK: test_vaddhn_u16 4574 return vaddhn_u16(a, b); 4575 // CHECK: addhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4576 } 4577 4578 uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) { 4579 // CHECK: test_vaddhn_u32 4580 return vaddhn_u32(a, b); 4581 // CHECK: addhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4582 } 4583 4584 uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) { 4585 // CHECK: test_vaddhn_u64 4586 return vaddhn_u64(a, b); 4587 // CHECK: addhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4588 } 4589 4590 int8x16_t test_vaddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) { 4591 // CHECK: test_vaddhn_high_s16 4592 return vaddhn_high_s16(r, a, b); 4593 // CHECK: addhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4594 } 4595 4596 int16x8_t test_vaddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) { 4597 // CHECK: test_vaddhn_high_s32 4598 return vaddhn_high_s32(r, a, b); 4599 // CHECK: addhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4600 } 4601 4602 int32x4_t test_vaddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) { 4603 // CHECK: test_vaddhn_high_s64 4604 return vaddhn_high_s64(r, a, b); 4605 // CHECK: addhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4606 } 4607 4608 uint8x16_t test_vaddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) { 4609 // CHECK: test_vaddhn_high_u16 4610 return vaddhn_high_u16(r, a, b); 4611 // CHECK: addhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4612 } 4613 4614 uint16x8_t test_vaddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) { 4615 // CHECK: test_vaddhn_high_u32 4616 return vaddhn_high_u32(r, a, b); 4617 // CHECK: addhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4618 } 4619 4620 uint32x4_t test_vaddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) { 4621 // CHECK: test_vaddhn_high_u64 4622 return vaddhn_high_u64(r, a, b); 4623 // CHECK: addhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4624 } 4625 4626 int8x8_t test_vraddhn_s16(int16x8_t a, int16x8_t b) { 4627 // CHECK: test_vraddhn_s16 4628 return vraddhn_s16(a, b); 4629 // CHECK: raddhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4630 } 4631 4632 int16x4_t test_vraddhn_s32(int32x4_t a, int32x4_t b) { 4633 // CHECK: test_vraddhn_s32 4634 return vraddhn_s32(a, b); 4635 // CHECK: raddhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4636 } 4637 4638 int32x2_t test_vraddhn_s64(int64x2_t a, int64x2_t b) { 4639 // CHECK: test_vraddhn_s64 4640 return vraddhn_s64(a, b); 4641 // CHECK: raddhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4642 } 4643 4644 uint8x8_t test_vraddhn_u16(uint16x8_t a, uint16x8_t b) { 4645 // CHECK: test_vraddhn_u16 4646 return vraddhn_u16(a, b); 4647 // CHECK: raddhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4648 } 4649 4650 uint16x4_t test_vraddhn_u32(uint32x4_t a, uint32x4_t b) { 4651 // CHECK: test_vraddhn_u32 4652 return vraddhn_u32(a, b); 4653 // CHECK: raddhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4654 } 4655 4656 uint32x2_t test_vraddhn_u64(uint64x2_t a, uint64x2_t b) { 4657 // CHECK: test_vraddhn_u64 4658 return vraddhn_u64(a, b); 4659 // CHECK: raddhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4660 } 4661 4662 int8x16_t test_vraddhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) { 4663 // CHECK: test_vraddhn_high_s16 4664 return vraddhn_high_s16(r, a, b); 4665 // CHECK: raddhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4666 } 4667 4668 int16x8_t test_vraddhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) { 4669 // CHECK: test_vraddhn_high_s32 4670 return vraddhn_high_s32(r, a, b); 4671 // CHECK: raddhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4672 } 4673 4674 int32x4_t test_vraddhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) { 4675 // CHECK: test_vraddhn_high_s64 4676 return vraddhn_high_s64(r, a, b); 4677 // CHECK: raddhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4678 } 4679 4680 uint8x16_t test_vraddhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) { 4681 // CHECK: test_vraddhn_high_u16 4682 return vraddhn_high_u16(r, a, b); 4683 // CHECK: raddhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4684 } 4685 4686 uint16x8_t test_vraddhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) { 4687 // CHECK: test_vraddhn_high_u32 4688 return vraddhn_high_u32(r, a, b); 4689 // CHECK: raddhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4690 } 4691 4692 uint32x4_t test_vraddhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) { 4693 // CHECK: test_vraddhn_high_u64 4694 return vraddhn_high_u64(r, a, b); 4695 // CHECK: raddhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4696 } 4697 4698 int8x8_t test_vsubhn_s16(int16x8_t a, int16x8_t b) { 4699 // CHECK: test_vsubhn_s16 4700 return vsubhn_s16(a, b); 4701 // CHECK: subhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4702 } 4703 4704 int16x4_t test_vsubhn_s32(int32x4_t a, int32x4_t b) { 4705 // CHECK: test_vsubhn_s32 4706 return vsubhn_s32(a, b); 4707 // CHECK: subhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4708 } 4709 4710 int32x2_t test_vsubhn_s64(int64x2_t a, int64x2_t b) { 4711 // CHECK: test_vsubhn_s64 4712 return vsubhn_s64(a, b); 4713 // CHECK: subhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4714 } 4715 4716 uint8x8_t test_vsubhn_u16(uint16x8_t a, uint16x8_t b) { 4717 // CHECK: test_vsubhn_u16 4718 return vsubhn_u16(a, b); 4719 // CHECK: subhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4720 } 4721 4722 uint16x4_t test_vsubhn_u32(uint32x4_t a, uint32x4_t b) { 4723 // CHECK: test_vsubhn_u32 4724 return vsubhn_u32(a, b); 4725 // CHECK: subhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4726 } 4727 4728 uint32x2_t test_vsubhn_u64(uint64x2_t a, uint64x2_t b) { 4729 // CHECK: test_vsubhn_u64 4730 return vsubhn_u64(a, b); 4731 // CHECK: subhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4732 } 4733 4734 int8x16_t test_vsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) { 4735 // CHECK: test_vsubhn_high_s16 4736 return vsubhn_high_s16(r, a, b); 4737 // CHECK: subhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4738 } 4739 4740 int16x8_t test_vsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) { 4741 // CHECK: test_vsubhn_high_s32 4742 return vsubhn_high_s32(r, a, b); 4743 // CHECK: subhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4744 } 4745 4746 int32x4_t test_vsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) { 4747 // CHECK: test_vsubhn_high_s64 4748 return vsubhn_high_s64(r, a, b); 4749 // CHECK: subhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4750 } 4751 4752 uint8x16_t test_vsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) { 4753 // CHECK: test_vsubhn_high_u16 4754 return vsubhn_high_u16(r, a, b); 4755 // CHECK: subhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4756 } 4757 4758 uint16x8_t test_vsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) { 4759 // CHECK: test_vsubhn_high_u32 4760 return vsubhn_high_u32(r, a, b); 4761 // CHECK: subhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4762 } 4763 4764 uint32x4_t test_vsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) { 4765 // CHECK: test_vsubhn_high_u64 4766 return vsubhn_high_u64(r, a, b); 4767 // CHECK: subhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4768 } 4769 4770 int8x8_t test_vrsubhn_s16(int16x8_t a, int16x8_t b) { 4771 // CHECK: test_vrsubhn_s16 4772 return vrsubhn_s16(a, b); 4773 // CHECK: rsubhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4774 } 4775 4776 int16x4_t test_vrsubhn_s32(int32x4_t a, int32x4_t b) { 4777 // CHECK: test_vrsubhn_s32 4778 return vrsubhn_s32(a, b); 4779 // CHECK: rsubhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4780 } 4781 4782 int32x2_t test_vrsubhn_s64(int64x2_t a, int64x2_t b) { 4783 // CHECK: test_vrsubhn_s64 4784 return vrsubhn_s64(a, b); 4785 // CHECK: rsubhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4786 } 4787 4788 uint8x8_t test_vrsubhn_u16(uint16x8_t a, uint16x8_t b) { 4789 // CHECK: test_vrsubhn_u16 4790 return vrsubhn_u16(a, b); 4791 // CHECK: rsubhn {{v[0-31]+}}.8b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4792 } 4793 4794 uint16x4_t test_vrsubhn_u32(uint32x4_t a, uint32x4_t b) { 4795 // CHECK: test_vrsubhn_u32 4796 return vrsubhn_u32(a, b); 4797 // CHECK: rsubhn {{v[0-31]+}}.4h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4798 } 4799 4800 uint32x2_t test_vrsubhn_u64(uint64x2_t a, uint64x2_t b) { 4801 // CHECK: test_vrsubhn_u64 4802 return vrsubhn_u64(a, b); 4803 // CHECK: rsubhn {{v[0-31]+}}.2s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4804 } 4805 4806 int8x16_t test_vrsubhn_high_s16(int8x8_t r, int16x8_t a, int16x8_t b) { 4807 // CHECK: test_vrsubhn_high_s16 4808 return vrsubhn_high_s16(r, a, b); 4809 // CHECK: rsubhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4810 } 4811 4812 int16x8_t test_vrsubhn_high_s32(int16x4_t r, int32x4_t a, int32x4_t b) { 4813 // CHECK: test_vrsubhn_high_s32 4814 return vrsubhn_high_s32(r, a, b); 4815 // CHECK: rsubhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4816 } 4817 4818 int32x4_t test_vrsubhn_high_s64(int32x2_t r, int64x2_t a, int64x2_t b) { 4819 // CHECK: test_vrsubhn_high_s64 4820 return vrsubhn_high_s64(r, a, b); 4821 // CHECK: rsubhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4822 } 4823 4824 uint8x16_t test_vrsubhn_high_u16(uint8x8_t r, uint16x8_t a, uint16x8_t b) { 4825 // CHECK: test_vrsubhn_high_u16 4826 return vrsubhn_high_u16(r, a, b); 4827 // CHECK: rsubhn2 {{v[0-31]+}}.16b, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4828 } 4829 4830 uint16x8_t test_vrsubhn_high_u32(uint16x4_t r, uint32x4_t a, uint32x4_t b) { 4831 // CHECK: test_vrsubhn_high_u32 4832 return vrsubhn_high_u32(r, a, b); 4833 // CHECK: rsubhn2 {{v[0-31]+}}.8h, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4834 } 4835 4836 uint32x4_t test_vrsubhn_high_u64(uint32x2_t r, uint64x2_t a, uint64x2_t b) { 4837 // CHECK: test_vrsubhn_high_u64 4838 return vrsubhn_high_u64(r, a, b); 4839 // CHECK: rsubhn2 {{v[0-31]+}}.4s, {{v[0-31]+}}.2d, {{v[0-31]+}}.2d 4840 } 4841 4842 int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) { 4843 // CHECK: test_vabdl_s8 4844 return vabdl_s8(a, b); 4845 // CHECK: sabdl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4846 } 4847 int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) { 4848 // CHECK: test_vabdl_s16 4849 return vabdl_s16(a, b); 4850 // CHECK: sabdl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4851 } 4852 int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) { 4853 // CHECK: test_vabdl_s32 4854 return vabdl_s32(a, b); 4855 // CHECK: sabdl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4856 } 4857 uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) { 4858 // CHECK: test_vabdl_u8 4859 return vabdl_u8(a, b); 4860 // CHECK: uabdl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4861 } 4862 uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) { 4863 // CHECK: test_vabdl_u16 4864 return vabdl_u16(a, b); 4865 // CHECK: uabdl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4866 } 4867 uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) { 4868 // CHECK: test_vabdl_u32 4869 return vabdl_u32(a, b); 4870 // CHECK: uabdl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4871 } 4872 4873 int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 4874 // CHECK: test_vabal_s8 4875 return vabal_s8(a, b, c); 4876 // CHECK: sabal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4877 } 4878 int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 4879 // CHECK: test_vabal_s16 4880 return vabal_s16(a, b, c); 4881 // CHECK: sabal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4882 } 4883 int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 4884 // CHECK: test_vabal_s32 4885 return vabal_s32(a, b, c); 4886 // CHECK: sabal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4887 } 4888 uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 4889 // CHECK: test_vabal_u8 4890 return vabal_u8(a, b, c); 4891 // CHECK: uabal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4892 } 4893 uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 4894 // CHECK: test_vabal_u16 4895 return vabal_u16(a, b, c); 4896 // CHECK: uabal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4897 } 4898 uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 4899 // CHECK: test_vabal_u32 4900 return vabal_u32(a, b, c); 4901 // CHECK: uabal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4902 } 4903 4904 int16x8_t test_vabdl_high_s8(int8x16_t a, int8x16_t b) { 4905 // CHECK: test_vabdl_high_s8 4906 return vabdl_high_s8(a, b); 4907 // CHECK: sabdl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4908 } 4909 int32x4_t test_vabdl_high_s16(int16x8_t a, int16x8_t b) { 4910 // CHECK: test_vabdl_high_s16 4911 return vabdl_high_s16(a, b); 4912 // CHECK: sabdl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4913 } 4914 int64x2_t test_vabdl_high_s32(int32x4_t a, int32x4_t b) { 4915 // CHECK: test_vabdl_high_s32 4916 return vabdl_high_s32(a, b); 4917 // CHECK: sabdl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4918 } 4919 uint16x8_t test_vabdl_high_u8(uint8x16_t a, uint8x16_t b) { 4920 // CHECK: test_vabdl_high_u8 4921 return vabdl_high_u8(a, b); 4922 // CHECK: uabdl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4923 } 4924 uint32x4_t test_vabdl_high_u16(uint16x8_t a, uint16x8_t b) { 4925 // CHECK: test_vabdl_high_u16 4926 return vabdl_high_u16(a, b); 4927 // CHECK: uabdl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4928 } 4929 uint64x2_t test_vabdl_high_u32(uint32x4_t a, uint32x4_t b) { 4930 // CHECK: test_vabdl_high_u32 4931 return vabdl_high_u32(a, b); 4932 // CHECK: uabdl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4933 } 4934 4935 int16x8_t test_vabal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) { 4936 // CHECK: test_vabal_high_s8 4937 return vabal_high_s8(a, b, c); 4938 // CHECK: sabal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4939 } 4940 int32x4_t test_vabal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) { 4941 // CHECK: test_vabal_high_s16 4942 return vabal_high_s16(a, b, c); 4943 // CHECK: sabal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4944 } 4945 int64x2_t test_vabal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) { 4946 // CHECK: test_vabal_high_s32 4947 return vabal_high_s32(a, b, c); 4948 // CHECK: sabal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4949 } 4950 uint16x8_t test_vabal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) { 4951 // CHECK: test_vabal_high_u8 4952 return vabal_high_u8(a, b, c); 4953 // CHECK: uabal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 4954 } 4955 uint32x4_t test_vabal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) { 4956 // CHECK: test_vabal_high_u16 4957 return vabal_high_u16(a, b, c); 4958 // CHECK: uabal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 4959 } 4960 uint64x2_t test_vabal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) { 4961 // CHECK: test_vabal_high_u32 4962 return vabal_high_u32(a, b, c); 4963 // CHECK: uabal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 4964 } 4965 4966 int16x8_t test_vmull_s8(int8x8_t a, int8x8_t b) { 4967 // CHECK: test_vmull_s8 4968 return vmull_s8(a, b); 4969 // CHECK: smull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4970 } 4971 int32x4_t test_vmull_s16(int16x4_t a, int16x4_t b) { 4972 // CHECK: test_vmull_s16 4973 return vmull_s16(a, b); 4974 // CHECK: smull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4975 } 4976 int64x2_t test_vmull_s32(int32x2_t a, int32x2_t b) { 4977 // CHECK: test_vmull_s32 4978 return vmull_s32(a, b); 4979 // CHECK: smull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4980 } 4981 uint16x8_t test_vmull_u8(uint8x8_t a, uint8x8_t b) { 4982 // CHECK: test_vmull_u8 4983 return vmull_u8(a, b); 4984 // CHECK: umull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 4985 } 4986 uint32x4_t test_vmull_u16(uint16x4_t a, uint16x4_t b) { 4987 // CHECK: test_vmull_u16 4988 return vmull_u16(a, b); 4989 // CHECK: umull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 4990 } 4991 uint64x2_t test_vmull_u32(uint32x2_t a, uint32x2_t b) { 4992 // CHECK: test_vmull_u32 4993 return vmull_u32(a, b); 4994 // CHECK: umull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 4995 } 4996 4997 int16x8_t test_vmull_high_s8(int8x16_t a, int8x16_t b) { 4998 // CHECK: test_vmull_high_s8 4999 return vmull_high_s8(a, b); 5000 // CHECK: smull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5001 } 5002 int32x4_t test_vmull_high_s16(int16x8_t a, int16x8_t b) { 5003 // CHECK: test_vmull_high_s16 5004 return vmull_high_s16(a, b); 5005 // CHECK: smull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5006 } 5007 int64x2_t test_vmull_high_s32(int32x4_t a, int32x4_t b) { 5008 // CHECK: test_vmull_high_s32 5009 return vmull_high_s32(a, b); 5010 // CHECK: smull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5011 } 5012 uint16x8_t test_vmull_high_u8(uint8x16_t a, uint8x16_t b) { 5013 // CHECK: test_vmull_high_u8 5014 return vmull_high_u8(a, b); 5015 // CHECK: umull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5016 } 5017 uint32x4_t test_vmull_high_u16(uint16x8_t a, uint16x8_t b) { 5018 // CHECK: test_vmull_high_u16 5019 return vmull_high_u16(a, b); 5020 // CHECK: umull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5021 } 5022 uint64x2_t test_vmull_high_u32(uint32x4_t a, uint32x4_t b) { 5023 // CHECK: test_vmull_high_u32 5024 return vmull_high_u32(a, b); 5025 // CHECK: umull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5026 } 5027 5028 int16x8_t test_vmlal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 5029 // CHECK: test_vmlal_s8 5030 return vmlal_s8(a, b, c); 5031 // CHECK: smlal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 5032 } 5033 int32x4_t test_vmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 5034 // CHECK: test_vmlal_s16 5035 return vmlal_s16(a, b, c); 5036 // CHECK: smlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5037 } 5038 int64x2_t test_vmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 5039 // CHECK: test_vmlal_s32 5040 return vmlal_s32(a, b, c); 5041 // CHECK: smlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5042 } 5043 uint16x8_t test_vmlal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 5044 // CHECK: test_vmlal_u8 5045 return vmlal_u8(a, b, c); 5046 // CHECK: umlal {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 5047 } 5048 uint32x4_t test_vmlal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 5049 // CHECK: test_vmlal_u16 5050 return vmlal_u16(a, b, c); 5051 // CHECK: umlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5052 } 5053 uint64x2_t test_vmlal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 5054 // CHECK: test_vmlal_u32 5055 return vmlal_u32(a, b, c); 5056 // CHECK: umlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5057 } 5058 5059 int16x8_t test_vmlal_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) { 5060 // CHECK: test_vmlal_high_s8 5061 return vmlal_high_s8(a, b, c); 5062 // CHECK: smlal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5063 } 5064 int32x4_t test_vmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) { 5065 // CHECK: test_vmlal_high_s16 5066 return vmlal_high_s16(a, b, c); 5067 // CHECK: smlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5068 } 5069 int64x2_t test_vmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) { 5070 // CHECK: test_vmlal_high_s32 5071 return vmlal_high_s32(a, b, c); 5072 // CHECK: smlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5073 } 5074 uint16x8_t test_vmlal_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) { 5075 // CHECK: test_vmlal_high_u8 5076 return vmlal_high_u8(a, b, c); 5077 // CHECK: umlal2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5078 } 5079 uint32x4_t test_vmlal_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) { 5080 // CHECK: test_vmlal_high_u16 5081 return vmlal_high_u16(a, b, c); 5082 // CHECK: umlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5083 } 5084 uint64x2_t test_vmlal_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) { 5085 // CHECK: test_vmlal_high_u32 5086 return vmlal_high_u32(a, b, c); 5087 // CHECK: umlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5088 } 5089 5090 int16x8_t test_vmlsl_s8(int16x8_t a, int8x8_t b, int8x8_t c) { 5091 // CHECK: test_vmlsl_s8 5092 return vmlsl_s8(a, b, c); 5093 // CHECK: smlsl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 5094 } 5095 int32x4_t test_vmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 5096 // CHECK: test_vmlsl_s16 5097 return vmlsl_s16(a, b, c); 5098 // CHECK: smlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5099 } 5100 int64x2_t test_vmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 5101 // CHECK: test_vmlsl_s32 5102 return vmlsl_s32(a, b, c); 5103 // CHECK: smlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5104 } 5105 uint16x8_t test_vmlsl_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { 5106 // CHECK: test_vmlsl_u8 5107 return vmlsl_u8(a, b, c); 5108 // CHECK: umlsl {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 5109 } 5110 uint32x4_t test_vmlsl_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { 5111 // CHECK: test_vmlsl_u16 5112 return vmlsl_u16(a, b, c); 5113 // CHECK: umlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5114 } 5115 uint64x2_t test_vmlsl_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { 5116 // CHECK: test_vmlsl_u32 5117 return vmlsl_u32(a, b, c); 5118 // CHECK: umlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5119 } 5120 5121 int16x8_t test_vmlsl_high_s8(int16x8_t a, int8x16_t b, int8x16_t c) { 5122 // CHECK: test_vmlsl_high_s8 5123 return vmlsl_high_s8(a, b, c); 5124 // CHECK: smlsl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5125 } 5126 int32x4_t test_vmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) { 5127 // CHECK: test_vmlsl_high_s16 5128 return vmlsl_high_s16(a, b, c); 5129 // CHECK: smlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5130 } 5131 int64x2_t test_vmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) { 5132 // CHECK: test_vmlsl_high_s32 5133 return vmlsl_high_s32(a, b, c); 5134 // CHECK: smlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5135 } 5136 uint16x8_t test_vmlsl_high_u8(uint16x8_t a, uint8x16_t b, uint8x16_t c) { 5137 // CHECK: test_vmlsl_high_u8 5138 return vmlsl_high_u8(a, b, c); 5139 // CHECK: umlsl2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5140 } 5141 uint32x4_t test_vmlsl_high_u16(uint32x4_t a, uint16x8_t b, uint16x8_t c) { 5142 // CHECK: test_vmlsl_high_u16 5143 return vmlsl_high_u16(a, b, c); 5144 // CHECK: umlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5145 } 5146 uint64x2_t test_vmlsl_high_u32(uint64x2_t a, uint32x4_t b, uint32x4_t c) { 5147 // CHECK: test_vmlsl_high_u32 5148 return vmlsl_high_u32(a, b, c); 5149 // CHECK: umlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5150 } 5151 5152 int32x4_t test_vqdmull_s16(int16x4_t a, int16x4_t b) { 5153 // CHECK: test_vqdmull_s16 5154 return vqdmull_s16(a, b); 5155 // CHECK: sqdmull {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5156 } 5157 int64x2_t test_vqdmull_s32(int32x2_t a, int32x2_t b) { 5158 // CHECK: test_vqdmull_s32 5159 return vqdmull_s32(a, b); 5160 // CHECK: sqdmull {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5161 } 5162 5163 int32x4_t test_vqdmlal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 5164 // CHECK: test_vqdmlal_s16 5165 return vqdmlal_s16(a, b, c); 5166 // CHECK: sqdmlal {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5167 } 5168 5169 int64x2_t test_vqdmlal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 5170 // CHECK: test_vqdmlal_s32 5171 return vqdmlal_s32(a, b, c); 5172 // CHECK: sqdmlal {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5173 } 5174 5175 int32x4_t test_vqdmlsl_s16(int32x4_t a, int16x4_t b, int16x4_t c) { 5176 // CHECK: test_vqdmlsl_s16 5177 return vqdmlsl_s16(a, b, c); 5178 // CHECK: sqdmlsl {{v[0-31]+}}.4s, {{v[0-31]+}}.4h, {{v[0-31]+}}.4h 5179 } 5180 5181 int64x2_t test_vqdmlsl_s32(int64x2_t a, int32x2_t b, int32x2_t c) { 5182 // CHECK: test_vqdmlsl_s32 5183 return vqdmlsl_s32(a, b, c); 5184 // CHECK: sqdmlsl {{v[0-31]+}}.2d, {{v[0-31]+}}.2s, {{v[0-31]+}}.2s 5185 } 5186 5187 int32x4_t test_vqdmull_high_s16(int16x8_t a, int16x8_t b) { 5188 // CHECK: test_vqdmull_high_s16 5189 return vqdmull_high_s16(a, b); 5190 // CHECK: sqdmull2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5191 } 5192 int64x2_t test_vqdmull_high_s32(int32x4_t a, int32x4_t b) { 5193 // CHECK: test_vqdmull_high_s32 5194 return vqdmull_high_s32(a, b); 5195 // CHECK: sqdmull2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5196 } 5197 5198 int32x4_t test_vqdmlal_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) { 5199 // CHECK: test_vqdmlal_high_s16 5200 return vqdmlal_high_s16(a, b, c); 5201 // CHECK: sqdmlal2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5202 } 5203 5204 int64x2_t test_vqdmlal_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) { 5205 // CHECK: test_vqdmlal_high_s32 5206 return vqdmlal_high_s32(a, b, c); 5207 // CHECK: sqdmlal2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5208 } 5209 5210 int32x4_t test_vqdmlsl_high_s16(int32x4_t a, int16x8_t b, int16x8_t c) { 5211 // CHECK: test_vqdmlsl_high_s16 5212 return vqdmlsl_high_s16(a, b, c); 5213 // CHECK: sqdmlsl2 {{v[0-31]+}}.4s, {{v[0-31]+}}.8h, {{v[0-31]+}}.8h 5214 } 5215 5216 int64x2_t test_vqdmlsl_high_s32(int64x2_t a, int32x4_t b, int32x4_t c) { 5217 // CHECK: test_vqdmlsl_high_s32 5218 return vqdmlsl_high_s32(a, b, c); 5219 // CHECK: sqdmlsl2 {{v[0-31]+}}.2d, {{v[0-31]+}}.4s, {{v[0-31]+}}.4s 5220 } 5221 5222 poly16x8_t test_vmull_p8(poly8x8_t a, poly8x8_t b) { 5223 // CHECK: test_vmull_p8 5224 return vmull_p8(a, b); 5225 // CHECK: pmull {{v[0-31]+}}.8h, {{v[0-31]+}}.8b, {{v[0-31]+}}.8b 5226 } 5227 5228 poly16x8_t test_vmull_high_p8(poly8x16_t a, poly8x16_t b) { 5229 // CHECK: test_vmull_high_p8 5230 return vmull_high_p8(a, b); 5231 // CHECK: pmull2 {{v[0-31]+}}.8h, {{v[0-31]+}}.16b, {{v[0-31]+}}.16b 5232 } 5233 5234 int64_t test_vaddd_s64(int64_t a, int64_t b) { 5235 // CHECK: test_vaddd_s64 5236 return vaddd_s64(a, b); 5237 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5238 } 5239 5240 uint64_t test_vaddd_u64(uint64_t a, uint64_t b) { 5241 // CHECK: test_vaddd_u64 5242 return vaddd_u64(a, b); 5243 // CHECK: add {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5244 } 5245 5246 int64_t test_vsubd_s64(int64_t a, int64_t b) { 5247 // CHECK: test_vsubd_s64 5248 return vsubd_s64(a, b); 5249 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5250 } 5251 5252 uint64_t test_vsubd_u64(uint64_t a, uint64_t b) { 5253 // CHECK: test_vsubd_u64 5254 return vsubd_u64(a, b); 5255 // CHECK: sub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5256 } 5257 5258 int8_t test_vqaddb_s8(int8_t a, int8_t b) { 5259 // CHECK: test_vqaddb_s8 5260 return vqaddb_s8(a, b); 5261 // CHECK: sqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5262 } 5263 5264 int16_t test_vqaddh_s16(int16_t a, int16_t b) { 5265 // CHECK: test_vqaddh_s16 5266 return vqaddh_s16(a, b); 5267 // CHECK: sqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5268 } 5269 5270 int32_t test_vqadds_s32(int32_t a, int32_t b) { 5271 // CHECK: test_vqadds_s32 5272 return vqadds_s32(a, b); 5273 // CHECK: sqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5274 } 5275 5276 int64_t test_vqaddd_s64(int64_t a, int64_t b) { 5277 // CHECK: test_vqaddd_s64 5278 return vqaddd_s64(a, b); 5279 // CHECK: sqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5280 } 5281 5282 uint8_t test_vqaddb_u8(uint8_t a, uint8_t b) { 5283 // CHECK: test_vqaddb_u8 5284 return vqaddb_u8(a, b); 5285 // CHECK: uqadd {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5286 } 5287 5288 uint16_t test_vqaddh_u16(uint16_t a, uint16_t b) { 5289 // CHECK: test_vqaddh_u16 5290 return vqaddh_u16(a, b); 5291 // CHECK: uqadd {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5292 } 5293 5294 uint32_t test_vqadds_u32(uint32_t a, uint32_t b) { 5295 // CHECK: test_vqadds_u32 5296 return vqadds_u32(a, b); 5297 // CHECK: uqadd {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5298 } 5299 5300 uint64_t test_vqaddd_u64(uint64_t a, uint64_t b) { 5301 // CHECK: test_vqaddd_u64 5302 return vqaddd_u64(a, b); 5303 // CHECK: uqadd {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5304 } 5305 5306 int8_t test_vqsubb_s8(int8_t a, int8_t b) { 5307 // CHECK: test_vqsubb_s8 5308 return vqsubb_s8(a, b); 5309 // CHECK: sqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5310 } 5311 5312 int16_t test_vqsubh_s16(int16_t a, int16_t b) { 5313 // CHECK: test_vqsubh_s16 5314 return vqsubh_s16(a, b); 5315 // CHECK: sqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5316 } 5317 5318 int32_t test_vqsubs_s32(int32_t a, int32_t b) { 5319 // CHECK: test_vqsubs_s32 5320 return vqsubs_s32(a, b); 5321 // CHECK: sqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5322 } 5323 5324 int64_t test_vqsubd_s64(int64_t a, int64_t b) { 5325 // CHECK: test_vqsubd_s64 5326 return vqsubd_s64(a, b); 5327 // CHECK: sqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5328 } 5329 5330 uint8_t test_vqsubb_u8(uint8_t a, uint8_t b) { 5331 // CHECK: test_vqsubb_u8 5332 return vqsubb_u8(a, b); 5333 // CHECK: uqsub {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5334 } 5335 5336 uint16_t test_vqsubh_u16(uint16_t a, uint16_t b) { 5337 // CHECK: test_vqsubh_u16 5338 return vqsubh_u16(a, b); 5339 // CHECK: uqsub {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5340 } 5341 5342 uint32_t test_vqsubs_u32(uint32_t a, uint32_t b) { 5343 // CHECK: test_vqsubs_u32 5344 return vqsubs_u32(a, b); 5345 // CHECK: uqsub {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5346 } 5347 5348 uint64_t test_vqsubd_u64(uint64_t a, uint64_t b) { 5349 // CHECK: test_vqsubd_u64 5350 return vqsubd_u64(a, b); 5351 // CHECK: uqsub {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5352 } 5353 5354 int64_t test_vshld_s64(int64_t a, int64_t b) { 5355 // CHECK: test_vshld_s64 5356 return vshld_s64(a, b); 5357 // CHECK: sshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5358 } 5359 5360 uint64_t test_vshld_u64(uint64_t a, uint64_t b) { 5361 // CHECK: test_vshld_u64 5362 return vshld_u64(a, b); 5363 // CHECK: ushl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5364 } 5365 5366 // CHECK: test_vqshlb_s8 5367 int8_t test_vqshlb_s8(int8_t a, int8_t b) { 5368 return vqshlb_s8(a, b); 5369 // CHECK: sqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5370 } 5371 5372 // CHECK: test_vqshlh_s16 5373 int16_t test_vqshlh_s16(int16_t a, int16_t b) { 5374 return vqshlh_s16(a, b); 5375 // CHECK: sqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5376 } 5377 5378 // CHECK: test_vqshls_s32 5379 int32_t test_vqshls_s32(int32_t a, int32_t b) { 5380 return vqshls_s32(a, b); 5381 // CHECK: sqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5382 } 5383 5384 // CHECK: test_vqshld_s64 5385 int64_t test_vqshld_s64(int64_t a, int64_t b) { 5386 return vqshld_s64(a, b); 5387 // CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5388 } 5389 5390 // CHECK: test_vqshlb_u8 5391 uint8_t test_vqshlb_u8(uint8_t a, uint8_t b) { 5392 return vqshlb_u8(a, b); 5393 // CHECK: uqshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5394 } 5395 5396 // CHECK: test_vqshlh_u16 5397 uint16_t test_vqshlh_u16(uint16_t a, uint16_t b) { 5398 return vqshlh_u16(a, b); 5399 // CHECK: uqshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5400 } 5401 5402 // CHECK: test_vqshls_u32 5403 uint32_t test_vqshls_u32(uint32_t a, uint32_t b) { 5404 return vqshls_u32(a, b); 5405 // CHECK: uqshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5406 } 5407 5408 // CHECK: test_vqshld_u64 5409 uint64_t test_vqshld_u64(uint64_t a, uint64_t b) { 5410 return vqshld_u64(a, b); 5411 // CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5412 } 5413 5414 // CHECK: test_vrshld_s64 5415 int64_t test_vrshld_s64(int64_t a, int64_t b) { 5416 return vrshld_s64(a, b); 5417 // CHECK: srshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5418 } 5419 5420 5421 // CHECK: test_vrshld_u64 5422 uint64_t test_vrshld_u64(uint64_t a, uint64_t b) { 5423 return vrshld_u64(a, b); 5424 // CHECK: urshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5425 } 5426 5427 // CHECK: test_vqrshlb_s8 5428 int8_t test_vqrshlb_s8(int8_t a, int8_t b) { 5429 return vqrshlb_s8(a, b); 5430 // CHECK: sqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5431 } 5432 5433 // CHECK: test_vqrshlh_s16 5434 int16_t test_vqrshlh_s16(int16_t a, int16_t b) { 5435 return vqrshlh_s16(a, b); 5436 // CHECK: sqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5437 } 5438 5439 // CHECK: test_vqrshls_s32 5440 int32_t test_vqrshls_s32(int32_t a, int32_t b) { 5441 return vqrshls_s32(a, b); 5442 // CHECK: sqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5443 } 5444 5445 // CHECK: test_vqrshld_s64 5446 int64_t test_vqrshld_s64(int64_t a, int64_t b) { 5447 return vqrshld_s64(a, b); 5448 // CHECK: sqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5449 } 5450 5451 // CHECK: test_vqrshlb_u8 5452 uint8_t test_vqrshlb_u8(uint8_t a, uint8_t b) { 5453 return vqrshlb_u8(a, b); 5454 // CHECK: uqrshl {{b[0-9]+}}, {{b[0-9]+}}, {{b[0-9]+}} 5455 } 5456 5457 // CHECK: test_vqrshlh_u16 5458 uint16_t test_vqrshlh_u16(uint16_t a, uint16_t b) { 5459 return vqrshlh_u16(a, b); 5460 // CHECK: uqrshl {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5461 } 5462 5463 // CHECK: test_vqrshls_u32 5464 uint32_t test_vqrshls_u32(uint32_t a, uint32_t b) { 5465 return vqrshls_u32(a, b); 5466 // CHECK: uqrshl {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5467 } 5468 5469 // CHECK: test_vqrshld_u64 5470 uint64_t test_vqrshld_u64(uint64_t a, uint64_t b) { 5471 return vqrshld_u64(a, b); 5472 // CHECK: uqrshl {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5473 } 5474 5475 // CHECK: test_vpaddd_s64 5476 int64_t test_vpaddd_s64(int64x2_t a) { 5477 return vpaddd_s64(a); 5478 // CHECK: addp {{d[0-9]+}}, {{v[0-9]+}}.2d 5479 } 5480 5481 // CHECK: test_vpadds_f32 5482 float32_t test_vpadds_f32(float32x2_t a) { 5483 return vpadds_f32(a); 5484 // CHECK: faddp {{s[0-9]+}}, {{v[0-9]+}}.2s 5485 } 5486 5487 // CHECK: test_vpaddd_f64 5488 float64_t test_vpaddd_f64(float64x2_t a) { 5489 return vpaddd_f64(a); 5490 // CHECK: faddp {{d[0-9]+}}, {{v[0-9]+}}.2d 5491 } 5492 5493 // CHECK: test_vpmaxnms_f32 5494 float32_t test_vpmaxnms_f32(float32x2_t a) { 5495 return vpmaxnms_f32(a); 5496 // CHECK: fmaxnmp {{s[0-9]+}}, {{v[0-9]+}}.2s 5497 } 5498 5499 // CHECK: test_vpmaxnmqd_f64 5500 float64_t test_vpmaxnmqd_f64(float64x2_t a) { 5501 return vpmaxnmqd_f64(a); 5502 // CHECK: fmaxnmp {{d[0-9]+}}, {{v[0-9]+}}.2d 5503 } 5504 5505 // CHECK: test_vpmaxs_f32 5506 float32_t test_vpmaxs_f32(float32x2_t a) { 5507 return vpmaxs_f32(a); 5508 // CHECK: fmaxp {{s[0-9]+}}, {{v[0-9]+}}.2s 5509 } 5510 5511 // CHECK: test_vpmaxqd_f64 5512 float64_t test_vpmaxqd_f64(float64x2_t a) { 5513 return vpmaxqd_f64(a); 5514 // CHECK: fmaxp {{d[0-9]+}}, {{v[0-9]+}}.2d 5515 } 5516 5517 // CHECK: test_vpminnms_f32 5518 float32_t test_vpminnms_f32(float32x2_t a) { 5519 return vpminnms_f32(a); 5520 // CHECK: fminnmp {{s[0-9]+}}, {{v[0-9]+}}.2s 5521 } 5522 5523 // CHECK: test_vpminnmqd_f64 5524 float64_t test_vpminnmqd_f64(float64x2_t a) { 5525 return vpminnmqd_f64(a); 5526 // CHECK: fminnmp {{d[0-9]+}}, {{v[0-9]+}}.2d 5527 } 5528 5529 // CHECK: test_vpmins_f32 5530 float32_t test_vpmins_f32(float32x2_t a) { 5531 return vpmins_f32(a); 5532 // CHECK: fminp {{s[0-9]+}}, {{v[0-9]+}}.2s 5533 } 5534 5535 // CHECK: test_vpminqd_f64 5536 float64_t test_vpminqd_f64(float64x2_t a) { 5537 return vpminqd_f64(a); 5538 // CHECK: fminp {{d[0-9]+}}, {{v[0-9]+}}.2d 5539 } 5540 5541 int16_t test_vqdmulhh_s16(int16_t a, int16_t b) { 5542 // CHECK: test_vqdmulhh_s16 5543 return vqdmulhh_s16(a, b); 5544 // CHECK: sqdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5545 } 5546 5547 int32_t test_vqdmulhs_s32(int32_t a, int32_t b) { 5548 // CHECK: test_vqdmulhs_s32 5549 return vqdmulhs_s32(a, b); 5550 // CHECK: sqdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5551 } 5552 5553 int16_t test_vqrdmulhh_s16(int16_t a, int16_t b) { 5554 // CHECK: test_vqrdmulhh_s16 5555 return vqrdmulhh_s16(a, b); 5556 // CHECK: sqrdmulh {{h[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 5557 } 5558 5559 int32_t test_vqrdmulhs_s32(int32_t a, int32_t b) { 5560 // CHECK: test_vqrdmulhs_s32 5561 return vqrdmulhs_s32(a, b); 5562 // CHECK: sqrdmulh {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5563 } 5564 5565 float32_t test_vmulxs_f32(float32_t a, float32_t b) { 5566 // CHECK: test_vmulxs_f32 5567 return vmulxs_f32(a, b); 5568 // CHECK: fmulx {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5569 } 5570 5571 float64_t test_vmulxd_f64(float64_t a, float64_t b) { 5572 // CHECK: test_vmulxd_f64 5573 return vmulxd_f64(a, b); 5574 // CHECK: fmulx {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5575 } 5576 5577 float32_t test_vrecpss_f32(float32_t a, float32_t b) { 5578 // CHECK: test_vrecpss_f32 5579 return vrecpss_f32(a, b); 5580 // CHECK: frecps {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5581 } 5582 5583 float64_t test_vrecpsd_f64(float64_t a, float64_t b) { 5584 // CHECK: test_vrecpsd_f64 5585 return vrecpsd_f64(a, b); 5586 // CHECK: frecps {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5587 } 5588 5589 float32_t test_vrsqrtss_f32(float32_t a, float32_t b) { 5590 // CHECK: test_vrsqrtss_f32 5591 return vrsqrtss_f32(a, b); 5592 // CHECK: frsqrts {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 5593 } 5594 5595 float64_t test_vrsqrtsd_f64(float64_t a, float64_t b) { 5596 // CHECK: test_vrsqrtsd_f64 5597 return vrsqrtsd_f64(a, b); 5598 // CHECK: frsqrts {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 5599 } 5600 5601 float32_t test_vcvts_f32_s32(int32_t a) { 5602 // CHECK: test_vcvts_f32_s32 5603 // CHECK: scvtf {{s[0-9]+}}, {{s[0-9]+}} 5604 return vcvts_f32_s32(a); 5605 } 5606 5607 float64_t test_vcvtd_f64_s64(int64_t a) { 5608 // CHECK: test_vcvtd_f64_s64 5609 // CHECK: scvtf {{d[0-9]+}}, {{d[0-9]+}} 5610 return vcvtd_f64_s64(a); 5611 } 5612 5613 float32_t test_vcvts_f32_u32(uint32_t a) { 5614 // CHECK: test_vcvts_f32_u32 5615 // CHECK: ucvtf {{s[0-9]+}}, {{s[0-9]+}} 5616 return vcvts_f32_u32(a); 5617 } 5618 5619 float64_t test_vcvtd_f64_u64(uint64_t a) { 5620 // CHECK: test_vcvtd_f64_u64 5621 // CHECK: ucvtf {{d[0-9]+}}, {{d[0-9]+}} 5622 return vcvtd_f64_u64(a); 5623 } 5624 5625 float32_t test_vrecpes_f32(float32_t a) { 5626 // CHECK: test_vrecpes_f32 5627 // CHECK: frecpe {{s[0-9]+}}, {{s[0-9]+}} 5628 return vrecpes_f32(a); 5629 } 5630 5631 float64_t test_vrecped_f64(float64_t a) { 5632 // CHECK: test_vrecped_f64 5633 // CHECK: frecpe {{d[0-9]+}}, {{d[0-9]+}} 5634 return vrecped_f64(a); 5635 } 5636 5637 float32_t test_vrecpxs_f32(float32_t a) { 5638 // CHECK: test_vrecpxs_f32 5639 // CHECK: frecpx {{s[0-9]+}}, {{s[0-9]+}} 5640 return vrecpxs_f32(a); 5641 } 5642 5643 float64_t test_vrecpxd_f64(float64_t a) { 5644 // CHECK: test_vrecpxd_f64 5645 // CHECK: frecpx {{d[0-9]+}}, {{d[0-9]+}} 5646 return vrecpxd_f64(a); 5647 } 5648 5649 float32_t test_vrsqrtes_f32(float32_t a) { 5650 // CHECK: vrsqrtes_f32 5651 // CHECK: frsqrte {{s[0-9]+}}, {{s[0-9]+}} 5652 return vrsqrtes_f32(a); 5653 } 5654 5655 float64_t test_vrsqrted_f64(float64_t a) { 5656 // CHECK: vrsqrted_f64 5657 // CHECK: frsqrte {{d[0-9]+}}, {{d[0-9]+}} 5658 return vrsqrted_f64(a); 5659 } 5660 5661 uint8x16_t test_vld1q_u8(uint8_t const *a) { 5662 // CHECK: test_vld1q_u8 5663 return vld1q_u8(a); 5664 // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5665 } 5666 5667 uint16x8_t test_vld1q_u16(uint16_t const *a) { 5668 // CHECK: test_vld1q_u16 5669 return vld1q_u16(a); 5670 // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5671 } 5672 5673 uint32x4_t test_vld1q_u32(uint32_t const *a) { 5674 // CHECK: test_vld1q_u32 5675 return vld1q_u32(a); 5676 // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5677 } 5678 5679 uint64x2_t test_vld1q_u64(uint64_t const *a) { 5680 // CHECK: test_vld1q_u64 5681 return vld1q_u64(a); 5682 // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5683 } 5684 5685 int8x16_t test_vld1q_s8(int8_t const *a) { 5686 // CHECK: test_vld1q_s8 5687 return vld1q_s8(a); 5688 // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5689 } 5690 5691 int16x8_t test_vld1q_s16(int16_t const *a) { 5692 // CHECK: test_vld1q_s16 5693 return vld1q_s16(a); 5694 // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5695 } 5696 5697 int32x4_t test_vld1q_s32(int32_t const *a) { 5698 // CHECK: test_vld1q_s32 5699 return vld1q_s32(a); 5700 // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5701 } 5702 5703 int64x2_t test_vld1q_s64(int64_t const *a) { 5704 // CHECK: test_vld1q_s64 5705 return vld1q_s64(a); 5706 // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5707 } 5708 5709 float16x8_t test_vld1q_f16(float16_t const *a) { 5710 // CHECK: test_vld1q_f16 5711 return vld1q_f16(a); 5712 // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5713 } 5714 5715 float32x4_t test_vld1q_f32(float32_t const *a) { 5716 // CHECK: test_vld1q_f32 5717 return vld1q_f32(a); 5718 // CHECK: ld1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5719 } 5720 5721 float64x2_t test_vld1q_f64(float64_t const *a) { 5722 // CHECK: test_vld1q_f64 5723 return vld1q_f64(a); 5724 // CHECK: ld1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5725 } 5726 5727 poly8x16_t test_vld1q_p8(poly8_t const *a) { 5728 // CHECK: test_vld1q_p8 5729 return vld1q_p8(a); 5730 // CHECK: ld1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5731 } 5732 5733 poly16x8_t test_vld1q_p16(poly16_t const *a) { 5734 // CHECK: test_vld1q_p16 5735 return vld1q_p16(a); 5736 // CHECK: ld1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5737 } 5738 5739 uint8x8_t test_vld1_u8(uint8_t const *a) { 5740 // CHECK: test_vld1_u8 5741 return vld1_u8(a); 5742 // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5743 } 5744 5745 uint16x4_t test_vld1_u16(uint16_t const *a) { 5746 // CHECK: test_vld1_u16 5747 return vld1_u16(a); 5748 // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5749 } 5750 5751 uint32x2_t test_vld1_u32(uint32_t const *a) { 5752 // CHECK: test_vld1_u32 5753 return vld1_u32(a); 5754 // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5755 } 5756 5757 uint64x1_t test_vld1_u64(uint64_t const *a) { 5758 // CHECK: test_vld1_u64 5759 return vld1_u64(a); 5760 // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5761 } 5762 5763 int8x8_t test_vld1_s8(int8_t const *a) { 5764 // CHECK: test_vld1_s8 5765 return vld1_s8(a); 5766 // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5767 } 5768 5769 int16x4_t test_vld1_s16(int16_t const *a) { 5770 // CHECK: test_vld1_s16 5771 return vld1_s16(a); 5772 // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5773 } 5774 5775 int32x2_t test_vld1_s32(int32_t const *a) { 5776 // CHECK: test_vld1_s32 5777 return vld1_s32(a); 5778 // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5779 } 5780 5781 int64x1_t test_vld1_s64(int64_t const *a) { 5782 // CHECK: test_vld1_s64 5783 return vld1_s64(a); 5784 // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5785 } 5786 5787 float16x4_t test_vld1_f16(float16_t const *a) { 5788 // CHECK: test_vld1_f16 5789 return vld1_f16(a); 5790 // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5791 } 5792 5793 float32x2_t test_vld1_f32(float32_t const *a) { 5794 // CHECK: test_vld1_f32 5795 return vld1_f32(a); 5796 // CHECK: ld1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5797 } 5798 5799 float64x1_t test_vld1_f64(float64_t const *a) { 5800 // CHECK: test_vld1_f64 5801 return vld1_f64(a); 5802 // CHECK: ld1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5803 } 5804 5805 poly8x8_t test_vld1_p8(poly8_t const *a) { 5806 // CHECK: test_vld1_p8 5807 return vld1_p8(a); 5808 // CHECK: ld1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5809 } 5810 5811 poly16x4_t test_vld1_p16(poly16_t const *a) { 5812 // CHECK: test_vld1_p16 5813 return vld1_p16(a); 5814 // CHECK: ld1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5815 } 5816 5817 uint8x16x2_t test_vld2q_u8(uint8_t const *a) { 5818 // CHECK: test_vld2q_u8 5819 return vld2q_u8(a); 5820 // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5821 } 5822 5823 uint16x8x2_t test_vld2q_u16(uint16_t const *a) { 5824 // CHECK: test_vld2q_u16 5825 return vld2q_u16(a); 5826 // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5827 } 5828 5829 uint32x4x2_t test_vld2q_u32(uint32_t const *a) { 5830 // CHECK: test_vld2q_u32 5831 return vld2q_u32(a); 5832 // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5833 } 5834 5835 uint64x2x2_t test_vld2q_u64(uint64_t const *a) { 5836 // CHECK: test_vld2q_u64 5837 return vld2q_u64(a); 5838 // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5839 } 5840 5841 int8x16x2_t test_vld2q_s8(int8_t const *a) { 5842 // CHECK: test_vld2q_s8 5843 return vld2q_s8(a); 5844 // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5845 } 5846 5847 int16x8x2_t test_vld2q_s16(int16_t const *a) { 5848 // CHECK: test_vld2q_s16 5849 return vld2q_s16(a); 5850 // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5851 } 5852 5853 int32x4x2_t test_vld2q_s32(int32_t const *a) { 5854 // CHECK: test_vld2q_s32 5855 return vld2q_s32(a); 5856 // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5857 } 5858 5859 int64x2x2_t test_vld2q_s64(int64_t const *a) { 5860 // CHECK: test_vld2q_s64 5861 return vld2q_s64(a); 5862 // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5863 } 5864 5865 float16x8x2_t test_vld2q_f16(float16_t const *a) { 5866 // CHECK: test_vld2q_f16 5867 return vld2q_f16(a); 5868 // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5869 } 5870 5871 float32x4x2_t test_vld2q_f32(float32_t const *a) { 5872 // CHECK: test_vld2q_f32 5873 return vld2q_f32(a); 5874 // CHECK: ld2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 5875 } 5876 5877 float64x2x2_t test_vld2q_f64(float64_t const *a) { 5878 // CHECK: test_vld2q_f64 5879 return vld2q_f64(a); 5880 // CHECK: ld2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 5881 } 5882 5883 poly8x16x2_t test_vld2q_p8(poly8_t const *a) { 5884 // CHECK: test_vld2q_p8 5885 return vld2q_p8(a); 5886 // CHECK: ld2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 5887 } 5888 5889 poly16x8x2_t test_vld2q_p16(poly16_t const *a) { 5890 // CHECK: test_vld2q_p16 5891 return vld2q_p16(a); 5892 // CHECK: ld2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 5893 } 5894 5895 uint8x8x2_t test_vld2_u8(uint8_t const *a) { 5896 // CHECK: test_vld2_u8 5897 return vld2_u8(a); 5898 // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5899 } 5900 5901 uint16x4x2_t test_vld2_u16(uint16_t const *a) { 5902 // CHECK: test_vld2_u16 5903 return vld2_u16(a); 5904 // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5905 } 5906 5907 uint32x2x2_t test_vld2_u32(uint32_t const *a) { 5908 // CHECK: test_vld2_u32 5909 return vld2_u32(a); 5910 // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5911 } 5912 5913 uint64x1x2_t test_vld2_u64(uint64_t const *a) { 5914 // CHECK: test_vld2_u64 5915 return vld2_u64(a); 5916 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5917 } 5918 5919 int8x8x2_t test_vld2_s8(int8_t const *a) { 5920 // CHECK: test_vld2_s8 5921 return vld2_s8(a); 5922 // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5923 } 5924 5925 int16x4x2_t test_vld2_s16(int16_t const *a) { 5926 // CHECK: test_vld2_s16 5927 return vld2_s16(a); 5928 // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5929 } 5930 5931 int32x2x2_t test_vld2_s32(int32_t const *a) { 5932 // CHECK: test_vld2_s32 5933 return vld2_s32(a); 5934 // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5935 } 5936 5937 int64x1x2_t test_vld2_s64(int64_t const *a) { 5938 // CHECK: test_vld2_s64 5939 return vld2_s64(a); 5940 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5941 } 5942 5943 float16x4x2_t test_vld2_f16(float16_t const *a) { 5944 // CHECK: test_vld2_f16 5945 return vld2_f16(a); 5946 // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5947 } 5948 5949 float32x2x2_t test_vld2_f32(float32_t const *a) { 5950 // CHECK: test_vld2_f32 5951 return vld2_f32(a); 5952 // CHECK: ld2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 5953 } 5954 5955 float64x1x2_t test_vld2_f64(float64_t const *a) { 5956 // CHECK: test_vld2_f64 5957 return vld2_f64(a); 5958 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 5959 } 5960 5961 poly8x8x2_t test_vld2_p8(poly8_t const *a) { 5962 // CHECK: test_vld2_p8 5963 return vld2_p8(a); 5964 // CHECK: ld2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 5965 } 5966 5967 poly16x4x2_t test_vld2_p16(poly16_t const *a) { 5968 // CHECK: test_vld2_p16 5969 return vld2_p16(a); 5970 // CHECK: ld2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 5971 } 5972 5973 uint8x16x3_t test_vld3q_u8(uint8_t const *a) { 5974 // CHECK: test_vld3q_u8 5975 return vld3q_u8(a); 5976 // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 5977 // [{{x[0-9]+|sp}}] 5978 } 5979 5980 uint16x8x3_t test_vld3q_u16(uint16_t const *a) { 5981 // CHECK: test_vld3q_u16 5982 return vld3q_u16(a); 5983 // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 5984 // [{{x[0-9]+|sp}}] 5985 } 5986 5987 uint32x4x3_t test_vld3q_u32(uint32_t const *a) { 5988 // CHECK: test_vld3q_u32 5989 return vld3q_u32(a); 5990 // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 5991 // [{{x[0-9]+|sp}}] 5992 } 5993 5994 uint64x2x3_t test_vld3q_u64(uint64_t const *a) { 5995 // CHECK: test_vld3q_u64 5996 return vld3q_u64(a); 5997 // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 5998 // [{{x[0-9]+|sp}}] 5999 } 6000 6001 int8x16x3_t test_vld3q_s8(int8_t const *a) { 6002 // CHECK: test_vld3q_s8 6003 return vld3q_s8(a); 6004 // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 6005 // [{{x[0-9]+|sp}}] 6006 } 6007 6008 int16x8x3_t test_vld3q_s16(int16_t const *a) { 6009 // CHECK: test_vld3q_s16 6010 return vld3q_s16(a); 6011 // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6012 // [{{x[0-9]+|sp}}] 6013 } 6014 6015 int32x4x3_t test_vld3q_s32(int32_t const *a) { 6016 // CHECK: test_vld3q_s32 6017 return vld3q_s32(a); 6018 // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 6019 // [{{x[0-9]+|sp}}] 6020 } 6021 6022 int64x2x3_t test_vld3q_s64(int64_t const *a) { 6023 // CHECK: test_vld3q_s64 6024 return vld3q_s64(a); 6025 // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 6026 // [{{x[0-9]+|sp}}] 6027 } 6028 6029 float16x8x3_t test_vld3q_f16(float16_t const *a) { 6030 // CHECK: test_vld3q_f16 6031 return vld3q_f16(a); 6032 // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6033 // [{{x[0-9]+|sp}}] 6034 } 6035 6036 float32x4x3_t test_vld3q_f32(float32_t const *a) { 6037 // CHECK: test_vld3q_f32 6038 return vld3q_f32(a); 6039 // CHECK: ld3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 6040 // [{{x[0-9]+|sp}}] 6041 } 6042 6043 float64x2x3_t test_vld3q_f64(float64_t const *a) { 6044 // CHECK: test_vld3q_f64 6045 return vld3q_f64(a); 6046 // CHECK: ld3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 6047 // [{{x[0-9]+|sp}}] 6048 } 6049 6050 poly8x16x3_t test_vld3q_p8(poly8_t const *a) { 6051 // CHECK: test_vld3q_p8 6052 return vld3q_p8(a); 6053 // CHECK: ld3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 6054 // [{{x[0-9]+|sp}}] 6055 } 6056 6057 poly16x8x3_t test_vld3q_p16(poly16_t const *a) { 6058 // CHECK: test_vld3q_p16 6059 return vld3q_p16(a); 6060 // CHECK: ld3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6061 // [{{x[0-9]+|sp}}] 6062 } 6063 6064 uint8x8x3_t test_vld3_u8(uint8_t const *a) { 6065 // CHECK: test_vld3_u8 6066 return vld3_u8(a); 6067 // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6068 // [{{x[0-9]+|sp}}] 6069 } 6070 6071 uint16x4x3_t test_vld3_u16(uint16_t const *a) { 6072 // CHECK: test_vld3_u16 6073 return vld3_u16(a); 6074 // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6075 // [{{x[0-9]+|sp}}] 6076 } 6077 6078 uint32x2x3_t test_vld3_u32(uint32_t const *a) { 6079 // CHECK: test_vld3_u32 6080 return vld3_u32(a); 6081 // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6082 // [{{x[0-9]+|sp}}] 6083 } 6084 6085 uint64x1x3_t test_vld3_u64(uint64_t const *a) { 6086 // CHECK: test_vld3_u64 6087 return vld3_u64(a); 6088 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6089 // [{{x[0-9]+|sp}}] 6090 } 6091 6092 int8x8x3_t test_vld3_s8(int8_t const *a) { 6093 // CHECK: test_vld3_s8 6094 return vld3_s8(a); 6095 // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6096 // [{{x[0-9]+|sp}}] 6097 } 6098 6099 int16x4x3_t test_vld3_s16(int16_t const *a) { 6100 // CHECK: test_vld3_s16 6101 return vld3_s16(a); 6102 // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6103 // [{{x[0-9]+|sp}}] 6104 } 6105 6106 int32x2x3_t test_vld3_s32(int32_t const *a) { 6107 // CHECK: test_vld3_s32 6108 return vld3_s32(a); 6109 // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6110 // [{{x[0-9]+|sp}}] 6111 } 6112 6113 int64x1x3_t test_vld3_s64(int64_t const *a) { 6114 // CHECK: test_vld3_s64 6115 return vld3_s64(a); 6116 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6117 // [{{x[0-9]+|sp}}] 6118 } 6119 6120 float16x4x3_t test_vld3_f16(float16_t const *a) { 6121 // CHECK: test_vld3_f16 6122 return vld3_f16(a); 6123 // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6124 // [{{x[0-9]+|sp}}] 6125 } 6126 6127 float32x2x3_t test_vld3_f32(float32_t const *a) { 6128 // CHECK: test_vld3_f32 6129 return vld3_f32(a); 6130 // CHECK: ld3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6131 // [{{x[0-9]+|sp}}] 6132 } 6133 6134 float64x1x3_t test_vld3_f64(float64_t const *a) { 6135 // CHECK: test_vld3_f64 6136 return vld3_f64(a); 6137 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6138 // [{{x[0-9]+|sp}}] 6139 } 6140 6141 poly8x8x3_t test_vld3_p8(poly8_t const *a) { 6142 // CHECK: test_vld3_p8 6143 return vld3_p8(a); 6144 // CHECK: ld3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6145 // [{{x[0-9]+|sp}}] 6146 } 6147 6148 poly16x4x3_t test_vld3_p16(poly16_t const *a) { 6149 // CHECK: test_vld3_p16 6150 return vld3_p16(a); 6151 // CHECK: ld3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6152 // [{{x[0-9]+|sp}}] 6153 } 6154 6155 uint8x16x4_t test_vld4q_u8(uint8_t const *a) { 6156 // CHECK: test_vld4q_u8 6157 return vld4q_u8(a); 6158 // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6159 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6160 } 6161 6162 uint16x8x4_t test_vld4q_u16(uint16_t const *a) { 6163 // CHECK: test_vld4q_u16 6164 return vld4q_u16(a); 6165 // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6166 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6167 } 6168 6169 uint32x4x4_t test_vld4q_u32(uint32_t const *a) { 6170 // CHECK: test_vld4q_u32 6171 return vld4q_u32(a); 6172 // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6173 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6174 } 6175 6176 uint64x2x4_t test_vld4q_u64(uint64_t const *a) { 6177 // CHECK: test_vld4q_u64 6178 return vld4q_u64(a); 6179 // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6180 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6181 } 6182 6183 int8x16x4_t test_vld4q_s8(int8_t const *a) { 6184 // CHECK: test_vld4q_s8 6185 return vld4q_s8(a); 6186 // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6187 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6188 } 6189 6190 int16x8x4_t test_vld4q_s16(int16_t const *a) { 6191 // CHECK: test_vld4q_s16 6192 return vld4q_s16(a); 6193 // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6194 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6195 } 6196 6197 int32x4x4_t test_vld4q_s32(int32_t const *a) { 6198 // CHECK: test_vld4q_s32 6199 return vld4q_s32(a); 6200 // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6201 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6202 } 6203 6204 int64x2x4_t test_vld4q_s64(int64_t const *a) { 6205 // CHECK: test_vld4q_s64 6206 return vld4q_s64(a); 6207 // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6208 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6209 } 6210 6211 float16x8x4_t test_vld4q_f16(float16_t const *a) { 6212 // CHECK: test_vld4q_f16 6213 return vld4q_f16(a); 6214 // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6215 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6216 } 6217 6218 float32x4x4_t test_vld4q_f32(float32_t const *a) { 6219 // CHECK: test_vld4q_f32 6220 return vld4q_f32(a); 6221 // CHECK: ld4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6222 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6223 } 6224 6225 float64x2x4_t test_vld4q_f64(float64_t const *a) { 6226 // CHECK: test_vld4q_f64 6227 return vld4q_f64(a); 6228 // CHECK: ld4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6229 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6230 } 6231 6232 poly8x16x4_t test_vld4q_p8(poly8_t const *a) { 6233 // CHECK: test_vld4q_p8 6234 return vld4q_p8(a); 6235 // CHECK: ld4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6236 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6237 } 6238 6239 poly16x8x4_t test_vld4q_p16(poly16_t const *a) { 6240 // CHECK: test_vld4q_p16 6241 return vld4q_p16(a); 6242 // CHECK: ld4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6243 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6244 } 6245 6246 uint8x8x4_t test_vld4_u8(uint8_t const *a) { 6247 // CHECK: test_vld4_u8 6248 return vld4_u8(a); 6249 // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 6250 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6251 } 6252 6253 uint16x4x4_t test_vld4_u16(uint16_t const *a) { 6254 // CHECK: test_vld4_u16 6255 return vld4_u16(a); 6256 // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6257 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6258 } 6259 6260 uint32x2x4_t test_vld4_u32(uint32_t const *a) { 6261 // CHECK: test_vld4_u32 6262 return vld4_u32(a); 6263 // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6264 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6265 } 6266 6267 uint64x1x4_t test_vld4_u64(uint64_t const *a) { 6268 // CHECK: test_vld4_u64 6269 return vld4_u64(a); 6270 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6271 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6272 } 6273 6274 int8x8x4_t test_vld4_s8(int8_t const *a) { 6275 // CHECK: test_vld4_s8 6276 return vld4_s8(a); 6277 // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 6278 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6279 } 6280 6281 int16x4x4_t test_vld4_s16(int16_t const *a) { 6282 // CHECK: test_vld4_s16 6283 return vld4_s16(a); 6284 // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6285 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6286 } 6287 6288 int32x2x4_t test_vld4_s32(int32_t const *a) { 6289 // CHECK: test_vld4_s32 6290 return vld4_s32(a); 6291 // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6292 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6293 } 6294 6295 int64x1x4_t test_vld4_s64(int64_t const *a) { 6296 // CHECK: test_vld4_s64 6297 return vld4_s64(a); 6298 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6299 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6300 } 6301 6302 float16x4x4_t test_vld4_f16(float16_t const *a) { 6303 // CHECK: test_vld4_f16 6304 return vld4_f16(a); 6305 // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6306 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6307 } 6308 6309 float32x2x4_t test_vld4_f32(float32_t const *a) { 6310 // CHECK: test_vld4_f32 6311 return vld4_f32(a); 6312 // CHECK: ld4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6313 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6314 } 6315 6316 float64x1x4_t test_vld4_f64(float64_t const *a) { 6317 // CHECK: test_vld4_f64 6318 return vld4_f64(a); 6319 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6320 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6321 } 6322 6323 poly8x8x4_t test_vld4_p8(poly8_t const *a) { 6324 // CHECK: test_vld4_p8 6325 return vld4_p8(a); 6326 // CHECK: ld4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 6327 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6328 } 6329 6330 poly16x4x4_t test_vld4_p16(poly16_t const *a) { 6331 // CHECK: test_vld4_p16 6332 return vld4_p16(a); 6333 // CHECK: ld4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6334 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6335 } 6336 6337 void test_vst1q_u8(uint8_t *a, uint8x16_t b) { 6338 // CHECK: test_vst1q_u8 6339 vst1q_u8(a, b); 6340 // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6341 } 6342 6343 void test_vst1q_u16(uint16_t *a, uint16x8_t b) { 6344 // CHECK: test_vst1q_u16 6345 vst1q_u16(a, b); 6346 // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6347 } 6348 6349 void test_vst1q_u32(uint32_t *a, uint32x4_t b) { 6350 // CHECK: test_vst1q_u32 6351 vst1q_u32(a, b); 6352 // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6353 } 6354 6355 void test_vst1q_u64(uint64_t *a, uint64x2_t b) { 6356 // CHECK: test_vst1q_u64 6357 vst1q_u64(a, b); 6358 // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6359 } 6360 6361 void test_vst1q_s8(int8_t *a, int8x16_t b) { 6362 // CHECK: test_vst1q_s8 6363 vst1q_s8(a, b); 6364 // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6365 } 6366 6367 void test_vst1q_s16(int16_t *a, int16x8_t b) { 6368 // CHECK: test_vst1q_s16 6369 vst1q_s16(a, b); 6370 // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6371 } 6372 6373 void test_vst1q_s32(int32_t *a, int32x4_t b) { 6374 // CHECK: test_vst1q_s32 6375 vst1q_s32(a, b); 6376 // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6377 } 6378 6379 void test_vst1q_s64(int64_t *a, int64x2_t b) { 6380 // CHECK: test_vst1q_s64 6381 vst1q_s64(a, b); 6382 // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6383 } 6384 6385 void test_vst1q_f16(float16_t *a, float16x8_t b) { 6386 // CHECK: test_vst1q_f16 6387 vst1q_f16(a, b); 6388 // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6389 } 6390 6391 void test_vst1q_f32(float32_t *a, float32x4_t b) { 6392 // CHECK: test_vst1q_f32 6393 vst1q_f32(a, b); 6394 // CHECK: st1 {v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6395 } 6396 6397 void test_vst1q_f64(float64_t *a, float64x2_t b) { 6398 // CHECK: test_vst1q_f64 6399 vst1q_f64(a, b); 6400 // CHECK: st1 {v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6401 } 6402 6403 void test_vst1q_p8(poly8_t *a, poly8x16_t b) { 6404 // CHECK: test_vst1q_p8 6405 vst1q_p8(a, b); 6406 // CHECK: st1 {v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6407 } 6408 6409 void test_vst1q_p16(poly16_t *a, poly16x8_t b) { 6410 // CHECK: test_vst1q_p16 6411 vst1q_p16(a, b); 6412 // CHECK: st1 {v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6413 } 6414 6415 void test_vst1_u8(uint8_t *a, uint8x8_t b) { 6416 // CHECK: test_vst1_u8 6417 vst1_u8(a, b); 6418 // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6419 } 6420 6421 void test_vst1_u16(uint16_t *a, uint16x4_t b) { 6422 // CHECK: test_vst1_u16 6423 vst1_u16(a, b); 6424 // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6425 } 6426 6427 void test_vst1_u32(uint32_t *a, uint32x2_t b) { 6428 // CHECK: test_vst1_u32 6429 vst1_u32(a, b); 6430 // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6431 } 6432 6433 void test_vst1_u64(uint64_t *a, uint64x1_t b) { 6434 // CHECK: test_vst1_u64 6435 vst1_u64(a, b); 6436 // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6437 } 6438 6439 void test_vst1_s8(int8_t *a, int8x8_t b) { 6440 // CHECK: test_vst1_s8 6441 vst1_s8(a, b); 6442 // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6443 } 6444 6445 void test_vst1_s16(int16_t *a, int16x4_t b) { 6446 // CHECK: test_vst1_s16 6447 vst1_s16(a, b); 6448 // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6449 } 6450 6451 void test_vst1_s32(int32_t *a, int32x2_t b) { 6452 // CHECK: test_vst1_s32 6453 vst1_s32(a, b); 6454 // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6455 } 6456 6457 void test_vst1_s64(int64_t *a, int64x1_t b) { 6458 // CHECK: test_vst1_s64 6459 vst1_s64(a, b); 6460 // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6461 } 6462 6463 void test_vst1_f16(float16_t *a, float16x4_t b) { 6464 // CHECK: test_vst1_f16 6465 vst1_f16(a, b); 6466 // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6467 } 6468 6469 void test_vst1_f32(float32_t *a, float32x2_t b) { 6470 // CHECK: test_vst1_f32 6471 vst1_f32(a, b); 6472 // CHECK: st1 {v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6473 } 6474 6475 void test_vst1_f64(float64_t *a, float64x1_t b) { 6476 // CHECK: test_vst1_f64 6477 vst1_f64(a, b); 6478 // CHECK: st1 {v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6479 } 6480 6481 void test_vst1_p8(poly8_t *a, poly8x8_t b) { 6482 // CHECK: test_vst1_p8 6483 vst1_p8(a, b); 6484 // CHECK: st1 {v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6485 } 6486 6487 void test_vst1_p16(poly16_t *a, poly16x4_t b) { 6488 // CHECK: test_vst1_p16 6489 vst1_p16(a, b); 6490 // CHECK: st1 {v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6491 } 6492 6493 void test_vst2q_u8(uint8_t *a, uint8x16x2_t b) { 6494 // CHECK: test_vst2q_u8 6495 vst2q_u8(a, b); 6496 // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6497 } 6498 6499 void test_vst2q_u16(uint16_t *a, uint16x8x2_t b) { 6500 // CHECK: test_vst2q_u16 6501 vst2q_u16(a, b); 6502 // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6503 } 6504 6505 void test_vst2q_u32(uint32_t *a, uint32x4x2_t b) { 6506 // CHECK: test_vst2q_u32 6507 vst2q_u32(a, b); 6508 // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6509 } 6510 6511 void test_vst2q_u64(uint64_t *a, uint64x2x2_t b) { 6512 // CHECK: test_vst2q_u64 6513 vst2q_u64(a, b); 6514 // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6515 } 6516 6517 void test_vst2q_s8(int8_t *a, int8x16x2_t b) { 6518 // CHECK: test_vst2q_s8 6519 vst2q_s8(a, b); 6520 // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6521 } 6522 6523 void test_vst2q_s16(int16_t *a, int16x8x2_t b) { 6524 // CHECK: test_vst2q_s16 6525 vst2q_s16(a, b); 6526 // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6527 } 6528 6529 void test_vst2q_s32(int32_t *a, int32x4x2_t b) { 6530 // CHECK: test_vst2q_s32 6531 vst2q_s32(a, b); 6532 // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6533 } 6534 6535 void test_vst2q_s64(int64_t *a, int64x2x2_t b) { 6536 // CHECK: test_vst2q_s64 6537 vst2q_s64(a, b); 6538 // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6539 } 6540 6541 void test_vst2q_f16(float16_t *a, float16x8x2_t b) { 6542 // CHECK: test_vst2q_f16 6543 vst2q_f16(a, b); 6544 // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6545 } 6546 6547 void test_vst2q_f32(float32_t *a, float32x4x2_t b) { 6548 // CHECK: test_vst2q_f32 6549 vst2q_f32(a, b); 6550 // CHECK: st2 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6551 } 6552 6553 void test_vst2q_f64(float64_t *a, float64x2x2_t b) { 6554 // CHECK: test_vst2q_f64 6555 vst2q_f64(a, b); 6556 // CHECK: st2 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6557 } 6558 6559 void test_vst2q_p8(poly8_t *a, poly8x16x2_t b) { 6560 // CHECK: test_vst2q_p8 6561 vst2q_p8(a, b); 6562 // CHECK: st2 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6563 } 6564 6565 void test_vst2q_p16(poly16_t *a, poly16x8x2_t b) { 6566 // CHECK: test_vst2q_p16 6567 vst2q_p16(a, b); 6568 // CHECK: st2 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6569 } 6570 6571 void test_vst2_u8(uint8_t *a, uint8x8x2_t b) { 6572 // CHECK: test_vst2_u8 6573 vst2_u8(a, b); 6574 // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6575 } 6576 6577 void test_vst2_u16(uint16_t *a, uint16x4x2_t b) { 6578 // CHECK: test_vst2_u16 6579 vst2_u16(a, b); 6580 // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6581 } 6582 6583 void test_vst2_u32(uint32_t *a, uint32x2x2_t b) { 6584 // CHECK: test_vst2_u32 6585 vst2_u32(a, b); 6586 // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6587 } 6588 6589 void test_vst2_u64(uint64_t *a, uint64x1x2_t b) { 6590 // CHECK: test_vst2_u64 6591 vst2_u64(a, b); 6592 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6593 } 6594 6595 void test_vst2_s8(int8_t *a, int8x8x2_t b) { 6596 // CHECK: test_vst2_s8 6597 vst2_s8(a, b); 6598 // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6599 } 6600 6601 void test_vst2_s16(int16_t *a, int16x4x2_t b) { 6602 // CHECK: test_vst2_s16 6603 vst2_s16(a, b); 6604 // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6605 } 6606 6607 void test_vst2_s32(int32_t *a, int32x2x2_t b) { 6608 // CHECK: test_vst2_s32 6609 vst2_s32(a, b); 6610 // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6611 } 6612 6613 void test_vst2_s64(int64_t *a, int64x1x2_t b) { 6614 // CHECK: test_vst2_s64 6615 vst2_s64(a, b); 6616 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6617 } 6618 6619 void test_vst2_f16(float16_t *a, float16x4x2_t b) { 6620 // CHECK: test_vst2_f16 6621 vst2_f16(a, b); 6622 // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6623 } 6624 6625 void test_vst2_f32(float32_t *a, float32x2x2_t b) { 6626 // CHECK: test_vst2_f32 6627 vst2_f32(a, b); 6628 // CHECK: st2 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6629 } 6630 6631 void test_vst2_f64(float64_t *a, float64x1x2_t b) { 6632 // CHECK: test_vst2_f64 6633 vst2_f64(a, b); 6634 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6635 } 6636 6637 void test_vst2_p8(poly8_t *a, poly8x8x2_t b) { 6638 // CHECK: test_vst2_p8 6639 vst2_p8(a, b); 6640 // CHECK: st2 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6641 } 6642 6643 void test_vst2_p16(poly16_t *a, poly16x4x2_t b) { 6644 // CHECK: test_vst2_p16 6645 vst2_p16(a, b); 6646 // CHECK: st2 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6647 } 6648 6649 void test_vst3q_u8(uint8_t *a, uint8x16x3_t b) { 6650 // CHECK: test_vst3q_u8 6651 vst3q_u8(a, b); 6652 // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 6653 // [{{x[0-9]+|sp}}] 6654 } 6655 6656 void test_vst3q_u16(uint16_t *a, uint16x8x3_t b) { 6657 // CHECK: test_vst3q_u16 6658 vst3q_u16(a, b); 6659 // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6660 // [{{x[0-9]+|sp}}] 6661 } 6662 6663 void test_vst3q_u32(uint32_t *a, uint32x4x3_t b) { 6664 // CHECK: test_vst3q_u32 6665 vst3q_u32(a, b); 6666 // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 6667 // [{{x[0-9]+|sp}}] 6668 } 6669 6670 void test_vst3q_u64(uint64_t *a, uint64x2x3_t b) { 6671 // CHECK: test_vst3q_u64 6672 vst3q_u64(a, b); 6673 // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 6674 // [{{x[0-9]+|sp}}] 6675 } 6676 6677 void test_vst3q_s8(int8_t *a, int8x16x3_t b) { 6678 // CHECK: test_vst3q_s8 6679 vst3q_s8(a, b); 6680 // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 6681 // [{{x[0-9]+|sp}}] 6682 } 6683 6684 void test_vst3q_s16(int16_t *a, int16x8x3_t b) { 6685 // CHECK: test_vst3q_s16 6686 vst3q_s16(a, b); 6687 // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6688 // [{{x[0-9]+|sp}}] 6689 } 6690 6691 void test_vst3q_s32(int32_t *a, int32x4x3_t b) { 6692 // CHECK: test_vst3q_s32 6693 vst3q_s32(a, b); 6694 // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 6695 // [{{x[0-9]+|sp}}] 6696 } 6697 6698 void test_vst3q_s64(int64_t *a, int64x2x3_t b) { 6699 // CHECK: test_vst3q_s64 6700 vst3q_s64(a, b); 6701 // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 6702 // [{{x[0-9]+|sp}}] 6703 } 6704 6705 void test_vst3q_f16(float16_t *a, float16x8x3_t b) { 6706 // CHECK: test_vst3q_f16 6707 vst3q_f16(a, b); 6708 // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6709 // [{{x[0-9]+|sp}}] 6710 } 6711 6712 void test_vst3q_f32(float32_t *a, float32x4x3_t b) { 6713 // CHECK: test_vst3q_f32 6714 vst3q_f32(a, b); 6715 // CHECK: st3 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 6716 // [{{x[0-9]+|sp}}] 6717 } 6718 6719 void test_vst3q_f64(float64_t *a, float64x2x3_t b) { 6720 // CHECK: test_vst3q_f64 6721 vst3q_f64(a, b); 6722 // CHECK: st3 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 6723 // [{{x[0-9]+|sp}}] 6724 } 6725 6726 void test_vst3q_p8(poly8_t *a, poly8x16x3_t b) { 6727 // CHECK: test_vst3q_p8 6728 vst3q_p8(a, b); 6729 // CHECK: st3 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 6730 // [{{x[0-9]+|sp}}] 6731 } 6732 6733 void test_vst3q_p16(poly16_t *a, poly16x8x3_t b) { 6734 // CHECK: test_vst3q_p16 6735 vst3q_p16(a, b); 6736 // CHECK: st3 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 6737 // [{{x[0-9]+|sp}}] 6738 } 6739 6740 void test_vst3_u8(uint8_t *a, uint8x8x3_t b) { 6741 // CHECK: test_vst3_u8 6742 vst3_u8(a, b); 6743 // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6744 // [{{x[0-9]+|sp}}] 6745 } 6746 6747 void test_vst3_u16(uint16_t *a, uint16x4x3_t b) { 6748 // CHECK: test_vst3_u16 6749 vst3_u16(a, b); 6750 // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6751 // [{{x[0-9]+|sp}}] 6752 } 6753 6754 void test_vst3_u32(uint32_t *a, uint32x2x3_t b) { 6755 // CHECK: test_vst3_u32 6756 vst3_u32(a, b); 6757 // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6758 // [{{x[0-9]+|sp}}] 6759 } 6760 6761 void test_vst3_u64(uint64_t *a, uint64x1x3_t b) { 6762 // CHECK: test_vst3_u64 6763 vst3_u64(a, b); 6764 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6765 // [{{x[0-9]+|sp}}] 6766 } 6767 6768 void test_vst3_s8(int8_t *a, int8x8x3_t b) { 6769 // CHECK: test_vst3_s8 6770 vst3_s8(a, b); 6771 // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6772 // [{{x[0-9]+|sp}}] 6773 } 6774 6775 void test_vst3_s16(int16_t *a, int16x4x3_t b) { 6776 // CHECK: test_vst3_s16 6777 vst3_s16(a, b); 6778 // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6779 // [{{x[0-9]+|sp}}] 6780 } 6781 6782 void test_vst3_s32(int32_t *a, int32x2x3_t b) { 6783 // CHECK: test_vst3_s32 6784 vst3_s32(a, b); 6785 // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6786 // [{{x[0-9]+|sp}}] 6787 } 6788 6789 void test_vst3_s64(int64_t *a, int64x1x3_t b) { 6790 // CHECK: test_vst3_s64 6791 vst3_s64(a, b); 6792 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6793 // [{{x[0-9]+|sp}}] 6794 } 6795 6796 void test_vst3_f16(float16_t *a, float16x4x3_t b) { 6797 // CHECK: test_vst3_f16 6798 vst3_f16(a, b); 6799 // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6800 // [{{x[0-9]+|sp}}] 6801 } 6802 6803 void test_vst3_f32(float32_t *a, float32x2x3_t b) { 6804 // CHECK: test_vst3_f32 6805 vst3_f32(a, b); 6806 // CHECK: st3 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 6807 // [{{x[0-9]+|sp}}] 6808 } 6809 6810 void test_vst3_f64(float64_t *a, float64x1x3_t b) { 6811 // CHECK: test_vst3_f64 6812 vst3_f64(a, b); 6813 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 6814 // [{{x[0-9]+|sp}}] 6815 } 6816 6817 void test_vst3_p8(poly8_t *a, poly8x8x3_t b) { 6818 // CHECK: test_vst3_p8 6819 vst3_p8(a, b); 6820 // CHECK: st3 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 6821 // [{{x[0-9]+|sp}}] 6822 } 6823 6824 void test_vst3_p16(poly16_t *a, poly16x4x3_t b) { 6825 // CHECK: test_vst3_p16 6826 vst3_p16(a, b); 6827 // CHECK: st3 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 6828 // [{{x[0-9]+|sp}}] 6829 } 6830 6831 void test_vst4q_u8(uint8_t *a, uint8x16x4_t b) { 6832 // CHECK: test_vst4q_u8 6833 vst4q_u8(a, b); 6834 // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6835 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6836 } 6837 6838 void test_vst4q_u16(uint16_t *a, uint16x8x4_t b) { 6839 // CHECK: test_vst4q_u16 6840 vst4q_u16(a, b); 6841 // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6842 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6843 } 6844 6845 void test_vst4q_u32(uint32_t *a, uint32x4x4_t b) { 6846 // CHECK: test_vst4q_u32 6847 vst4q_u32(a, b); 6848 // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6849 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6850 } 6851 6852 void test_vst4q_u64(uint64_t *a, uint64x2x4_t b) { 6853 // CHECK: test_vst4q_u64 6854 vst4q_u64(a, b); 6855 // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6856 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6857 } 6858 6859 void test_vst4q_s8(int8_t *a, int8x16x4_t b) { 6860 // CHECK: test_vst4q_s8 6861 vst4q_s8(a, b); 6862 // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6863 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6864 } 6865 6866 void test_vst4q_s16(int16_t *a, int16x8x4_t b) { 6867 // CHECK: test_vst4q_s16 6868 vst4q_s16(a, b); 6869 // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6870 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6871 } 6872 6873 void test_vst4q_s32(int32_t *a, int32x4x4_t b) { 6874 // CHECK: test_vst4q_s32 6875 vst4q_s32(a, b); 6876 // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6877 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6878 } 6879 6880 void test_vst4q_s64(int64_t *a, int64x2x4_t b) { 6881 // CHECK: test_vst4q_s64 6882 vst4q_s64(a, b); 6883 // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6884 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6885 } 6886 6887 void test_vst4q_f16(float16_t *a, float16x8x4_t b) { 6888 // CHECK: test_vst4q_f16 6889 vst4q_f16(a, b); 6890 // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6891 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6892 } 6893 6894 void test_vst4q_f32(float32_t *a, float32x4x4_t b) { 6895 // CHECK: test_vst4q_f32 6896 vst4q_f32(a, b); 6897 // CHECK: st4 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 6898 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 6899 } 6900 6901 void test_vst4q_f64(float64_t *a, float64x2x4_t b) { 6902 // CHECK: test_vst4q_f64 6903 vst4q_f64(a, b); 6904 // CHECK: st4 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 6905 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 6906 } 6907 6908 void test_vst4q_p8(poly8_t *a, poly8x16x4_t b) { 6909 // CHECK: test_vst4q_p8 6910 vst4q_p8(a, b); 6911 // CHECK: st4 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 6912 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 6913 } 6914 6915 void test_vst4q_p16(poly16_t *a, poly16x8x4_t b) { 6916 // CHECK: test_vst4q_p16 6917 vst4q_p16(a, b); 6918 // CHECK: st4 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 6919 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 6920 } 6921 6922 void test_vst4_u8(uint8_t *a, uint8x8x4_t b) { 6923 // CHECK: test_vst4_u8 6924 vst4_u8(a, b); 6925 // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 6926 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6927 } 6928 6929 void test_vst4_u16(uint16_t *a, uint16x4x4_t b) { 6930 // CHECK: test_vst4_u16 6931 vst4_u16(a, b); 6932 // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6933 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6934 } 6935 6936 void test_vst4_u32(uint32_t *a, uint32x2x4_t b) { 6937 // CHECK: test_vst4_u32 6938 vst4_u32(a, b); 6939 // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6940 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6941 } 6942 6943 void test_vst4_u64(uint64_t *a, uint64x1x4_t b) { 6944 // CHECK: test_vst4_u64 6945 vst4_u64(a, b); 6946 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6947 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6948 } 6949 6950 void test_vst4_s8(int8_t *a, int8x8x4_t b) { 6951 // CHECK: test_vst4_s8 6952 vst4_s8(a, b); 6953 // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 6954 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 6955 } 6956 6957 void test_vst4_s16(int16_t *a, int16x4x4_t b) { 6958 // CHECK: test_vst4_s16 6959 vst4_s16(a, b); 6960 // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6961 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6962 } 6963 6964 void test_vst4_s32(int32_t *a, int32x2x4_t b) { 6965 // CHECK: test_vst4_s32 6966 vst4_s32(a, b); 6967 // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6968 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6969 } 6970 6971 void test_vst4_s64(int64_t *a, int64x1x4_t b) { 6972 // CHECK: test_vst4_s64 6973 vst4_s64(a, b); 6974 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6975 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6976 } 6977 6978 void test_vst4_f16(float16_t *a, float16x4x4_t b) { 6979 // CHECK: test_vst4_f16 6980 vst4_f16(a, b); 6981 // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 6982 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 6983 } 6984 6985 void test_vst4_f32(float32_t *a, float32x2x4_t b) { 6986 // CHECK: test_vst4_f32 6987 vst4_f32(a, b); 6988 // CHECK: st4 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 6989 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 6990 } 6991 6992 void test_vst4_f64(float64_t *a, float64x1x4_t b) { 6993 // CHECK: test_vst4_f64 6994 vst4_f64(a, b); 6995 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 6996 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 6997 } 6998 6999 void test_vst4_p8(poly8_t *a, poly8x8x4_t b) { 7000 // CHECK: test_vst4_p8 7001 vst4_p8(a, b); 7002 // CHECK: st4 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 7003 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7004 } 7005 7006 void test_vst4_p16(poly16_t *a, poly16x4x4_t b) { 7007 // CHECK: test_vst4_p16 7008 vst4_p16(a, b); 7009 // CHECK: st4 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 7010 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7011 } 7012 7013 uint8x16x2_t test_vld1q_u8_x2(uint8_t const *a) { 7014 // CHECK-LABEL: test_vld1q_u8_x2 7015 return vld1q_u8_x2(a); 7016 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7017 } 7018 7019 uint16x8x2_t test_vld1q_u16_x2(uint16_t const *a) { 7020 // CHECK-LABEL: test_vld1q_u16_x2 7021 return vld1q_u16_x2(a); 7022 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7023 } 7024 7025 uint32x4x2_t test_vld1q_u32_x2(uint32_t const *a) { 7026 // CHECK-LABEL: test_vld1q_u32_x2 7027 return vld1q_u32_x2(a); 7028 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7029 } 7030 7031 uint64x2x2_t test_vld1q_u64_x2(uint64_t const *a) { 7032 // CHECK-LABEL: test_vld1q_u64_x2 7033 return vld1q_u64_x2(a); 7034 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7035 } 7036 7037 int8x16x2_t test_vld1q_s8_x2(int8_t const *a) { 7038 // CHECK-LABEL: test_vld1q_s8_x2 7039 return vld1q_s8_x2(a); 7040 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7041 } 7042 7043 int16x8x2_t test_vld1q_s16_x2(int16_t const *a) { 7044 // CHECK-LABEL: test_vld1q_s16_x2 7045 return vld1q_s16_x2(a); 7046 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7047 } 7048 7049 int32x4x2_t test_vld1q_s32_x2(int32_t const *a) { 7050 // CHECK-LABEL: test_vld1q_s32_x2 7051 return vld1q_s32_x2(a); 7052 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7053 } 7054 7055 int64x2x2_t test_vld1q_s64_x2(int64_t const *a) { 7056 // CHECK-LABEL: test_vld1q_s64_x2 7057 return vld1q_s64_x2(a); 7058 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7059 } 7060 7061 float16x8x2_t test_vld1q_f16_x2(float16_t const *a) { 7062 // CHECK-LABEL: test_vld1q_f16_x2 7063 return vld1q_f16_x2(a); 7064 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7065 } 7066 7067 float32x4x2_t test_vld1q_f32_x2(float32_t const *a) { 7068 // CHECK-LABEL: test_vld1q_f32_x2 7069 return vld1q_f32_x2(a); 7070 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7071 } 7072 7073 float64x2x2_t test_vld1q_f64_x2(float64_t const *a) { 7074 // CHECK-LABEL: test_vld1q_f64_x2 7075 return vld1q_f64_x2(a); 7076 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7077 } 7078 7079 poly8x16x2_t test_vld1q_p8_x2(poly8_t const *a) { 7080 // CHECK-LABEL: test_vld1q_p8_x2 7081 return vld1q_p8_x2(a); 7082 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7083 } 7084 7085 poly16x8x2_t test_vld1q_p16_x2(poly16_t const *a) { 7086 // CHECK-LABEL: test_vld1q_p16_x2 7087 return vld1q_p16_x2(a); 7088 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7089 } 7090 7091 poly64x2x2_t test_vld1q_p64_x2(poly64_t const *a) { 7092 // CHECK-LABEL: test_vld1q_p64_x2 7093 return vld1q_p64_x2(a); 7094 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7095 } 7096 7097 uint8x8x2_t test_vld1_u8_x2(uint8_t const *a) { 7098 // CHECK-LABEL: test_vld1_u8_x2 7099 return vld1_u8_x2(a); 7100 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7101 } 7102 7103 uint16x4x2_t test_vld1_u16_x2(uint16_t const *a) { 7104 // CHECK-LABEL: test_vld1_u16_x2 7105 return vld1_u16_x2(a); 7106 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7107 } 7108 7109 uint32x2x2_t test_vld1_u32_x2(uint32_t const *a) { 7110 // CHECK-LABEL: test_vld1_u32_x2 7111 return vld1_u32_x2(a); 7112 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7113 } 7114 7115 uint64x1x2_t test_vld1_u64_x2(uint64_t const *a) { 7116 // CHECK-LABEL: test_vld1_u64_x2 7117 return vld1_u64_x2(a); 7118 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7119 } 7120 7121 int8x8x2_t test_vld1_s8_x2(int8_t const *a) { 7122 // CHECK-LABEL: test_vld1_s8_x2 7123 return vld1_s8_x2(a); 7124 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7125 } 7126 7127 int16x4x2_t test_vld1_s16_x2(int16_t const *a) { 7128 // CHECK-LABEL: test_vld1_s16_x2 7129 return vld1_s16_x2(a); 7130 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7131 } 7132 7133 int32x2x2_t test_vld1_s32_x2(int32_t const *a) { 7134 // CHECK-LABEL: test_vld1_s32_x2 7135 return vld1_s32_x2(a); 7136 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7137 } 7138 7139 int64x1x2_t test_vld1_s64_x2(int64_t const *a) { 7140 // CHECK-LABEL: test_vld1_s64_x2 7141 return vld1_s64_x2(a); 7142 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7143 } 7144 7145 float16x4x2_t test_vld1_f16_x2(float16_t const *a) { 7146 // CHECK-LABEL: test_vld1_f16_x2 7147 return vld1_f16_x2(a); 7148 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7149 } 7150 7151 float32x2x2_t test_vld1_f32_x2(float32_t const *a) { 7152 // CHECK-LABEL: test_vld1_f32_x2 7153 return vld1_f32_x2(a); 7154 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7155 } 7156 7157 float64x1x2_t test_vld1_f64_x2(float64_t const *a) { 7158 // CHECK-LABEL: test_vld1_f64_x2 7159 return vld1_f64_x2(a); 7160 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7161 } 7162 7163 poly8x8x2_t test_vld1_p8_x2(poly8_t const *a) { 7164 // CHECK-LABEL: test_vld1_p8_x2 7165 return vld1_p8_x2(a); 7166 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7167 } 7168 7169 poly16x4x2_t test_vld1_p16_x2(poly16_t const *a) { 7170 // CHECK-LABEL: test_vld1_p16_x2 7171 return vld1_p16_x2(a); 7172 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7173 } 7174 7175 poly64x1x2_t test_vld1_p64_x2(poly64_t const *a) { 7176 // CHECK-LABEL: test_vld1_p64_x2 7177 return vld1_p64_x2(a); 7178 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7179 } 7180 7181 uint8x16x3_t test_vld1q_u8_x3(uint8_t const *a) { 7182 // CHECK-LABEL: test_vld1q_u8_x3 7183 return vld1q_u8_x3(a); 7184 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7185 // [{{x[0-9]+|sp}}] 7186 } 7187 7188 uint16x8x3_t test_vld1q_u16_x3(uint16_t const *a) { 7189 // CHECK-LABEL: test_vld1q_u16_x3 7190 return vld1q_u16_x3(a); 7191 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7192 // [{{x[0-9]+|sp}}] 7193 } 7194 7195 uint32x4x3_t test_vld1q_u32_x3(uint32_t const *a) { 7196 // CHECK-LABEL: test_vld1q_u32_x3 7197 return vld1q_u32_x3(a); 7198 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7199 // [{{x[0-9]+|sp}}] 7200 } 7201 7202 uint64x2x3_t test_vld1q_u64_x3(uint64_t const *a) { 7203 // CHECK-LABEL: test_vld1q_u64_x3 7204 return vld1q_u64_x3(a); 7205 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7206 // [{{x[0-9]+|sp}}] 7207 } 7208 7209 int8x16x3_t test_vld1q_s8_x3(int8_t const *a) { 7210 // CHECK-LABEL: test_vld1q_s8_x3 7211 return vld1q_s8_x3(a); 7212 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7213 // [{{x[0-9]+|sp}}] 7214 } 7215 7216 int16x8x3_t test_vld1q_s16_x3(int16_t const *a) { 7217 // CHECK-LABEL: test_vld1q_s16_x3 7218 return vld1q_s16_x3(a); 7219 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7220 // [{{x[0-9]+|sp}}] 7221 } 7222 7223 int32x4x3_t test_vld1q_s32_x3(int32_t const *a) { 7224 // CHECK-LABEL: test_vld1q_s32_x3 7225 return vld1q_s32_x3(a); 7226 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7227 // [{{x[0-9]+|sp}}] 7228 } 7229 7230 int64x2x3_t test_vld1q_s64_x3(int64_t const *a) { 7231 // CHECK-LABEL: test_vld1q_s64_x3 7232 return vld1q_s64_x3(a); 7233 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7234 // [{{x[0-9]+|sp}}] 7235 } 7236 7237 float16x8x3_t test_vld1q_f16_x3(float16_t const *a) { 7238 // CHECK-LABEL: test_vld1q_f16_x3 7239 return vld1q_f16_x3(a); 7240 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7241 // [{{x[0-9]+|sp}}] 7242 } 7243 7244 float32x4x3_t test_vld1q_f32_x3(float32_t const *a) { 7245 // CHECK-LABEL: test_vld1q_f32_x3 7246 return vld1q_f32_x3(a); 7247 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7248 // [{{x[0-9]+|sp}}] 7249 } 7250 7251 float64x2x3_t test_vld1q_f64_x3(float64_t const *a) { 7252 // CHECK-LABEL: test_vld1q_f64_x3 7253 return vld1q_f64_x3(a); 7254 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7255 // [{{x[0-9]+|sp}}] 7256 } 7257 7258 poly8x16x3_t test_vld1q_p8_x3(poly8_t const *a) { 7259 // CHECK-LABEL: test_vld1q_p8_x3 7260 return vld1q_p8_x3(a); 7261 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7262 // [{{x[0-9]+|sp}}] 7263 } 7264 7265 poly16x8x3_t test_vld1q_p16_x3(poly16_t const *a) { 7266 // CHECK-LABEL: test_vld1q_p16_x3 7267 return vld1q_p16_x3(a); 7268 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7269 // [{{x[0-9]+|sp}}] 7270 } 7271 7272 poly64x2x3_t test_vld1q_p64_x3(poly64_t const *a) { 7273 // CHECK-LABEL: test_vld1q_p64_x3 7274 return vld1q_p64_x3(a); 7275 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7276 // [{{x[0-9]+|sp}}] 7277 } 7278 7279 uint8x8x3_t test_vld1_u8_x3(uint8_t const *a) { 7280 // CHECK-LABEL: test_vld1_u8_x3 7281 return vld1_u8_x3(a); 7282 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7283 // [{{x[0-9]+|sp}}] 7284 } 7285 7286 uint16x4x3_t test_vld1_u16_x3(uint16_t const *a) { 7287 // CHECK-LABEL: test_vld1_u16_x3 7288 return vld1_u16_x3(a); 7289 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7290 // [{{x[0-9]+|sp}}] 7291 } 7292 7293 uint32x2x3_t test_vld1_u32_x3(uint32_t const *a) { 7294 // CHECK-LABEL: test_vld1_u32_x3 7295 return vld1_u32_x3(a); 7296 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7297 // [{{x[0-9]+|sp}}] 7298 } 7299 7300 uint64x1x3_t test_vld1_u64_x3(uint64_t const *a) { 7301 // CHECK-LABEL: test_vld1_u64_x3 7302 return vld1_u64_x3(a); 7303 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7304 // [{{x[0-9]+|sp}}] 7305 } 7306 7307 int8x8x3_t test_vld1_s8_x3(int8_t const *a) { 7308 // CHECK-LABEL: test_vld1_s8_x3 7309 return vld1_s8_x3(a); 7310 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7311 // [{{x[0-9]+|sp}}] 7312 } 7313 7314 int16x4x3_t test_vld1_s16_x3(int16_t const *a) { 7315 // CHECK-LABEL: test_vld1_s16_x3 7316 return vld1_s16_x3(a); 7317 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7318 // [{{x[0-9]+|sp}}] 7319 } 7320 7321 int32x2x3_t test_vld1_s32_x3(int32_t const *a) { 7322 // CHECK-LABEL: test_vld1_s32_x3 7323 return vld1_s32_x3(a); 7324 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7325 // [{{x[0-9]+|sp}}] 7326 } 7327 7328 int64x1x3_t test_vld1_s64_x3(int64_t const *a) { 7329 // CHECK-LABEL: test_vld1_s64_x3 7330 return vld1_s64_x3(a); 7331 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7332 // [{{x[0-9]+|sp}}] 7333 } 7334 7335 float16x4x3_t test_vld1_f16_x3(float16_t const *a) { 7336 // CHECK-LABEL: test_vld1_f16_x3 7337 return vld1_f16_x3(a); 7338 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7339 // [{{x[0-9]+|sp}}] 7340 } 7341 7342 float32x2x3_t test_vld1_f32_x3(float32_t const *a) { 7343 // CHECK-LABEL: test_vld1_f32_x3 7344 return vld1_f32_x3(a); 7345 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7346 // [{{x[0-9]+|sp}}] 7347 } 7348 7349 float64x1x3_t test_vld1_f64_x3(float64_t const *a) { 7350 // CHECK-LABEL: test_vld1_f64_x3 7351 return vld1_f64_x3(a); 7352 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7353 // [{{x[0-9]+|sp}}] 7354 } 7355 7356 poly8x8x3_t test_vld1_p8_x3(poly8_t const *a) { 7357 // CHECK-LABEL: test_vld1_p8_x3 7358 return vld1_p8_x3(a); 7359 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7360 // [{{x[0-9]+|sp}}] 7361 } 7362 7363 poly16x4x3_t test_vld1_p16_x3(poly16_t const *a) { 7364 // CHECK-LABEL: test_vld1_p16_x3 7365 return vld1_p16_x3(a); 7366 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7367 // [{{x[0-9]+|sp}}] 7368 } 7369 7370 poly64x1x3_t test_vld1_p64_x3(poly64_t const *a) { 7371 // CHECK-LABEL: test_vld1_p64_x3 7372 return vld1_p64_x3(a); 7373 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7374 // [{{x[0-9]+|sp}}] 7375 } 7376 7377 uint8x16x4_t test_vld1q_u8_x4(uint8_t const *a) { 7378 // CHECK-LABEL: test_vld1q_u8_x4 7379 return vld1q_u8_x4(a); 7380 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 7381 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7382 } 7383 7384 uint16x8x4_t test_vld1q_u16_x4(uint16_t const *a) { 7385 // CHECK-LABEL: test_vld1q_u16_x4 7386 return vld1q_u16_x4(a); 7387 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7388 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7389 } 7390 7391 uint32x4x4_t test_vld1q_u32_x4(uint32_t const *a) { 7392 // CHECK-LABEL: test_vld1q_u32_x4 7393 return vld1q_u32_x4(a); 7394 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 7395 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7396 } 7397 7398 uint64x2x4_t test_vld1q_u64_x4(uint64_t const *a) { 7399 // CHECK-LABEL: test_vld1q_u64_x4 7400 return vld1q_u64_x4(a); 7401 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7402 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7403 } 7404 7405 int8x16x4_t test_vld1q_s8_x4(int8_t const *a) { 7406 // CHECK-LABEL: test_vld1q_s8_x4 7407 return vld1q_s8_x4(a); 7408 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 7409 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7410 } 7411 7412 int16x8x4_t test_vld1q_s16_x4(int16_t const *a) { 7413 // CHECK-LABEL: test_vld1q_s16_x4 7414 return vld1q_s16_x4(a); 7415 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7416 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7417 } 7418 7419 int32x4x4_t test_vld1q_s32_x4(int32_t const *a) { 7420 // CHECK-LABEL: test_vld1q_s32_x4 7421 return vld1q_s32_x4(a); 7422 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 7423 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7424 } 7425 7426 int64x2x4_t test_vld1q_s64_x4(int64_t const *a) { 7427 // CHECK-LABEL: test_vld1q_s64_x4 7428 return vld1q_s64_x4(a); 7429 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7430 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7431 } 7432 7433 float16x8x4_t test_vld1q_f16_x4(float16_t const *a) { 7434 // CHECK-LABEL: test_vld1q_f16_x4 7435 return vld1q_f16_x4(a); 7436 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7437 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7438 } 7439 7440 float32x4x4_t test_vld1q_f32_x4(float32_t const *a) { 7441 // CHECK-LABEL: test_vld1q_f32_x4 7442 return vld1q_f32_x4(a); 7443 // CHECK: ld1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 7444 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7445 } 7446 7447 float64x2x4_t test_vld1q_f64_x4(float64_t const *a) { 7448 // CHECK-LABEL: test_vld1q_f64_x4 7449 return vld1q_f64_x4(a); 7450 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7451 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7452 } 7453 7454 poly8x16x4_t test_vld1q_p8_x4(poly8_t const *a) { 7455 // CHECK-LABEL: test_vld1q_p8_x4 7456 return vld1q_p8_x4(a); 7457 // CHECK: ld1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 7458 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7459 } 7460 7461 poly16x8x4_t test_vld1q_p16_x4(poly16_t const *a) { 7462 // CHECK-LABEL: test_vld1q_p16_x4 7463 return vld1q_p16_x4(a); 7464 // CHECK: ld1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7465 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7466 } 7467 7468 poly64x2x4_t test_vld1q_p64_x4(poly64_t const *a) { 7469 // CHECK-LABEL: test_vld1q_p64_x4 7470 return vld1q_p64_x4(a); 7471 // CHECK: ld1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7472 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7473 } 7474 7475 uint8x8x4_t test_vld1_u8_x4(uint8_t const *a) { 7476 // CHECK-LABEL: test_vld1_u8_x4 7477 return vld1_u8_x4(a); 7478 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 7479 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7480 } 7481 7482 uint16x4x4_t test_vld1_u16_x4(uint16_t const *a) { 7483 // CHECK-LABEL: test_vld1_u16_x4 7484 return vld1_u16_x4(a); 7485 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 7486 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7487 } 7488 7489 uint32x2x4_t test_vld1_u32_x4(uint32_t const *a) { 7490 // CHECK-LABEL: test_vld1_u32_x4 7491 return vld1_u32_x4(a); 7492 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 7493 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7494 } 7495 7496 uint64x1x4_t test_vld1_u64_x4(uint64_t const *a) { 7497 // CHECK-LABEL: test_vld1_u64_x4 7498 return vld1_u64_x4(a); 7499 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 7500 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7501 } 7502 7503 int8x8x4_t test_vld1_s8_x4(int8_t const *a) { 7504 // CHECK-LABEL: test_vld1_s8_x4 7505 return vld1_s8_x4(a); 7506 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 7507 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7508 } 7509 7510 int16x4x4_t test_vld1_s16_x4(int16_t const *a) { 7511 // CHECK-LABEL: test_vld1_s16_x4 7512 return vld1_s16_x4(a); 7513 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 7514 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7515 } 7516 7517 int32x2x4_t test_vld1_s32_x4(int32_t const *a) { 7518 // CHECK-LABEL: test_vld1_s32_x4 7519 return vld1_s32_x4(a); 7520 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 7521 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7522 } 7523 7524 int64x1x4_t test_vld1_s64_x4(int64_t const *a) { 7525 // CHECK-LABEL: test_vld1_s64_x4 7526 return vld1_s64_x4(a); 7527 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 7528 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7529 } 7530 7531 float16x4x4_t test_vld1_f16_x4(float16_t const *a) { 7532 // CHECK-LABEL: test_vld1_f16_x4 7533 return vld1_f16_x4(a); 7534 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 7535 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7536 } 7537 7538 float32x2x4_t test_vld1_f32_x4(float32_t const *a) { 7539 // CHECK-LABEL: test_vld1_f32_x4 7540 return vld1_f32_x4(a); 7541 // CHECK: ld1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 7542 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7543 } 7544 7545 float64x1x4_t test_vld1_f64_x4(float64_t const *a) { 7546 // CHECK-LABEL: test_vld1_f64_x4 7547 return vld1_f64_x4(a); 7548 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 7549 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7550 } 7551 7552 poly8x8x4_t test_vld1_p8_x4(poly8_t const *a) { 7553 // CHECK-LABEL: test_vld1_p8_x4 7554 return vld1_p8_x4(a); 7555 // CHECK: ld1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 7556 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7557 } 7558 7559 poly16x4x4_t test_vld1_p16_x4(poly16_t const *a) { 7560 // CHECK-LABEL: test_vld1_p16_x4 7561 return vld1_p16_x4(a); 7562 // CHECK: ld1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 7563 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7564 } 7565 7566 poly64x1x4_t test_vld1_p64_x4(poly64_t const *a) { 7567 // CHECK-LABEL: test_vld1_p64_x4 7568 return vld1_p64_x4(a); 7569 // CHECK: ld1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 7570 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7571 } 7572 7573 void test_vst1q_u8_x2(uint8_t *a, uint8x16x2_t b) { 7574 // CHECK: test_vst1q_u8_x2 7575 vst1q_u8_x2(a, b); 7576 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7577 } 7578 7579 void test_vst1q_u16_x2(uint16_t *a, uint16x8x2_t b) { 7580 // CHECK: test_vst1q_u16_x2 7581 vst1q_u16_x2(a, b); 7582 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7583 } 7584 7585 void test_vst1q_u32_x2(uint32_t *a, uint32x4x2_t b) { 7586 // CHECK: test_vst1q_u32_x2 7587 vst1q_u32_x2(a, b); 7588 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7589 } 7590 7591 void test_vst1q_u64_x2(uint64_t *a, uint64x2x2_t b) { 7592 // CHECK: test_vst1q_u64_x2 7593 vst1q_u64_x2(a, b); 7594 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7595 } 7596 7597 void test_vst1q_s8_x2(int8_t *a, int8x16x2_t b) { 7598 // CHECK: test_vst1q_s8_x2 7599 vst1q_s8_x2(a, b); 7600 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7601 } 7602 7603 void test_vst1q_s16_x2(int16_t *a, int16x8x2_t b) { 7604 // CHECK: test_vst1q_s16_x2 7605 vst1q_s16_x2(a, b); 7606 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7607 } 7608 7609 void test_vst1q_s32_x2(int32_t *a, int32x4x2_t b) { 7610 // CHECK: test_vst1q_s32_x2 7611 vst1q_s32_x2(a, b); 7612 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7613 } 7614 7615 void test_vst1q_s64_x2(int64_t *a, int64x2x2_t b) { 7616 // CHECK: test_vst1q_s64_x2 7617 vst1q_s64_x2(a, b); 7618 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7619 } 7620 7621 void test_vst1q_f16_x2(float16_t *a, float16x8x2_t b) { 7622 // CHECK: test_vst1q_f16_x2 7623 vst1q_f16_x2(a, b); 7624 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7625 } 7626 7627 void test_vst1q_f32_x2(float32_t *a, float32x4x2_t b) { 7628 // CHECK: test_vst1q_f32_x2 7629 vst1q_f32_x2(a, b); 7630 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7631 } 7632 7633 void test_vst1q_f64_x2(float64_t *a, float64x2x2_t b) { 7634 // CHECK: test_vst1q_f64_x2 7635 vst1q_f64_x2(a, b); 7636 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7637 } 7638 7639 void test_vst1q_p8_x2(poly8_t *a, poly8x16x2_t b) { 7640 // CHECK: test_vst1q_p8_x2 7641 vst1q_p8_x2(a, b); 7642 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7643 } 7644 7645 void test_vst1q_p16_x2(poly16_t *a, poly16x8x2_t b) { 7646 // CHECK: test_vst1q_p16_x2 7647 vst1q_p16_x2(a, b); 7648 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7649 } 7650 7651 void test_vst1q_p64_x2(poly64_t *a, poly64x2x2_t b) { 7652 // CHECK: test_vst1q_p64_x2 7653 vst1q_p64_x2(a, b); 7654 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7655 } 7656 7657 void test_vst1_u8_x2(uint8_t *a, uint8x8x2_t b) { 7658 // CHECK: test_vst1_u8_x2 7659 vst1_u8_x2(a, b); 7660 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7661 } 7662 7663 void test_vst1_u16_x2(uint16_t *a, uint16x4x2_t b) { 7664 // CHECK: test_vst1_u16_x2 7665 vst1_u16_x2(a, b); 7666 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7667 } 7668 7669 void test_vst1_u32_x2(uint32_t *a, uint32x2x2_t b) { 7670 // CHECK: test_vst1_u32_x2 7671 vst1_u32_x2(a, b); 7672 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7673 } 7674 7675 void test_vst1_u64_x2(uint64_t *a, uint64x1x2_t b) { 7676 // CHECK: test_vst1_u64_x2 7677 vst1_u64_x2(a, b); 7678 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7679 } 7680 7681 void test_vst1_s8_x2(int8_t *a, int8x8x2_t b) { 7682 // CHECK: test_vst1_s8_x2 7683 vst1_s8_x2(a, b); 7684 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7685 } 7686 7687 void test_vst1_s16_x2(int16_t *a, int16x4x2_t b) { 7688 // CHECK: test_vst1_s16_x2 7689 vst1_s16_x2(a, b); 7690 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7691 } 7692 7693 void test_vst1_s32_x2(int32_t *a, int32x2x2_t b) { 7694 // CHECK: test_vst1_s32_x2 7695 vst1_s32_x2(a, b); 7696 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7697 } 7698 7699 void test_vst1_s64_x2(int64_t *a, int64x1x2_t b) { 7700 // CHECK: test_vst1_s64_x2 7701 vst1_s64_x2(a, b); 7702 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7703 } 7704 7705 void test_vst1_f16_x2(float16_t *a, float16x4x2_t b) { 7706 // CHECK: test_vst1_f16_x2 7707 vst1_f16_x2(a, b); 7708 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7709 } 7710 7711 void test_vst1_f32_x2(float32_t *a, float32x2x2_t b) { 7712 // CHECK: test_vst1_f32_x2 7713 vst1_f32_x2(a, b); 7714 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 7715 } 7716 7717 void test_vst1_f64_x2(float64_t *a, float64x1x2_t b) { 7718 // CHECK: test_vst1_f64_x2 7719 vst1_f64_x2(a, b); 7720 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7721 } 7722 7723 void test_vst1_p8_x2(poly8_t *a, poly8x8x2_t b) { 7724 // CHECK: test_vst1_p8_x2 7725 vst1_p8_x2(a, b); 7726 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 7727 } 7728 7729 void test_vst1_p16_x2(poly16_t *a, poly16x4x2_t b) { 7730 // CHECK: test_vst1_p16_x2 7731 vst1_p16_x2(a, b); 7732 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 7733 } 7734 7735 void test_vst1_p64_x2(poly64_t *a, poly64x1x2_t b) { 7736 // CHECK: test_vst1_p64_x2 7737 vst1_p64_x2(a, b); 7738 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 7739 } 7740 7741 void test_vst1q_u8_x3(uint8_t *a, uint8x16x3_t b) { 7742 // CHECK: test_vst1q_u8_x3 7743 vst1q_u8_x3(a, b); 7744 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7745 // [{{x[0-9]+|sp}}] 7746 } 7747 7748 void test_vst1q_u16_x3(uint16_t *a, uint16x8x3_t b) { 7749 // CHECK: test_vst1q_u16_x3 7750 vst1q_u16_x3(a, b); 7751 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7752 // [{{x[0-9]+|sp}}] 7753 } 7754 7755 void test_vst1q_u32_x3(uint32_t *a, uint32x4x3_t b) { 7756 // CHECK: test_vst1q_u32_x3 7757 vst1q_u32_x3(a, b); 7758 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7759 // [{{x[0-9]+|sp}}] 7760 } 7761 7762 void test_vst1q_u64_x3(uint64_t *a, uint64x2x3_t b) { 7763 // CHECK: test_vst1q_u64_x3 7764 vst1q_u64_x3(a, b); 7765 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7766 // [{{x[0-9]+|sp}}] 7767 } 7768 7769 void test_vst1q_s8_x3(int8_t *a, int8x16x3_t b) { 7770 // CHECK: test_vst1q_s8_x3 7771 vst1q_s8_x3(a, b); 7772 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7773 // [{{x[0-9]+|sp}}] 7774 } 7775 7776 void test_vst1q_s16_x3(int16_t *a, int16x8x3_t b) { 7777 // CHECK: test_vst1q_s16_x3 7778 vst1q_s16_x3(a, b); 7779 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7780 // [{{x[0-9]+|sp}}] 7781 } 7782 7783 void test_vst1q_s32_x3(int32_t *a, int32x4x3_t b) { 7784 // CHECK: test_vst1q_s32_x3 7785 vst1q_s32_x3(a, b); 7786 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7787 // [{{x[0-9]+|sp}}] 7788 } 7789 7790 void test_vst1q_s64_x3(int64_t *a, int64x2x3_t b) { 7791 // CHECK: test_vst1q_s64_x3 7792 vst1q_s64_x3(a, b); 7793 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7794 // [{{x[0-9]+|sp}}] 7795 } 7796 7797 void test_vst1q_f16_x3(float16_t *a, float16x8x3_t b) { 7798 // CHECK: test_vst1q_f16_x3 7799 vst1q_f16_x3(a, b); 7800 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7801 // [{{x[0-9]+|sp}}] 7802 } 7803 7804 void test_vst1q_f32_x3(float32_t *a, float32x4x3_t b) { 7805 // CHECK: test_vst1q_f32_x3 7806 vst1q_f32_x3(a, b); 7807 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s}, 7808 // [{{x[0-9]+|sp}}] 7809 } 7810 7811 void test_vst1q_f64_x3(float64_t *a, float64x2x3_t b) { 7812 // CHECK: test_vst1q_f64_x3 7813 vst1q_f64_x3(a, b); 7814 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7815 // [{{x[0-9]+|sp}}] 7816 } 7817 7818 void test_vst1q_p8_x3(poly8_t *a, poly8x16x3_t b) { 7819 // CHECK: test_vst1q_p8_x3 7820 vst1q_p8_x3(a, b); 7821 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b}, 7822 // [{{x[0-9]+|sp}}] 7823 } 7824 7825 void test_vst1q_p16_x3(poly16_t *a, poly16x8x3_t b) { 7826 // CHECK: test_vst1q_p16_x3 7827 vst1q_p16_x3(a, b); 7828 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h}, 7829 // [{{x[0-9]+|sp}}] 7830 } 7831 7832 void test_vst1q_p64_x3(poly64_t *a, poly64x2x3_t b) { 7833 // CHECK: test_vst1q_p64_x3 7834 vst1q_p64_x3(a, b); 7835 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d}, 7836 // [{{x[0-9]+|sp}}] 7837 } 7838 7839 void test_vst1_u8_x3(uint8_t *a, uint8x8x3_t b) { 7840 // CHECK: test_vst1_u8_x3 7841 vst1_u8_x3(a, b); 7842 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7843 // [{{x[0-9]+|sp}}] 7844 } 7845 7846 void test_vst1_u16_x3(uint16_t *a, uint16x4x3_t b) { 7847 // CHECK: test_vst1_u16_x3 7848 vst1_u16_x3(a, b); 7849 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7850 // [{{x[0-9]+|sp}}] 7851 } 7852 7853 void test_vst1_u32_x3(uint32_t *a, uint32x2x3_t b) { 7854 // CHECK: test_vst1_u32_x3 7855 vst1_u32_x3(a, b); 7856 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7857 // [{{x[0-9]+|sp}}] 7858 } 7859 7860 void test_vst1_u64_x3(uint64_t *a, uint64x1x3_t b) { 7861 // CHECK: test_vst1_u64_x3 7862 vst1_u64_x3(a, b); 7863 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7864 // [{{x[0-9]+|sp}}] 7865 } 7866 7867 void test_vst1_s8_x3(int8_t *a, int8x8x3_t b) { 7868 // CHECK: test_vst1_s8_x3 7869 vst1_s8_x3(a, b); 7870 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7871 // [{{x[0-9]+|sp}}] 7872 } 7873 7874 void test_vst1_s16_x3(int16_t *a, int16x4x3_t b) { 7875 // CHECK: test_vst1_s16_x3 7876 vst1_s16_x3(a, b); 7877 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7878 // [{{x[0-9]+|sp}}] 7879 } 7880 7881 void test_vst1_s32_x3(int32_t *a, int32x2x3_t b) { 7882 // CHECK: test_vst1_s32_x3 7883 vst1_s32_x3(a, b); 7884 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7885 // [{{x[0-9]+|sp}}] 7886 } 7887 7888 void test_vst1_s64_x3(int64_t *a, int64x1x3_t b) { 7889 // CHECK: test_vst1_s64_x3 7890 vst1_s64_x3(a, b); 7891 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7892 // [{{x[0-9]+|sp}}] 7893 } 7894 7895 void test_vst1_f16_x3(float16_t *a, float16x4x3_t b) { 7896 // CHECK: test_vst1_f16_x3 7897 vst1_f16_x3(a, b); 7898 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7899 // [{{x[0-9]+|sp}}] 7900 } 7901 7902 void test_vst1_f32_x3(float32_t *a, float32x2x3_t b) { 7903 // CHECK: test_vst1_f32_x3 7904 vst1_f32_x3(a, b); 7905 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s}, 7906 // [{{x[0-9]+|sp}}] 7907 } 7908 7909 void test_vst1_f64_x3(float64_t *a, float64x1x3_t b) { 7910 // CHECK: test_vst1_f64_x3 7911 vst1_f64_x3(a, b); 7912 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7913 // [{{x[0-9]+|sp}}] 7914 } 7915 7916 void test_vst1_p8_x3(poly8_t *a, poly8x8x3_t b) { 7917 // CHECK: test_vst1_p8_x3 7918 vst1_p8_x3(a, b); 7919 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b}, 7920 // [{{x[0-9]+|sp}}] 7921 } 7922 7923 void test_vst1_p16_x3(poly16_t *a, poly16x4x3_t b) { 7924 // CHECK: test_vst1_p16_x3 7925 vst1_p16_x3(a, b); 7926 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h}, 7927 // [{{x[0-9]+|sp}}] 7928 } 7929 7930 void test_vst1_p64_x3(poly64_t *a, poly64x1x3_t b) { 7931 // CHECK: test_vst1_p64_x3 7932 vst1_p64_x3(a, b); 7933 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d}, 7934 // [{{x[0-9]+|sp}}] 7935 } 7936 7937 void test_vst1q_u8_x4(uint8_t *a, uint8x16x4_t b) { 7938 // CHECK: test_vst1q_u8_x4 7939 vst1q_u8_x4(a, b); 7940 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 7941 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7942 } 7943 7944 void test_vst1q_u16_x4(uint16_t *a, uint16x8x4_t b) { 7945 // CHECK: test_vst1q_u16_x4 7946 vst1q_u16_x4(a, b); 7947 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7948 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7949 } 7950 7951 void test_vst1q_u32_x4(uint32_t *a, uint32x4x4_t b) { 7952 // CHECK: test_vst1q_u32_x4 7953 vst1q_u32_x4(a, b); 7954 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 7955 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7956 } 7957 7958 void test_vst1q_u64_x4(uint64_t *a, uint64x2x4_t b) { 7959 // CHECK: test_vst1q_u64_x4 7960 vst1q_u64_x4(a, b); 7961 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7962 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7963 } 7964 7965 void test_vst1q_s8_x4(int8_t *a, int8x16x4_t b) { 7966 // CHECK: test_vst1q_s8_x4 7967 vst1q_s8_x4(a, b); 7968 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 7969 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 7970 } 7971 7972 void test_vst1q_s16_x4(int16_t *a, int16x8x4_t b) { 7973 // CHECK: test_vst1q_s16_x4 7974 vst1q_s16_x4(a, b); 7975 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7976 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7977 } 7978 7979 void test_vst1q_s32_x4(int32_t *a, int32x4x4_t b) { 7980 // CHECK: test_vst1q_s32_x4 7981 vst1q_s32_x4(a, b); 7982 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 7983 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 7984 } 7985 7986 void test_vst1q_s64_x4(int64_t *a, int64x2x4_t b) { 7987 // CHECK: test_vst1q_s64_x4 7988 vst1q_s64_x4(a, b); 7989 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 7990 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 7991 } 7992 7993 void test_vst1q_f16_x4(float16_t *a, float16x8x4_t b) { 7994 // CHECK: test_vst1q_f16_x4 7995 vst1q_f16_x4(a, b); 7996 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 7997 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 7998 } 7999 8000 void test_vst1q_f32_x4(float32_t *a, float32x4x4_t b) { 8001 // CHECK: test_vst1q_f32_x4 8002 vst1q_f32_x4(a, b); 8003 // CHECK: st1 {v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, v{{[0-9]+}}.4s, 8004 // v{{[0-9]+}}.4s}, [{{x[0-9]+|sp}}] 8005 } 8006 8007 void test_vst1q_f64_x4(float64_t *a, float64x2x4_t b) { 8008 // CHECK: test_vst1q_f64_x4 8009 vst1q_f64_x4(a, b); 8010 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 8011 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 8012 } 8013 8014 void test_vst1q_p8_x4(poly8_t *a, poly8x16x4_t b) { 8015 // CHECK: test_vst1q_p8_x4 8016 vst1q_p8_x4(a, b); 8017 // CHECK: st1 {v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, v{{[0-9]+}}.16b, 8018 // v{{[0-9]+}}.16b}, [{{x[0-9]+|sp}}] 8019 } 8020 8021 void test_vst1q_p16_x4(poly16_t *a, poly16x8x4_t b) { 8022 // CHECK: test_vst1q_p16_x4 8023 vst1q_p16_x4(a, b); 8024 // CHECK: st1 {v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, v{{[0-9]+}}.8h, 8025 // v{{[0-9]+}}.8h}, [{{x[0-9]+|sp}}] 8026 } 8027 8028 void test_vst1q_p64_x4(poly64_t *a, poly64x2x4_t b) { 8029 // CHECK: test_vst1q_p64_x4 8030 vst1q_p64_x4(a, b); 8031 // CHECK: st1 {v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, v{{[0-9]+}}.2d, 8032 // v{{[0-9]+}}.2d}, [{{x[0-9]+|sp}}] 8033 } 8034 8035 void test_vst1_u8_x4(uint8_t *a, uint8x8x4_t b) { 8036 // CHECK: test_vst1_u8_x4 8037 vst1_u8_x4(a, b); 8038 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 8039 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 8040 } 8041 8042 void test_vst1_u16_x4(uint16_t *a, uint16x4x4_t b) { 8043 // CHECK: test_vst1_u16_x4 8044 vst1_u16_x4(a, b); 8045 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 8046 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 8047 } 8048 8049 void test_vst1_u32_x4(uint32_t *a, uint32x2x4_t b) { 8050 // CHECK: test_vst1_u32_x4 8051 vst1_u32_x4(a, b); 8052 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 8053 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 8054 } 8055 8056 void test_vst1_u64_x4(uint64_t *a, uint64x1x4_t b) { 8057 // CHECK: test_vst1_u64_x4 8058 vst1_u64_x4(a, b); 8059 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 8060 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 8061 } 8062 8063 void test_vst1_s8_x4(int8_t *a, int8x8x4_t b) { 8064 // CHECK: test_vst1_s8_x4 8065 vst1_s8_x4(a, b); 8066 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 8067 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 8068 } 8069 8070 void test_vst1_s16_x4(int16_t *a, int16x4x4_t b) { 8071 // CHECK: test_vst1_s16_x4 8072 vst1_s16_x4(a, b); 8073 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 8074 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 8075 } 8076 8077 void test_vst1_s32_x4(int32_t *a, int32x2x4_t b) { 8078 // CHECK: test_vst1_s32_x4 8079 vst1_s32_x4(a, b); 8080 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 8081 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 8082 } 8083 8084 void test_vst1_s64_x4(int64_t *a, int64x1x4_t b) { 8085 // CHECK: test_vst1_s64_x4 8086 vst1_s64_x4(a, b); 8087 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 8088 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 8089 } 8090 8091 void test_vst1_f16_x4(float16_t *a, float16x4x4_t b) { 8092 // CHECK: test_vst1_f16_x4 8093 vst1_f16_x4(a, b); 8094 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 8095 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 8096 } 8097 8098 void test_vst1_f32_x4(float32_t *a, float32x2x4_t b) { 8099 // CHECK: test_vst1_f32_x4 8100 vst1_f32_x4(a, b); 8101 // CHECK: st1 {v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, v{{[0-9]+}}.2s, 8102 // v{{[0-9]+}}.2s}, [{{x[0-9]+|sp}}] 8103 } 8104 8105 void test_vst1_f64_x4(float64_t *a, float64x1x4_t b) { 8106 // CHECK: test_vst1_f64_x4 8107 vst1_f64_x4(a, b); 8108 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 8109 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 8110 } 8111 8112 void test_vst1_p8_x4(poly8_t *a, poly8x8x4_t b) { 8113 // CHECK: test_vst1_p8_x4 8114 vst1_p8_x4(a, b); 8115 // CHECK: st1 {v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, v{{[0-9]+}}.8b, 8116 // v{{[0-9]+}}.8b}, [{{x[0-9]+|sp}}] 8117 } 8118 8119 void test_vst1_p16_x4(poly16_t *a, poly16x4x4_t b) { 8120 // CHECK: test_vst1_p16_x4 8121 vst1_p16_x4(a, b); 8122 // CHECK: st1 {v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, v{{[0-9]+}}.4h, 8123 // v{{[0-9]+}}.4h}, [{{x[0-9]+|sp}}] 8124 } 8125 8126 void test_vst1_p64_x4(poly64_t *a, poly64x1x4_t b) { 8127 // CHECK: test_vst1_p64_x4 8128 vst1_p64_x4(a, b); 8129 // CHECK: st1 {v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, v{{[0-9]+}}.1d, 8130 // v{{[0-9]+}}.1d}, [{{x[0-9]+|sp}}] 8131 } 8132 8133 int64_t test_vceqd_s64(int64_t a, int64_t b) { 8134 // CHECK: test_vceqd_s64 8135 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8136 return (int64_t)vceqd_s64(a, b); 8137 } 8138 8139 uint64_t test_vceqd_u64(uint64_t a, uint64_t b) { 8140 // CHECK: test_vceqd_u64 8141 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8142 return (int64_t)vceqd_u64(a, b); 8143 } 8144 8145 int64_t test_vceqzd_s64(int64_t a) { 8146 // CHECK: test_vceqzd_s64 8147 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8148 return (int64_t)vceqzd_s64(a); 8149 } 8150 8151 int64_t test_vceqzd_u64(int64_t a) { 8152 // CHECK: test_vceqzd_u64 8153 // CHECK: cmeq {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8154 return (int64_t)vceqzd_u64(a); 8155 } 8156 8157 int64_t test_vcged_s64(int64_t a, int64_t b) { 8158 // CHECK: test_vcged_s64 8159 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8160 return (int64_t)vcged_s64(a, b); 8161 } 8162 8163 uint64_t test_vcged_u64(uint64_t a, uint64_t b) { 8164 // CHECK: test_vcged_u64 8165 // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8166 return (uint64_t)vcged_u64(a, b); 8167 } 8168 8169 int64_t test_vcgezd_s64(int64_t a) { 8170 // CHECK: test_vcgezd_s64 8171 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8172 return (int64_t)vcgezd_s64(a); 8173 } 8174 8175 int64_t test_vcgtd_s64(int64_t a, int64_t b) { 8176 // CHECK: test_vcgtd_s64 8177 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8178 return (int64_t)vcgtd_s64(a, b); 8179 } 8180 8181 uint64_t test_vcgtd_u64(uint64_t a, uint64_t b) { 8182 // CHECK: test_vcgtd_u64 8183 // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8184 return (uint64_t)vcgtd_u64(a, b); 8185 } 8186 8187 int64_t test_vcgtzd_s64(int64_t a) { 8188 // CHECK: test_vcgtzd_s64 8189 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8190 return (int64_t)vcgtzd_s64(a); 8191 } 8192 8193 int64_t test_vcled_s64(int64_t a, int64_t b) { 8194 // CHECK: test_vcled_s64 8195 // CHECK: cmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8196 return (int64_t)vcled_s64(a, b); 8197 } 8198 8199 uint64_t test_vcled_u64(uint64_t a, uint64_t b) { 8200 // CHECK: test_vcled_u64 8201 // CHECK: cmhs {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8202 return (uint64_t)vcled_u64(a, 0); 8203 } 8204 8205 int64_t test_vclezd_s64(int64_t a) { 8206 // CHECK: test_vclezd_s64 8207 // CHECK: cmle {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8208 return (int64_t)vclezd_s64(a); 8209 } 8210 8211 int64_t test_vcltd_s64(int64_t a, int64_t b) { 8212 // CHECK: test_vcltd_s64 8213 // CHECK: cmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8214 return (int64_t)vcltd_s64(a, b); 8215 } 8216 8217 uint64_t test_vcltd_u64(uint64_t a, uint64_t b) { 8218 // CHECK: test_vcltd_u64 8219 // CHECK: cmhi {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8220 return (uint64_t)vcltd_u64(a, b); 8221 } 8222 8223 int64_t test_vcltzd_s64(int64_t a) { 8224 // CHECK: test_vcltzd_s64 8225 // CHECK: cmlt {{d[0-9]+}}, {{d[0-9]+}}, #0x0 8226 return (int64_t)vcltzd_s64(a); 8227 } 8228 8229 int64_t test_vtstd_s64(int64_t a, int64_t b) { 8230 // CHECK: test_vtstd_s64 8231 // CHECK: cmtst {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8232 return (int64_t)vtstd_s64(a, b); 8233 } 8234 8235 uint64_t test_vtstd_u64(uint64_t a, uint64_t b) { 8236 // CHECK: test_vtstd_u64 8237 // CHECK: cmtst {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8238 return (uint64_t)vtstd_u64(a, b); 8239 } 8240 8241 int64_t test_vabsd_s64(int64_t a) { 8242 // CHECK: test_vabsd_s64 8243 // CHECK: abs {{d[0-9]+}}, {{d[0-9]+}} 8244 return (int64_t)vabsd_s64(a); 8245 } 8246 8247 int8_t test_vqabsb_s8(int8_t a) { 8248 // CHECK: test_vqabsb_s8 8249 // CHECK: sqabs {{b[0-9]+}}, {{b[0-9]+}} 8250 return (int8_t)vqabsb_s8(a); 8251 } 8252 8253 int16_t test_vqabsh_s16(int16_t a) { 8254 // CHECK: test_vqabsh_s16 8255 // CHECK: sqabs {{h[0-9]+}}, {{h[0-9]+}} 8256 return (int16_t)vqabsh_s16(a); 8257 } 8258 8259 int32_t test_vqabss_s32(int32_t a) { 8260 // CHECK: test_vqabss_s32 8261 // CHECK: sqabs {{s[0-9]+}}, {{s[0-9]+}} 8262 return (int32_t)vqabss_s32(a); 8263 } 8264 8265 int64_t test_vqabsd_s64(int64_t a) { 8266 // CHECK: test_vqabsd_s64 8267 // CHECK: sqabs {{d[0-9]+}}, {{d[0-9]+}} 8268 return (int64_t)vqabsd_s64(a); 8269 } 8270 8271 int64_t test_vnegd_s64(int64_t a) { 8272 // CHECK: test_vnegd_s64 8273 // CHECK: neg {{d[0-9]+}}, {{d[0-9]+}} 8274 return (int64_t)vnegd_s64(a); 8275 } 8276 8277 int8_t test_vqnegb_s8(int8_t a) { 8278 // CHECK: test_vqnegb_s8 8279 // CHECK: sqneg {{b[0-9]+}}, {{b[0-9]+}} 8280 return (int8_t)vqnegb_s8(a); 8281 } 8282 8283 int16_t test_vqnegh_s16(int16_t a) { 8284 // CHECK: test_vqnegh_s16 8285 // CHECK: sqneg {{h[0-9]+}}, {{h[0-9]+}} 8286 return (int16_t)vqnegh_s16(a); 8287 } 8288 8289 int32_t test_vqnegs_s32(int32_t a) { 8290 // CHECK: test_vqnegs_s32 8291 // CHECK: sqneg {{s[0-9]+}}, {{s[0-9]+}} 8292 return (int32_t)vqnegs_s32(a); 8293 } 8294 8295 int64_t test_vqnegd_s64(int64_t a) { 8296 // CHECK: test_vqnegd_s64 8297 // CHECK: sqneg {{d[0-9]+}}, {{d[0-9]+}} 8298 return (int64_t)vqnegd_s64(a); 8299 } 8300 8301 int8_t test_vuqaddb_s8(int8_t a, int8_t b) { 8302 // CHECK: test_vuqaddb_s8 8303 // CHECK: suqadd {{b[0-9]+}}, {{b[0-9]+}} 8304 return (int8_t)vuqaddb_s8(a, b); 8305 } 8306 8307 int16_t test_vuqaddh_s16(int16_t a, int16_t b) { 8308 // CHECK: test_vuqaddh_s16 8309 // CHECK: suqadd {{h[0-9]+}}, {{h[0-9]+}} 8310 return (int16_t)vuqaddh_s16(a, b); 8311 } 8312 8313 int32_t test_vuqadds_s32(int32_t a, int32_t b) { 8314 // CHECK: test_vuqadds_s32 8315 // CHECK: suqadd {{s[0-9]+}}, {{s[0-9]+}} 8316 return (int32_t)vuqadds_s32(a, b); 8317 } 8318 8319 int64_t test_vuqaddd_s64(int64_t a, int64_t b) { 8320 // CHECK: test_vuqaddd_s64 8321 // CHECK: suqadd {{d[0-9]+}}, {{d[0-9]+}} 8322 return (int64_t)vuqaddd_s64(a, b); 8323 } 8324 8325 uint8_t test_vsqaddb_u8(uint8_t a, uint8_t b) { 8326 // CHECK: test_vsqaddb_u8 8327 // CHECK: usqadd {{b[0-9]+}}, {{b[0-9]+}} 8328 return (uint8_t)vsqaddb_u8(a, b); 8329 } 8330 8331 uint16_t test_vsqaddh_u16(uint16_t a, uint16_t b) { 8332 // CHECK: test_vsqaddh_u16 8333 // CHECK: usqadd {{h[0-9]+}}, {{h[0-9]+}} 8334 return (uint16_t)vsqaddh_u16(a, b); 8335 } 8336 8337 uint32_t test_vsqadds_u32(uint32_t a, uint32_t b) { 8338 // CHECK: test_vsqadds_u32 8339 // CHECK: usqadd {{s[0-9]+}}, {{s[0-9]+}} 8340 return (uint32_t)vsqadds_u32(a, b); 8341 } 8342 8343 uint64_t test_vsqaddd_u64(uint64_t a, uint64_t b) { 8344 // CHECK: test_vsqaddd_u64 8345 // CHECK: usqadd {{d[0-9]+}}, {{d[0-9]+}} 8346 return (uint64_t)vsqaddd_u64(a, b); 8347 } 8348 8349 int32_t test_vqdmlalh_s16(int32_t a, int16_t b, int16_t c) { 8350 // CHECK: test_vqdmlalh_s16 8351 // CHECK: sqdmlal {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 8352 return (int32_t)vqdmlalh_s16(a, b, c); 8353 } 8354 8355 int64_t test_vqdmlals_s32(int64_t a, int32_t b, int32_t c) { 8356 // CHECK: test_vqdmlals_s32 8357 // CHECK: sqdmlal {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8358 return (int64_t)vqdmlals_s32(a, b, c); 8359 } 8360 8361 int32_t test_vqdmlslh_s16(int32_t a, int16_t b, int16_t c) { 8362 // CHECK: test_vqdmlslh_s16 8363 // CHECK: sqdmlsl {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 8364 return (int32_t)vqdmlslh_s16(a, b, c); 8365 } 8366 8367 int64_t test_vqdmlsls_s32(int64_t a, int32_t b, int32_t c) { 8368 // CHECK: test_vqdmlsls_s32 8369 // CHECK: sqdmlsl {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8370 return (int64_t)vqdmlsls_s32(a, b, c); 8371 } 8372 8373 int32_t test_vqdmullh_s16(int16_t a, int16_t b) { 8374 // CHECK: test_vqdmullh_s16 8375 // CHECK: sqdmull {{s[0-9]+}}, {{h[0-9]+}}, {{h[0-9]+}} 8376 return (int32_t)vqdmullh_s16(a, b); 8377 } 8378 8379 int64_t test_vqdmulls_s32(int32_t a, int32_t b) { 8380 // CHECK: test_vqdmulls_s32 8381 // CHECK: sqdmull {{d[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8382 return (int64_t)vqdmulls_s32(a, b); 8383 } 8384 8385 int8_t test_vqmovunh_s16(int16_t a) { 8386 // CHECK: test_vqmovunh_s16 8387 // CHECK: sqxtun {{b[0-9]+}}, {{h[0-9]+}} 8388 return (int8_t)vqmovunh_s16(a); 8389 } 8390 8391 int16_t test_vqmovuns_s32(int32_t a) { 8392 // CHECK: test_vqmovuns_s32 8393 // CHECK: sqxtun {{h[0-9]+}}, {{s[0-9]+}} 8394 return (int16_t)vqmovuns_s32(a); 8395 } 8396 8397 int32_t test_vqmovund_s64(int64_t a) { 8398 // CHECK: test_vqmovund_s64 8399 // CHECK: sqxtun {{s[0-9]+}}, {{d[0-9]+}} 8400 return (int32_t)vqmovund_s64(a); 8401 } 8402 8403 int8_t test_vqmovnh_s16(int16_t a) { 8404 // CHECK: test_vqmovnh_s16 8405 // CHECK: sqxtn {{b[0-9]+}}, {{h[0-9]+}} 8406 return (int8_t)vqmovnh_s16(a); 8407 } 8408 8409 int16_t test_vqmovns_s32(int32_t a) { 8410 // CHECK: test_vqmovns_s32 8411 // CHECK: sqxtn {{h[0-9]+}}, {{s[0-9]+}} 8412 return (int16_t)vqmovns_s32(a); 8413 } 8414 8415 int32_t test_vqmovnd_s64(int64_t a) { 8416 // CHECK: test_vqmovnd_s64 8417 // CHECK: sqxtn {{s[0-9]+}}, {{d[0-9]+}} 8418 return (int32_t)vqmovnd_s64(a); 8419 } 8420 8421 int8_t test_vqmovnh_u16(int16_t a) { 8422 // CHECK: test_vqmovnh_u16 8423 // CHECK: uqxtn {{b[0-9]+}}, {{h[0-9]+}} 8424 return (int8_t)vqmovnh_u16(a); 8425 } 8426 8427 int16_t test_vqmovns_u32(int32_t a) { 8428 // CHECK: test_vqmovns_u32 8429 // CHECK: uqxtn {{h[0-9]+}}, {{s[0-9]+}} 8430 return (int16_t)vqmovns_u32(a); 8431 } 8432 8433 int32_t test_vqmovnd_u64(int64_t a) { 8434 // CHECK: test_vqmovnd_u64 8435 // CHECK: uqxtn {{s[0-9]+}}, {{d[0-9]+}} 8436 return (int32_t)vqmovnd_u64(a); 8437 } 8438 8439 uint32_t test_vceqs_f32(float32_t a, float32_t b) { 8440 // CHECK: test_vceqs_f32 8441 // CHECK: fcmeq {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8442 return (uint32_t)vceqs_f32(a, b); 8443 } 8444 8445 uint64_t test_vceqd_f64(float64_t a, float64_t b) { 8446 // CHECK: test_vceqd_f64 8447 // CHECK: fcmeq {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8448 return (uint64_t)vceqd_f64(a, b); 8449 } 8450 8451 uint32_t test_vceqzs_f32(float32_t a) { 8452 // CHECK: test_vceqzs_f32 8453 // CHECK: fcmeq {{s[0-9]+}}, {{s[0-9]+}}, #0.0 8454 return (uint32_t)vceqzs_f32(a); 8455 } 8456 8457 uint64_t test_vceqzd_f64(float64_t a) { 8458 // CHECK: test_vceqzd_f64 8459 // CHECK: fcmeq {{d[0-9]+}}, {{d[0-9]+}}, #0.0 8460 return (uint64_t)vceqzd_f64(a); 8461 } 8462 8463 uint32_t test_vcges_f32(float32_t a, float32_t b) { 8464 // CHECK: test_vcges_f32 8465 // CHECK: fcmge {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8466 return (uint32_t)vcges_f32(a, b); 8467 } 8468 8469 uint64_t test_vcged_f64(float64_t a, float64_t b) { 8470 // CHECK: test_vcged_f64 8471 // CHECK: fcmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8472 return (uint64_t)vcged_f64(a, b); 8473 } 8474 8475 uint32_t test_vcgezs_f32(float32_t a) { 8476 // CHECK: test_vcgezs_f32 8477 // CHECK: fcmge {{s[0-9]+}}, {{s[0-9]+}}, #0.0 8478 return (uint32_t)vcgezs_f32(a); 8479 } 8480 8481 uint64_t test_vcgezd_f64(float64_t a) { 8482 // CHECK: test_vcgezd_f64 8483 // CHECK: fcmge {{d[0-9]+}}, {{d[0-9]+}}, #0.0 8484 return (uint64_t)vcgezd_f64(a); 8485 } 8486 8487 uint32_t test_vcgts_f32(float32_t a, float32_t b) { 8488 // CHECK: test_vcgts_f32 8489 // CHECK: fcmgt {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8490 return (uint32_t)vcgts_f32(a, b); 8491 } 8492 8493 uint64_t test_vcgtd_f64(float64_t a, float64_t b) { 8494 // CHECK: test_vcgtd_f64 8495 // CHECK: fcmgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8496 return (uint64_t)vcgtd_f64(a, b); 8497 } 8498 8499 uint32_t test_vcgtzs_f32(float32_t a) { 8500 // CHECK: test_vcgtzs_f32 8501 // CHECK: fcmgt {{s[0-9]+}}, {{s[0-9]+}}, #0.0 8502 return (uint32_t)vcgtzs_f32(a); 8503 } 8504 8505 uint64_t test_vcgtzd_f64(float64_t a) { 8506 // CHECK: test_vcgtzd_f64 8507 // CHECK: fcmgt {{d[0-9]+}}, {{d[0-9]+}}, #0.0 8508 return (uint64_t)vcgtzd_f64(a); 8509 } 8510 8511 uint32_t test_vcles_f32(float32_t a, float32_t b) { 8512 // CHECK: test_vcles_f32 8513 // CHECK: fcmge {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8514 return (uint32_t)vcles_f32(a, b); 8515 } 8516 8517 uint64_t test_vcled_f64(float64_t a, float64_t b) { 8518 // CHECK: test_vcled_f64 8519 // CHECK: fcmge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8520 return (uint64_t)vcled_f64(a, b); 8521 } 8522 8523 uint32_t test_vclezs_f32(float32_t a) { 8524 // CHECK: test_vclezs_f32 8525 // CHECK: fcmle {{s[0-9]+}}, {{s[0-9]+}}, #0.0 8526 return (uint32_t)vclezs_f32(a); 8527 } 8528 8529 uint64_t test_vclezd_f64(float64_t a) { 8530 // CHECK: test_vclezd_f64 8531 // CHECK: fcmle {{d[0-9]+}}, {{d[0-9]+}}, #0.0 8532 return (uint64_t)vclezd_f64(a); 8533 } 8534 8535 uint32_t test_vclts_f32(float32_t a, float32_t b) { 8536 // CHECK: test_vclts_f32 8537 // CHECK: fcmgt {{s[0-9]+}}, s1, s0 8538 return (uint32_t)vclts_f32(a, b); 8539 } 8540 8541 uint64_t test_vcltd_f64(float64_t a, float64_t b) { 8542 // CHECK: test_vcltd_f64 8543 // CHECK: fcmgt {{d[0-9]+}}, d1, d0 8544 return (uint64_t)vcltd_f64(a, b); 8545 } 8546 8547 uint32_t test_vcltzs_f32(float32_t a) { 8548 // CHECK: test_vcltzs_f32 8549 // CHECK: fcmlt {{s[0-9]+}}, {{s[0-9]+}}, #0.0 8550 return (uint32_t)vcltzs_f32(a); 8551 } 8552 8553 uint64_t test_vcltzd_f64(float64_t a) { 8554 // CHECK: test_vcltzd_f64 8555 // CHECK: fcmlt {{d[0-9]+}}, {{d[0-9]+}}, #0.0 8556 return (uint64_t)vcltzd_f64(a); 8557 } 8558 8559 uint32_t test_vcages_f32(float32_t a, float32_t b) { 8560 // CHECK: test_vcages_f32 8561 // CHECK: facge {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8562 return (uint32_t)vcages_f32(a, b); 8563 } 8564 8565 uint64_t test_vcaged_f64(float64_t a, float64_t b) { 8566 // CHECK: test_vcaged_f64 8567 // CHECK: facge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8568 return (uint64_t)vcaged_f64(a, b); 8569 } 8570 8571 uint32_t test_vcagts_f32(float32_t a, float32_t b) { 8572 // CHECK: test_vcagts_f32 8573 // CHECK: facgt {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8574 return (uint32_t)vcagts_f32(a, b); 8575 } 8576 8577 uint64_t test_vcagtd_f64(float64_t a, float64_t b) { 8578 // CHECK: test_vcagtd_f64 8579 // CHECK: facgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8580 return (uint64_t)vcagtd_f64(a, b); 8581 } 8582 8583 uint32_t test_vcales_f32(float32_t a, float32_t b) { 8584 // CHECK: test_vcales_f32 8585 // CHECK: facge {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8586 return (uint32_t)vcales_f32(a, b); 8587 } 8588 8589 uint64_t test_vcaled_f64(float64_t a, float64_t b) { 8590 // CHECK: test_vcaled_f64 8591 // CHECK: facge {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8592 return (uint64_t)vcaled_f64(a, b); 8593 } 8594 8595 uint32_t test_vcalts_f32(float32_t a, float32_t b) { 8596 // CHECK: test_vcalts_f32 8597 // CHECK: facgt {{s[0-9]+}}, {{s[0-9]+}}, {{s[0-9]+}} 8598 return (uint32_t)vcalts_f32(a, b); 8599 } 8600 8601 uint64_t test_vcaltd_f64(float64_t a, float64_t b) { 8602 // CHECK: test_vcaltd_f64 8603 // CHECK: facgt {{d[0-9]+}}, {{d[0-9]+}}, {{d[0-9]+}} 8604 return (uint64_t)vcaltd_f64(a, b); 8605 } 8606 8607 int64_t test_vshrd_n_s64(int64_t a) { 8608 // CHECK-LABEL: test_vshrd_n_s64 8609 // CHECK: sshr {{d[0-9]+}}, {{d[0-9]+}}, #1 8610 return (int64_t)vshrd_n_s64(a, 1); 8611 } 8612 8613 int64x1_t test_vshr_n_s64(int64x1_t a) { 8614 // CHECK-LABEL: test_vshr_n_s64 8615 // CHECK: sshr {{d[0-9]+}}, {{d[0-9]+}}, #1 8616 return vshr_n_s64(a, 1); 8617 } 8618 8619 uint64_t test_vshrd_n_u64(uint64_t a) { 8620 // CHECK-LABEL: test_vshrd_n_u64 8621 // CHECK: ushr {{d[0-9]+}}, {{d[0-9]+}}, #64 8622 return (uint64_t)vshrd_n_u64(a, 64); 8623 } 8624 8625 uint64x1_t test_vshr_n_u64(uint64x1_t a) { 8626 // CHECK-LABEL: test_vshr_n_u64 8627 // CHECK: ushr {{d[0-9]+}}, {{d[0-9]+}}, #1 8628 return vshr_n_u64(a, 1); 8629 } 8630 8631 int64_t test_vrshrd_n_s64(int64_t a) { 8632 // CHECK-LABEL: test_vrshrd_n_s64 8633 // CHECK: srshr {{d[0-9]+}}, {{d[0-9]+}}, #63 8634 return (int64_t)vrshrd_n_s64(a, 63); 8635 } 8636 8637 int64x1_t test_vrshr_n_s64(int64x1_t a) { 8638 // CHECK: test_vrshr_n_s64 8639 // CHECK: srshr d{{[0-9]+}}, d{{[0-9]+}}, #1 8640 return vrshr_n_s64(a, 1); 8641 } 8642 8643 uint64_t test_vrshrd_n_u64(uint64_t a) { 8644 // CHECK-LABEL: test_vrshrd_n_u64 8645 // CHECK: urshr {{d[0-9]+}}, {{d[0-9]+}}, #63 8646 return (uint64_t)vrshrd_n_u64(a, 63); 8647 } 8648 8649 uint64x1_t test_vrshr_n_u64(uint64x1_t a) { 8650 // CHECK: test_vrshr_n_u64 8651 // CHECK: urshr d{{[0-9]+}}, d{{[0-9]+}}, #1 8652 return vrshr_n_u64(a, 1); 8653 } 8654 8655 int64_t test_vsrad_n_s64(int64_t a, int64_t b) { 8656 // CHECK-LABEL: test_vsrad_n_s64 8657 // CHECK: ssra {{d[0-9]+}}, {{d[0-9]+}}, #63 8658 return (int64_t)vsrad_n_s64(a, b, 63); 8659 } 8660 8661 int64x1_t test_vsra_n_s64(int64x1_t a, int64x1_t b) { 8662 // CHECK: test_vsra_n_s64 8663 // CHECK: ssra d{{[0-9]+}}, d{{[0-9]+}}, #1 8664 return vsra_n_s64(a, b, 1); 8665 } 8666 8667 uint64_t test_vsrad_n_u64(uint64_t a, uint64_t b) { 8668 // CHECK-LABEL: test_vsrad_n_u64 8669 // CHECK: usra {{d[0-9]+}}, {{d[0-9]+}}, #63 8670 return (uint64_t)vsrad_n_u64(a, b, 63); 8671 } 8672 8673 uint64x1_t test_vsra_n_u64(uint64x1_t a, uint64x1_t b) { 8674 // CHECK: test_vsra_n_u64 8675 // CHECK: usra d{{[0-9]+}}, d{{[0-9]+}}, #1 8676 return vsra_n_u64(a, b, 1); 8677 } 8678 8679 int64_t test_vrsrad_n_s64(int64_t a, int64_t b) { 8680 // CHECK-LABEL: test_vrsrad_n_s64 8681 // CHECK: srsra {{d[0-9]+}}, {{d[0-9]+}}, #63 8682 return (int64_t)vrsrad_n_s64(a, b, 63); 8683 } 8684 8685 int64x1_t test_vrsra_n_s64(int64x1_t a, int64x1_t b) { 8686 // CHECK: test_vrsra_n_s64 8687 // CHECK: srsra d{{[0-9]+}}, d{{[0-9]+}}, #1 8688 return vrsra_n_s64(a, b, 1); 8689 } 8690 8691 uint64_t test_vrsrad_n_u64(uint64_t a, uint64_t b) { 8692 // CHECK-LABEL: test_vrsrad_n_u64 8693 // CHECK: ursra {{d[0-9]+}}, {{d[0-9]+}}, #63 8694 return (uint64_t)vrsrad_n_u64(a, b, 63); 8695 } 8696 8697 uint64x1_t test_vrsra_n_u64(uint64x1_t a, uint64x1_t b) { 8698 // CHECK: test_vrsra_n_u64 8699 // CHECK: ursra d{{[0-9]+}}, d{{[0-9]+}}, #1 8700 return vrsra_n_u64(a, b, 1); 8701 } 8702 8703 int64_t test_vshld_n_s64(int64_t a) { 8704 // CHECK-LABEL: test_vshld_n_s64 8705 // CHECK: shl {{d[0-9]+}}, {{d[0-9]+}}, #0 8706 return (int64_t)vshld_n_s64(a, 0); 8707 } 8708 int64x1_t test_vshl_n_s64(int64x1_t a) { 8709 // CHECK: test_vshl_n_s64 8710 // CHECK: shl d{{[0-9]+}}, d{{[0-9]+}}, #1 8711 return vshl_n_s64(a, 1); 8712 } 8713 8714 uint64_t test_vshld_n_u64(uint64_t a) { 8715 // CHECK-LABEL: test_vshld_n_u64 8716 // CHECK: shl {{d[0-9]+}}, {{d[0-9]+}}, #63 8717 return (uint64_t)vshld_n_u64(a, 63); 8718 } 8719 8720 uint64x1_t test_vshl_n_u64(uint64x1_t a) { 8721 // CHECK: test_vshl_n_u64 8722 // CHECK: shl d{{[0-9]+}}, d{{[0-9]+}}, #1 8723 return vshl_n_u64(a, 1); 8724 } 8725 8726 int8_t test_vqshlb_n_s8(int8_t a) { 8727 // CHECK-LABEL: test_vqshlb_n_s8 8728 // CHECK: sqshl {{b[0-9]+}}, {{b[0-9]+}}, #7 8729 return (int8_t)vqshlb_n_s8(a, 7); 8730 } 8731 8732 int16_t test_vqshlh_n_s16(int16_t a) { 8733 // CHECK-LABEL: test_vqshlh_n_s16 8734 // CHECK: sqshl {{h[0-9]+}}, {{h[0-9]+}}, #15 8735 return (int16_t)vqshlh_n_s16(a, 15); 8736 } 8737 8738 int32_t test_vqshls_n_s32(int32_t a) { 8739 // CHECK-LABEL: test_vqshls_n_s32 8740 // CHECK: sqshl {{s[0-9]+}}, {{s[0-9]+}}, #31 8741 return (int32_t)vqshls_n_s32(a, 31); 8742 } 8743 8744 int64_t test_vqshld_n_s64(int64_t a) { 8745 // CHECK-LABEL: test_vqshld_n_s64 8746 // CHECK: sqshl {{d[0-9]+}}, {{d[0-9]+}}, #63 8747 return (int64_t)vqshld_n_s64(a, 63); 8748 } 8749 8750 int64x1_t test_vqshl_n_s64(int64x1_t a) { 8751 // CHECK: test_vqshl_n_s64 8752 // CHECK: sqshl d{{[0-9]+}}, d{{[0-9]+}}, #1 8753 return vqshl_n_s64(a, 1); 8754 } 8755 8756 uint8_t test_vqshlb_n_u8(uint8_t a) { 8757 // CHECK-LABEL: test_vqshlb_n_u8 8758 // CHECK: uqshl {{b[0-9]+}}, {{b[0-9]+}}, #7 8759 return (uint8_t)vqshlb_n_u8(a, 7); 8760 } 8761 8762 uint16_t test_vqshlh_n_u16(uint16_t a) { 8763 // CHECK-LABEL: test_vqshlh_n_u16 8764 // CHECK: uqshl {{h[0-9]+}}, {{h[0-9]+}}, #15 8765 return (uint16_t)vqshlh_n_u16(a, 15); 8766 } 8767 8768 uint32_t test_vqshls_n_u32(uint32_t a) { 8769 // CHECK-LABEL: test_vqshls_n_u32 8770 // CHECK: uqshl {{s[0-9]+}}, {{s[0-9]+}}, #31 8771 return (uint32_t)vqshls_n_u32(a, 31); 8772 } 8773 8774 uint64_t test_vqshld_n_u64(uint64_t a) { 8775 // CHECK-LABEL: test_vqshld_n_u64 8776 // CHECK: uqshl {{d[0-9]+}}, {{d[0-9]+}}, #63 8777 return (uint64_t)vqshld_n_u64(a, 63); 8778 } 8779 8780 uint64x1_t test_vqshl_n_u64(uint64x1_t a) { 8781 // CHECK: test_vqshl_n_u64 8782 // CHECK: uqshl d{{[0-9]+}}, d{{[0-9]+}}, #1 8783 return vqshl_n_u64(a, 1); 8784 } 8785 8786 int8_t test_vqshlub_n_s8(int8_t a) { 8787 // CHECK-LABEL: test_vqshlub_n_s8 8788 // CHECK: sqshlu {{b[0-9]+}}, {{b[0-9]+}}, #7 8789 return (int8_t)vqshlub_n_s8(a, 7); 8790 } 8791 8792 int16_t test_vqshluh_n_s16(int16_t a) { 8793 // CHECK-LABEL: test_vqshluh_n_s16 8794 // CHECK: sqshlu {{h[0-9]+}}, {{h[0-9]+}}, #15 8795 return (int16_t)vqshluh_n_s16(a, 15); 8796 } 8797 8798 int32_t test_vqshlus_n_s32(int32_t a) { 8799 // CHECK-LABEL: test_vqshlus_n_s32 8800 // CHECK: sqshlu {{s[0-9]+}}, {{s[0-9]+}}, #31 8801 return (int32_t)vqshlus_n_s32(a, 31); 8802 } 8803 8804 int64_t test_vqshlud_n_s64(int64_t a) { 8805 // CHECK-LABEL: test_vqshlud_n_s64 8806 // CHECK: sqshlu {{d[0-9]+}}, {{d[0-9]+}}, #63 8807 return (int64_t)vqshlud_n_s64(a, 63); 8808 } 8809 8810 uint64x1_t test_vqshlu_n_s64(int64x1_t a) { 8811 // CHECK: test_vqshlu_n_s64 8812 // CHECK: sqshlu d{{[0-9]+}}, d{{[0-9]+}}, #1 8813 return vqshlu_n_s64(a, 1); 8814 } 8815 8816 int64_t test_vsrid_n_s64(int64_t a, int64_t b) { 8817 // CHECK-LABEL: test_vsrid_n_s64 8818 // CHECK: sri {{d[0-9]+}}, {{d[0-9]+}}, #63 8819 return (int64_t)vsrid_n_s64(a, b, 63); 8820 } 8821 8822 int64x1_t test_vsri_n_s64(int64x1_t a, int64x1_t b) { 8823 // CHECK: test_vsri_n_s64 8824 // CHECK: sri d{{[0-9]+}}, d{{[0-9]+}}, #1 8825 return vsri_n_s64(a, b, 1); 8826 } 8827 8828 uint64_t test_vsrid_n_u64(uint64_t a, uint64_t b) { 8829 // CHECK-LABEL: test_vsrid_n_u64 8830 // CHECK: sri {{d[0-9]+}}, {{d[0-9]+}}, #63 8831 return (uint64_t)vsrid_n_u64(a, b, 63); 8832 } 8833 8834 uint64x1_t test_vsri_n_u64(uint64x1_t a, uint64x1_t b) { 8835 // CHECK: test_vsri_n_u64 8836 // CHECK: sri d{{[0-9]+}}, d{{[0-9]+}}, #1 8837 return vsri_n_u64(a, b, 1); 8838 } 8839 8840 int64_t test_vslid_n_s64(int64_t a, int64_t b) { 8841 // CHECK-LABEL: test_vslid_n_s64 8842 // CHECK: sli {{d[0-9]+}}, {{d[0-9]+}}, #63 8843 return (int64_t)vslid_n_s64(a, b, 63); 8844 } 8845 8846 int64x1_t test_vsli_n_s64(int64x1_t a, int64x1_t b) { 8847 // CHECK: test_vsli_n_s64 8848 // CHECK: sli d{{[0-9]+}}, d{{[0-9]+}}, #1 8849 return vsli_n_s64(a, b, 1); 8850 } 8851 8852 uint64_t test_vslid_n_u64(uint64_t a, uint64_t b) { 8853 // CHECK-LABEL: test_vslid_n_u64 8854 // CHECK: sli {{d[0-9]+}}, {{d[0-9]+}}, #63 8855 return (uint64_t)vslid_n_u64(a, b, 63); 8856 } 8857 8858 uint64x1_t test_vsli_n_u64(uint64x1_t a, uint64x1_t b) { 8859 // CHECK: test_vsli_n_u64 8860 // CHECK: sli d{{[0-9]+}}, d{{[0-9]+}}, #1 8861 return vsli_n_u64(a, b, 1); 8862 } 8863 8864 int8_t test_vqshrnh_n_s16(int16_t a) { 8865 // CHECK-LABEL: test_vqshrnh_n_s16 8866 // CHECK: sqshrn {{b[0-9]+}}, {{h[0-9]+}}, #15 8867 return (int8_t)vqshrnh_n_s16(a, 15); 8868 } 8869 8870 int16_t test_vqshrns_n_s32(int32_t a) { 8871 // CHECK-LABEL: test_vqshrns_n_s32 8872 // CHECK: sqshrn {{h[0-9]+}}, {{s[0-9]+}}, #31 8873 return (int16_t)vqshrns_n_s32(a, 31); 8874 } 8875 8876 int32_t test_vqshrnd_n_s64(int64_t a) { 8877 // CHECK-LABEL: test_vqshrnd_n_s64 8878 // CHECK: sqshrn {{s[0-9]+}}, {{d[0-9]+}}, #63 8879 return (int32_t)vqshrnd_n_s64(a, 63); 8880 } 8881 8882 uint8_t test_vqshrnh_n_u16(uint16_t a) { 8883 // CHECK-LABEL: test_vqshrnh_n_u16 8884 // CHECK: uqshrn {{b[0-9]+}}, {{h[0-9]+}}, #15 8885 return (uint8_t)vqshrnh_n_u16(a, 15); 8886 } 8887 8888 uint16_t test_vqshrns_n_u32(uint32_t a) { 8889 // CHECK-LABEL: test_vqshrns_n_u32 8890 // CHECK: uqshrn {{h[0-9]+}}, {{s[0-9]+}}, #31 8891 return (uint16_t)vqshrns_n_u32(a, 31); 8892 } 8893 8894 uint32_t test_vqshrnd_n_u64(uint64_t a) { 8895 // CHECK-LABEL: test_vqshrnd_n_u64 8896 // CHECK: uqshrn {{s[0-9]+}}, {{d[0-9]+}}, #63 8897 return (uint32_t)vqshrnd_n_u64(a, 63); 8898 } 8899 8900 int8_t test_vqrshrnh_n_s16(int16_t a) { 8901 // CHECK-LABEL: test_vqrshrnh_n_s16 8902 // CHECK: sqrshrn {{b[0-9]+}}, {{h[0-9]+}}, #15 8903 return (int8_t)vqrshrnh_n_s16(a, 15); 8904 } 8905 8906 int16_t test_vqrshrns_n_s32(int32_t a) { 8907 // CHECK-LABEL: test_vqrshrns_n_s32 8908 // CHECK: sqrshrn {{h[0-9]+}}, {{s[0-9]+}}, #31 8909 return (int16_t)vqrshrns_n_s32(a, 31); 8910 } 8911 8912 int32_t test_vqrshrnd_n_s64(int64_t a) { 8913 // CHECK-LABEL: test_vqrshrnd_n_s64 8914 // CHECK: sqrshrn {{s[0-9]+}}, {{d[0-9]+}}, #63 8915 return (int32_t)vqrshrnd_n_s64(a, 63); 8916 } 8917 8918 uint8_t test_vqrshrnh_n_u16(uint16_t a) { 8919 // CHECK-LABEL: test_vqrshrnh_n_u16 8920 // CHECK: uqrshrn {{b[0-9]+}}, {{h[0-9]+}}, #15 8921 return (uint8_t)vqrshrnh_n_u16(a, 15); 8922 } 8923 8924 uint16_t test_vqrshrns_n_u32(uint32_t a) { 8925 // CHECK-LABEL: test_vqrshrns_n_u32 8926 // CHECK: uqrshrn {{h[0-9]+}}, {{s[0-9]+}}, #31 8927 return (uint16_t)vqrshrns_n_u32(a, 31); 8928 } 8929 8930 uint32_t test_vqrshrnd_n_u64(uint64_t a) { 8931 // CHECK-LABEL: test_vqrshrnd_n_u64 8932 // CHECK: uqrshrn {{s[0-9]+}}, {{d[0-9]+}}, #63 8933 return (uint32_t)vqrshrnd_n_u64(a, 63); 8934 } 8935 8936 int8_t test_vqshrunh_n_s16(int16_t a) { 8937 // CHECK-LABEL: test_vqshrunh_n_s16 8938 // CHECK: sqshrun {{b[0-9]+}}, {{h[0-9]+}}, #15 8939 return (int8_t)vqshrunh_n_s16(a, 15); 8940 } 8941 8942 int16_t test_vqshruns_n_s32(int32_t a) { 8943 // CHECK-LABEL: test_vqshruns_n_s32 8944 // CHECK: sqshrun {{h[0-9]+}}, {{s[0-9]+}}, #31 8945 return (int16_t)vqshruns_n_s32(a, 31); 8946 } 8947 8948 int32_t test_vqshrund_n_s64(int64_t a) { 8949 // CHECK-LABEL: test_vqshrund_n_s64 8950 // CHECK: sqshrun {{s[0-9]+}}, {{d[0-9]+}}, #63 8951 return (int32_t)vqshrund_n_s64(a, 63); 8952 } 8953 8954 int8_t test_vqrshrunh_n_s16(int16_t a) { 8955 // CHECK-LABEL: test_vqrshrunh_n_s16 8956 // CHECK: sqrshrun {{b[0-9]+}}, {{h[0-9]+}}, #15 8957 return (int8_t)vqrshrunh_n_s16(a, 15); 8958 } 8959 8960 int16_t test_vqrshruns_n_s32(int32_t a) { 8961 // CHECK-LABEL: test_vqrshruns_n_s32 8962 // CHECK: sqrshrun {{h[0-9]+}}, {{s[0-9]+}}, #31 8963 return (int16_t)vqrshruns_n_s32(a, 31); 8964 } 8965 8966 int32_t test_vqrshrund_n_s64(int64_t a) { 8967 // CHECK-LABEL: test_vqrshrund_n_s64 8968 // CHECK: sqrshrun {{s[0-9]+}}, {{d[0-9]+}}, #63 8969 return (int32_t)vqrshrund_n_s64(a, 63); 8970 } 8971 8972 float32_t test_vcvts_n_f32_s32(int32_t a) { 8973 // CHECK: test_vcvts_n_f32_s32 8974 // CHECK: scvtf {{s[0-9]+}}, {{s[0-9]+}}, #1 8975 return vcvts_n_f32_s32(a, 1); 8976 } 8977 8978 float64_t test_vcvtd_n_f64_s64(int64_t a) { 8979 // CHECK: test_vcvtd_n_f64_s64 8980 // CHECK: scvtf {{d[0-9]+}}, {{d[0-9]+}}, #1 8981 return vcvtd_n_f64_s64(a, 1); 8982 } 8983 8984 float32_t test_vcvts_n_f32_u32(uint32_t a) { 8985 // CHECK: test_vcvts_n_f32_u32 8986 // CHECK: ucvtf {{s[0-9]+}}, {{s[0-9]+}}, #32 8987 return vcvts_n_f32_u32(a, 32); 8988 } 8989 8990 float64_t test_vcvtd_n_f64_u64(uint64_t a) { 8991 // CHECK: test_vcvtd_n_f64_u64 8992 // CHECK: ucvtf {{d[0-9]+}}, {{d[0-9]+}}, #64 8993 return vcvtd_n_f64_u64(a, 64); 8994 } 8995 8996 int32_t test_vcvts_n_s32_f32(float32_t a) { 8997 // CHECK: test_vcvts_n_s32_f32 8998 // CHECK: fcvtzs {{s[0-9]+}}, {{s[0-9]+}}, #1 8999 return (int32_t)vcvts_n_s32_f32(a, 1); 9000 } 9001 9002 int64_t test_vcvtd_n_s64_f64(float64_t a) { 9003 // CHECK: test_vcvtd_n_s64_f64 9004 // CHECK: fcvtzs {{d[0-9]+}}, {{d[0-9]+}}, #1 9005 return (int64_t)vcvtd_n_s64_f64(a, 1); 9006 } 9007 9008 uint32_t test_vcvts_n_u32_f32(float32_t a) { 9009 // CHECK: test_vcvts_n_u32_f32 9010 // CHECK: fcvtzu {{s[0-9]+}}, {{s[0-9]+}}, #32 9011 return (uint32_t)vcvts_n_u32_f32(a, 32); 9012 } 9013 9014 uint64_t test_vcvtd_n_u64_f64(float64_t a) { 9015 // CHECK: test_vcvtd_n_u64_f64 9016 // CHECK: fcvtzu {{d[0-9]+}}, {{d[0-9]+}}, #64 9017 return (uint64_t)vcvtd_n_u64_f64(a, 64); 9018 } 9019 9020 // CHECK-LABEL: test_vreinterpret_s8_s16 9021 // CHECK-NEXT: ret 9022 int8x8_t test_vreinterpret_s8_s16(int16x4_t a) { 9023 return vreinterpret_s8_s16(a); 9024 } 9025 9026 // CHECK-LABEL: test_vreinterpret_s8_s32 9027 // CHECK-NEXT: ret 9028 int8x8_t test_vreinterpret_s8_s32(int32x2_t a) { 9029 return vreinterpret_s8_s32(a); 9030 } 9031 9032 // CHECK-LABEL: test_vreinterpret_s8_s64 9033 // CHECK-NEXT: ret 9034 int8x8_t test_vreinterpret_s8_s64(int64x1_t a) { 9035 return vreinterpret_s8_s64(a); 9036 } 9037 9038 // CHECK-LABEL: test_vreinterpret_s8_u8 9039 // CHECK-NEXT: ret 9040 int8x8_t test_vreinterpret_s8_u8(uint8x8_t a) { 9041 return vreinterpret_s8_u8(a); 9042 } 9043 9044 // CHECK-LABEL: test_vreinterpret_s8_u16 9045 // CHECK-NEXT: ret 9046 int8x8_t test_vreinterpret_s8_u16(uint16x4_t a) { 9047 return vreinterpret_s8_u16(a); 9048 } 9049 9050 // CHECK-LABEL: test_vreinterpret_s8_u32 9051 // CHECK-NEXT: ret 9052 int8x8_t test_vreinterpret_s8_u32(uint32x2_t a) { 9053 return vreinterpret_s8_u32(a); 9054 } 9055 9056 // CHECK-LABEL: test_vreinterpret_s8_u64 9057 // CHECK-NEXT: ret 9058 int8x8_t test_vreinterpret_s8_u64(uint64x1_t a) { 9059 return vreinterpret_s8_u64(a); 9060 } 9061 9062 // CHECK-LABEL: test_vreinterpret_s8_f16 9063 // CHECK-NEXT: ret 9064 int8x8_t test_vreinterpret_s8_f16(float16x4_t a) { 9065 return vreinterpret_s8_f16(a); 9066 } 9067 9068 // CHECK-LABEL: test_vreinterpret_s8_f32 9069 // CHECK-NEXT: ret 9070 int8x8_t test_vreinterpret_s8_f32(float32x2_t a) { 9071 return vreinterpret_s8_f32(a); 9072 } 9073 9074 // CHECK-LABEL: test_vreinterpret_s8_f64 9075 // CHECK-NEXT: ret 9076 int8x8_t test_vreinterpret_s8_f64(float64x1_t a) { 9077 return vreinterpret_s8_f64(a); 9078 } 9079 9080 // CHECK-LABEL: test_vreinterpret_s8_p8 9081 // CHECK-NEXT: ret 9082 int8x8_t test_vreinterpret_s8_p8(poly8x8_t a) { 9083 return vreinterpret_s8_p8(a); 9084 } 9085 9086 // CHECK-LABEL: test_vreinterpret_s8_p16 9087 // CHECK-NEXT: ret 9088 int8x8_t test_vreinterpret_s8_p16(poly16x4_t a) { 9089 return vreinterpret_s8_p16(a); 9090 } 9091 9092 // CHECK-LABEL: test_vreinterpret_s8_p64 9093 // CHECK-NEXT: ret 9094 int8x8_t test_vreinterpret_s8_p64(poly64x1_t a) { 9095 return vreinterpret_s8_p64(a); 9096 } 9097 9098 // CHECK-LABEL: test_vreinterpret_s16_s8 9099 // CHECK-NEXT: ret 9100 int16x4_t test_vreinterpret_s16_s8(int8x8_t a) { 9101 return vreinterpret_s16_s8(a); 9102 } 9103 9104 // CHECK-LABEL: test_vreinterpret_s16_s32 9105 // CHECK-NEXT: ret 9106 int16x4_t test_vreinterpret_s16_s32(int32x2_t a) { 9107 return vreinterpret_s16_s32(a); 9108 } 9109 9110 // CHECK-LABEL: test_vreinterpret_s16_s64 9111 // CHECK-NEXT: ret 9112 int16x4_t test_vreinterpret_s16_s64(int64x1_t a) { 9113 return vreinterpret_s16_s64(a); 9114 } 9115 9116 // CHECK-LABEL: test_vreinterpret_s16_u8 9117 // CHECK-NEXT: ret 9118 int16x4_t test_vreinterpret_s16_u8(uint8x8_t a) { 9119 return vreinterpret_s16_u8(a); 9120 } 9121 9122 // CHECK-LABEL: test_vreinterpret_s16_u16 9123 // CHECK-NEXT: ret 9124 int16x4_t test_vreinterpret_s16_u16(uint16x4_t a) { 9125 return vreinterpret_s16_u16(a); 9126 } 9127 9128 // CHECK-LABEL: test_vreinterpret_s16_u32 9129 // CHECK-NEXT: ret 9130 int16x4_t test_vreinterpret_s16_u32(uint32x2_t a) { 9131 return vreinterpret_s16_u32(a); 9132 } 9133 9134 // CHECK-LABEL: test_vreinterpret_s16_u64 9135 // CHECK-NEXT: ret 9136 int16x4_t test_vreinterpret_s16_u64(uint64x1_t a) { 9137 return vreinterpret_s16_u64(a); 9138 } 9139 9140 // CHECK-LABEL: test_vreinterpret_s16_f16 9141 // CHECK-NEXT: ret 9142 int16x4_t test_vreinterpret_s16_f16(float16x4_t a) { 9143 return vreinterpret_s16_f16(a); 9144 } 9145 9146 // CHECK-LABEL: test_vreinterpret_s16_f32 9147 // CHECK-NEXT: ret 9148 int16x4_t test_vreinterpret_s16_f32(float32x2_t a) { 9149 return vreinterpret_s16_f32(a); 9150 } 9151 9152 // CHECK-LABEL: test_vreinterpret_s16_f64 9153 // CHECK-NEXT: ret 9154 int16x4_t test_vreinterpret_s16_f64(float64x1_t a) { 9155 return vreinterpret_s16_f64(a); 9156 } 9157 9158 // CHECK-LABEL: test_vreinterpret_s16_p8 9159 // CHECK-NEXT: ret 9160 int16x4_t test_vreinterpret_s16_p8(poly8x8_t a) { 9161 return vreinterpret_s16_p8(a); 9162 } 9163 9164 // CHECK-LABEL: test_vreinterpret_s16_p16 9165 // CHECK-NEXT: ret 9166 int16x4_t test_vreinterpret_s16_p16(poly16x4_t a) { 9167 return vreinterpret_s16_p16(a); 9168 } 9169 9170 // CHECK-LABEL: test_vreinterpret_s16_p64 9171 // CHECK-NEXT: ret 9172 int16x4_t test_vreinterpret_s16_p64(poly64x1_t a) { 9173 return vreinterpret_s16_p64(a); 9174 } 9175 9176 // CHECK-LABEL: test_vreinterpret_s32_s8 9177 // CHECK-NEXT: ret 9178 int32x2_t test_vreinterpret_s32_s8(int8x8_t a) { 9179 return vreinterpret_s32_s8(a); 9180 } 9181 9182 // CHECK-LABEL: test_vreinterpret_s32_s16 9183 // CHECK-NEXT: ret 9184 int32x2_t test_vreinterpret_s32_s16(int16x4_t a) { 9185 return vreinterpret_s32_s16(a); 9186 } 9187 9188 // CHECK-LABEL: test_vreinterpret_s32_s64 9189 // CHECK-NEXT: ret 9190 int32x2_t test_vreinterpret_s32_s64(int64x1_t a) { 9191 return vreinterpret_s32_s64(a); 9192 } 9193 9194 // CHECK-LABEL: test_vreinterpret_s32_u8 9195 // CHECK-NEXT: ret 9196 int32x2_t test_vreinterpret_s32_u8(uint8x8_t a) { 9197 return vreinterpret_s32_u8(a); 9198 } 9199 9200 // CHECK-LABEL: test_vreinterpret_s32_u16 9201 // CHECK-NEXT: ret 9202 int32x2_t test_vreinterpret_s32_u16(uint16x4_t a) { 9203 return vreinterpret_s32_u16(a); 9204 } 9205 9206 // CHECK-LABEL: test_vreinterpret_s32_u32 9207 // CHECK-NEXT: ret 9208 int32x2_t test_vreinterpret_s32_u32(uint32x2_t a) { 9209 return vreinterpret_s32_u32(a); 9210 } 9211 9212 // CHECK-LABEL: test_vreinterpret_s32_u64 9213 // CHECK-NEXT: ret 9214 int32x2_t test_vreinterpret_s32_u64(uint64x1_t a) { 9215 return vreinterpret_s32_u64(a); 9216 } 9217 9218 // CHECK-LABEL: test_vreinterpret_s32_f16 9219 // CHECK-NEXT: ret 9220 int32x2_t test_vreinterpret_s32_f16(float16x4_t a) { 9221 return vreinterpret_s32_f16(a); 9222 } 9223 9224 // CHECK-LABEL: test_vreinterpret_s32_f32 9225 // CHECK-NEXT: ret 9226 int32x2_t test_vreinterpret_s32_f32(float32x2_t a) { 9227 return vreinterpret_s32_f32(a); 9228 } 9229 9230 // CHECK-LABEL: test_vreinterpret_s32_f64 9231 // CHECK-NEXT: ret 9232 int32x2_t test_vreinterpret_s32_f64(float64x1_t a) { 9233 return vreinterpret_s32_f64(a); 9234 } 9235 9236 // CHECK-LABEL: test_vreinterpret_s32_p8 9237 // CHECK-NEXT: ret 9238 int32x2_t test_vreinterpret_s32_p8(poly8x8_t a) { 9239 return vreinterpret_s32_p8(a); 9240 } 9241 9242 // CHECK-LABEL: test_vreinterpret_s32_p16 9243 // CHECK-NEXT: ret 9244 int32x2_t test_vreinterpret_s32_p16(poly16x4_t a) { 9245 return vreinterpret_s32_p16(a); 9246 } 9247 9248 // CHECK-LABEL: test_vreinterpret_s32_p64 9249 // CHECK-NEXT: ret 9250 int32x2_t test_vreinterpret_s32_p64(poly64x1_t a) { 9251 return vreinterpret_s32_p64(a); 9252 } 9253 9254 // CHECK-LABEL: test_vreinterpret_s64_s8 9255 // CHECK-NEXT: ret 9256 int64x1_t test_vreinterpret_s64_s8(int8x8_t a) { 9257 return vreinterpret_s64_s8(a); 9258 } 9259 9260 // CHECK-LABEL: test_vreinterpret_s64_s16 9261 // CHECK-NEXT: ret 9262 int64x1_t test_vreinterpret_s64_s16(int16x4_t a) { 9263 return vreinterpret_s64_s16(a); 9264 } 9265 9266 // CHECK-LABEL: test_vreinterpret_s64_s32 9267 // CHECK-NEXT: ret 9268 int64x1_t test_vreinterpret_s64_s32(int32x2_t a) { 9269 return vreinterpret_s64_s32(a); 9270 } 9271 9272 // CHECK-LABEL: test_vreinterpret_s64_u8 9273 // CHECK-NEXT: ret 9274 int64x1_t test_vreinterpret_s64_u8(uint8x8_t a) { 9275 return vreinterpret_s64_u8(a); 9276 } 9277 9278 // CHECK-LABEL: test_vreinterpret_s64_u16 9279 // CHECK-NEXT: ret 9280 int64x1_t test_vreinterpret_s64_u16(uint16x4_t a) { 9281 return vreinterpret_s64_u16(a); 9282 } 9283 9284 // CHECK-LABEL: test_vreinterpret_s64_u32 9285 // CHECK-NEXT: ret 9286 int64x1_t test_vreinterpret_s64_u32(uint32x2_t a) { 9287 return vreinterpret_s64_u32(a); 9288 } 9289 9290 // CHECK-LABEL: test_vreinterpret_s64_u64 9291 // CHECK-NEXT: ret 9292 int64x1_t test_vreinterpret_s64_u64(uint64x1_t a) { 9293 return vreinterpret_s64_u64(a); 9294 } 9295 9296 // CHECK-LABEL: test_vreinterpret_s64_f16 9297 // CHECK-NEXT: ret 9298 int64x1_t test_vreinterpret_s64_f16(float16x4_t a) { 9299 return vreinterpret_s64_f16(a); 9300 } 9301 9302 // CHECK-LABEL: test_vreinterpret_s64_f32 9303 // CHECK-NEXT: ret 9304 int64x1_t test_vreinterpret_s64_f32(float32x2_t a) { 9305 return vreinterpret_s64_f32(a); 9306 } 9307 9308 // CHECK-LABEL: test_vreinterpret_s64_f64 9309 // CHECK-NEXT: ret 9310 int64x1_t test_vreinterpret_s64_f64(float64x1_t a) { 9311 return vreinterpret_s64_f64(a); 9312 } 9313 9314 // CHECK-LABEL: test_vreinterpret_s64_p8 9315 // CHECK-NEXT: ret 9316 int64x1_t test_vreinterpret_s64_p8(poly8x8_t a) { 9317 return vreinterpret_s64_p8(a); 9318 } 9319 9320 // CHECK-LABEL: test_vreinterpret_s64_p16 9321 // CHECK-NEXT: ret 9322 int64x1_t test_vreinterpret_s64_p16(poly16x4_t a) { 9323 return vreinterpret_s64_p16(a); 9324 } 9325 9326 // CHECK-LABEL: test_vreinterpret_s64_p64 9327 // CHECK-NEXT: ret 9328 int64x1_t test_vreinterpret_s64_p64(poly64x1_t a) { 9329 return vreinterpret_s64_p64(a); 9330 } 9331 9332 // CHECK-LABEL: test_vreinterpret_u8_s8 9333 // CHECK-NEXT: ret 9334 uint8x8_t test_vreinterpret_u8_s8(int8x8_t a) { 9335 return vreinterpret_u8_s8(a); 9336 } 9337 9338 // CHECK-LABEL: test_vreinterpret_u8_s16 9339 // CHECK-NEXT: ret 9340 uint8x8_t test_vreinterpret_u8_s16(int16x4_t a) { 9341 return vreinterpret_u8_s16(a); 9342 } 9343 9344 // CHECK-LABEL: test_vreinterpret_u8_s32 9345 // CHECK-NEXT: ret 9346 uint8x8_t test_vreinterpret_u8_s32(int32x2_t a) { 9347 return vreinterpret_u8_s32(a); 9348 } 9349 9350 // CHECK-LABEL: test_vreinterpret_u8_s64 9351 // CHECK-NEXT: ret 9352 uint8x8_t test_vreinterpret_u8_s64(int64x1_t a) { 9353 return vreinterpret_u8_s64(a); 9354 } 9355 9356 // CHECK-LABEL: test_vreinterpret_u8_u16 9357 // CHECK-NEXT: ret 9358 uint8x8_t test_vreinterpret_u8_u16(uint16x4_t a) { 9359 return vreinterpret_u8_u16(a); 9360 } 9361 9362 // CHECK-LABEL: test_vreinterpret_u8_u32 9363 // CHECK-NEXT: ret 9364 uint8x8_t test_vreinterpret_u8_u32(uint32x2_t a) { 9365 return vreinterpret_u8_u32(a); 9366 } 9367 9368 // CHECK-LABEL: test_vreinterpret_u8_u64 9369 // CHECK-NEXT: ret 9370 uint8x8_t test_vreinterpret_u8_u64(uint64x1_t a) { 9371 return vreinterpret_u8_u64(a); 9372 } 9373 9374 // CHECK-LABEL: test_vreinterpret_u8_f16 9375 // CHECK-NEXT: ret 9376 uint8x8_t test_vreinterpret_u8_f16(float16x4_t a) { 9377 return vreinterpret_u8_f16(a); 9378 } 9379 9380 // CHECK-LABEL: test_vreinterpret_u8_f32 9381 // CHECK-NEXT: ret 9382 uint8x8_t test_vreinterpret_u8_f32(float32x2_t a) { 9383 return vreinterpret_u8_f32(a); 9384 } 9385 9386 // CHECK-LABEL: test_vreinterpret_u8_f64 9387 // CHECK-NEXT: ret 9388 uint8x8_t test_vreinterpret_u8_f64(float64x1_t a) { 9389 return vreinterpret_u8_f64(a); 9390 } 9391 9392 // CHECK-LABEL: test_vreinterpret_u8_p8 9393 // CHECK-NEXT: ret 9394 uint8x8_t test_vreinterpret_u8_p8(poly8x8_t a) { 9395 return vreinterpret_u8_p8(a); 9396 } 9397 9398 // CHECK-LABEL: test_vreinterpret_u8_p16 9399 // CHECK-NEXT: ret 9400 uint8x8_t test_vreinterpret_u8_p16(poly16x4_t a) { 9401 return vreinterpret_u8_p16(a); 9402 } 9403 9404 // CHECK-LABEL: test_vreinterpret_u8_p64 9405 // CHECK-NEXT: ret 9406 uint8x8_t test_vreinterpret_u8_p64(poly64x1_t a) { 9407 return vreinterpret_u8_p64(a); 9408 } 9409 9410 // CHECK-LABEL: test_vreinterpret_u16_s8 9411 // CHECK-NEXT: ret 9412 uint16x4_t test_vreinterpret_u16_s8(int8x8_t a) { 9413 return vreinterpret_u16_s8(a); 9414 } 9415 9416 // CHECK-LABEL: test_vreinterpret_u16_s16 9417 // CHECK-NEXT: ret 9418 uint16x4_t test_vreinterpret_u16_s16(int16x4_t a) { 9419 return vreinterpret_u16_s16(a); 9420 } 9421 9422 // CHECK-LABEL: test_vreinterpret_u16_s32 9423 // CHECK-NEXT: ret 9424 uint16x4_t test_vreinterpret_u16_s32(int32x2_t a) { 9425 return vreinterpret_u16_s32(a); 9426 } 9427 9428 // CHECK-LABEL: test_vreinterpret_u16_s64 9429 // CHECK-NEXT: ret 9430 uint16x4_t test_vreinterpret_u16_s64(int64x1_t a) { 9431 return vreinterpret_u16_s64(a); 9432 } 9433 9434 // CHECK-LABEL: test_vreinterpret_u16_u8 9435 // CHECK-NEXT: ret 9436 uint16x4_t test_vreinterpret_u16_u8(uint8x8_t a) { 9437 return vreinterpret_u16_u8(a); 9438 } 9439 9440 // CHECK-LABEL: test_vreinterpret_u16_u32 9441 // CHECK-NEXT: ret 9442 uint16x4_t test_vreinterpret_u16_u32(uint32x2_t a) { 9443 return vreinterpret_u16_u32(a); 9444 } 9445 9446 // CHECK-LABEL: test_vreinterpret_u16_u64 9447 // CHECK-NEXT: ret 9448 uint16x4_t test_vreinterpret_u16_u64(uint64x1_t a) { 9449 return vreinterpret_u16_u64(a); 9450 } 9451 9452 // CHECK-LABEL: test_vreinterpret_u16_f16 9453 // CHECK-NEXT: ret 9454 uint16x4_t test_vreinterpret_u16_f16(float16x4_t a) { 9455 return vreinterpret_u16_f16(a); 9456 } 9457 9458 // CHECK-LABEL: test_vreinterpret_u16_f32 9459 // CHECK-NEXT: ret 9460 uint16x4_t test_vreinterpret_u16_f32(float32x2_t a) { 9461 return vreinterpret_u16_f32(a); 9462 } 9463 9464 // CHECK-LABEL: test_vreinterpret_u16_f64 9465 // CHECK-NEXT: ret 9466 uint16x4_t test_vreinterpret_u16_f64(float64x1_t a) { 9467 return vreinterpret_u16_f64(a); 9468 } 9469 9470 // CHECK-LABEL: test_vreinterpret_u16_p8 9471 // CHECK-NEXT: ret 9472 uint16x4_t test_vreinterpret_u16_p8(poly8x8_t a) { 9473 return vreinterpret_u16_p8(a); 9474 } 9475 9476 // CHECK-LABEL: test_vreinterpret_u16_p16 9477 // CHECK-NEXT: ret 9478 uint16x4_t test_vreinterpret_u16_p16(poly16x4_t a) { 9479 return vreinterpret_u16_p16(a); 9480 } 9481 9482 // CHECK-LABEL: test_vreinterpret_u16_p64 9483 // CHECK-NEXT: ret 9484 uint16x4_t test_vreinterpret_u16_p64(poly64x1_t a) { 9485 return vreinterpret_u16_p64(a); 9486 } 9487 9488 // CHECK-LABEL: test_vreinterpret_u32_s8 9489 // CHECK-NEXT: ret 9490 uint32x2_t test_vreinterpret_u32_s8(int8x8_t a) { 9491 return vreinterpret_u32_s8(a); 9492 } 9493 9494 // CHECK-LABEL: test_vreinterpret_u32_s16 9495 // CHECK-NEXT: ret 9496 uint32x2_t test_vreinterpret_u32_s16(int16x4_t a) { 9497 return vreinterpret_u32_s16(a); 9498 } 9499 9500 // CHECK-LABEL: test_vreinterpret_u32_s32 9501 // CHECK-NEXT: ret 9502 uint32x2_t test_vreinterpret_u32_s32(int32x2_t a) { 9503 return vreinterpret_u32_s32(a); 9504 } 9505 9506 // CHECK-LABEL: test_vreinterpret_u32_s64 9507 // CHECK-NEXT: ret 9508 uint32x2_t test_vreinterpret_u32_s64(int64x1_t a) { 9509 return vreinterpret_u32_s64(a); 9510 } 9511 9512 // CHECK-LABEL: test_vreinterpret_u32_u8 9513 // CHECK-NEXT: ret 9514 uint32x2_t test_vreinterpret_u32_u8(uint8x8_t a) { 9515 return vreinterpret_u32_u8(a); 9516 } 9517 9518 // CHECK-LABEL: test_vreinterpret_u32_u16 9519 // CHECK-NEXT: ret 9520 uint32x2_t test_vreinterpret_u32_u16(uint16x4_t a) { 9521 return vreinterpret_u32_u16(a); 9522 } 9523 9524 // CHECK-LABEL: test_vreinterpret_u32_u64 9525 // CHECK-NEXT: ret 9526 uint32x2_t test_vreinterpret_u32_u64(uint64x1_t a) { 9527 return vreinterpret_u32_u64(a); 9528 } 9529 9530 // CHECK-LABEL: test_vreinterpret_u32_f16 9531 // CHECK-NEXT: ret 9532 uint32x2_t test_vreinterpret_u32_f16(float16x4_t a) { 9533 return vreinterpret_u32_f16(a); 9534 } 9535 9536 // CHECK-LABEL: test_vreinterpret_u32_f32 9537 // CHECK-NEXT: ret 9538 uint32x2_t test_vreinterpret_u32_f32(float32x2_t a) { 9539 return vreinterpret_u32_f32(a); 9540 } 9541 9542 // CHECK-LABEL: test_vreinterpret_u32_f64 9543 // CHECK-NEXT: ret 9544 uint32x2_t test_vreinterpret_u32_f64(float64x1_t a) { 9545 return vreinterpret_u32_f64(a); 9546 } 9547 9548 // CHECK-LABEL: test_vreinterpret_u32_p8 9549 // CHECK-NEXT: ret 9550 uint32x2_t test_vreinterpret_u32_p8(poly8x8_t a) { 9551 return vreinterpret_u32_p8(a); 9552 } 9553 9554 // CHECK-LABEL: test_vreinterpret_u32_p16 9555 // CHECK-NEXT: ret 9556 uint32x2_t test_vreinterpret_u32_p16(poly16x4_t a) { 9557 return vreinterpret_u32_p16(a); 9558 } 9559 9560 // CHECK-LABEL: test_vreinterpret_u32_p64 9561 // CHECK-NEXT: ret 9562 uint32x2_t test_vreinterpret_u32_p64(poly64x1_t a) { 9563 return vreinterpret_u32_p64(a); 9564 } 9565 9566 // CHECK-LABEL: test_vreinterpret_u64_s8 9567 // CHECK-NEXT: ret 9568 uint64x1_t test_vreinterpret_u64_s8(int8x8_t a) { 9569 return vreinterpret_u64_s8(a); 9570 } 9571 9572 // CHECK-LABEL: test_vreinterpret_u64_s16 9573 // CHECK-NEXT: ret 9574 uint64x1_t test_vreinterpret_u64_s16(int16x4_t a) { 9575 return vreinterpret_u64_s16(a); 9576 } 9577 9578 // CHECK-LABEL: test_vreinterpret_u64_s32 9579 // CHECK-NEXT: ret 9580 uint64x1_t test_vreinterpret_u64_s32(int32x2_t a) { 9581 return vreinterpret_u64_s32(a); 9582 } 9583 9584 // CHECK-LABEL: test_vreinterpret_u64_s64 9585 // CHECK-NEXT: ret 9586 uint64x1_t test_vreinterpret_u64_s64(int64x1_t a) { 9587 return vreinterpret_u64_s64(a); 9588 } 9589 9590 // CHECK-LABEL: test_vreinterpret_u64_u8 9591 // CHECK-NEXT: ret 9592 uint64x1_t test_vreinterpret_u64_u8(uint8x8_t a) { 9593 return vreinterpret_u64_u8(a); 9594 } 9595 9596 // CHECK-LABEL: test_vreinterpret_u64_u16 9597 // CHECK-NEXT: ret 9598 uint64x1_t test_vreinterpret_u64_u16(uint16x4_t a) { 9599 return vreinterpret_u64_u16(a); 9600 } 9601 9602 // CHECK-LABEL: test_vreinterpret_u64_u32 9603 // CHECK-NEXT: ret 9604 uint64x1_t test_vreinterpret_u64_u32(uint32x2_t a) { 9605 return vreinterpret_u64_u32(a); 9606 } 9607 9608 // CHECK-LABEL: test_vreinterpret_u64_f16 9609 // CHECK-NEXT: ret 9610 uint64x1_t test_vreinterpret_u64_f16(float16x4_t a) { 9611 return vreinterpret_u64_f16(a); 9612 } 9613 9614 // CHECK-LABEL: test_vreinterpret_u64_f32 9615 // CHECK-NEXT: ret 9616 uint64x1_t test_vreinterpret_u64_f32(float32x2_t a) { 9617 return vreinterpret_u64_f32(a); 9618 } 9619 9620 // CHECK-LABEL: test_vreinterpret_u64_f64 9621 // CHECK-NEXT: ret 9622 uint64x1_t test_vreinterpret_u64_f64(float64x1_t a) { 9623 return vreinterpret_u64_f64(a); 9624 } 9625 9626 // CHECK-LABEL: test_vreinterpret_u64_p8 9627 // CHECK-NEXT: ret 9628 uint64x1_t test_vreinterpret_u64_p8(poly8x8_t a) { 9629 return vreinterpret_u64_p8(a); 9630 } 9631 9632 // CHECK-LABEL: test_vreinterpret_u64_p16 9633 // CHECK-NEXT: ret 9634 uint64x1_t test_vreinterpret_u64_p16(poly16x4_t a) { 9635 return vreinterpret_u64_p16(a); 9636 } 9637 9638 // CHECK-LABEL: test_vreinterpret_u64_p64 9639 // CHECK-NEXT: ret 9640 uint64x1_t test_vreinterpret_u64_p64(poly64x1_t a) { 9641 return vreinterpret_u64_p64(a); 9642 } 9643 9644 // CHECK-LABEL: test_vreinterpret_f16_s8 9645 // CHECK-NEXT: ret 9646 float16x4_t test_vreinterpret_f16_s8(int8x8_t a) { 9647 return vreinterpret_f16_s8(a); 9648 } 9649 9650 // CHECK-LABEL: test_vreinterpret_f16_s16 9651 // CHECK-NEXT: ret 9652 float16x4_t test_vreinterpret_f16_s16(int16x4_t a) { 9653 return vreinterpret_f16_s16(a); 9654 } 9655 9656 // CHECK-LABEL: test_vreinterpret_f16_s32 9657 // CHECK-NEXT: ret 9658 float16x4_t test_vreinterpret_f16_s32(int32x2_t a) { 9659 return vreinterpret_f16_s32(a); 9660 } 9661 9662 // CHECK-LABEL: test_vreinterpret_f16_s64 9663 // CHECK-NEXT: ret 9664 float16x4_t test_vreinterpret_f16_s64(int64x1_t a) { 9665 return vreinterpret_f16_s64(a); 9666 } 9667 9668 // CHECK-LABEL: test_vreinterpret_f16_u8 9669 // CHECK-NEXT: ret 9670 float16x4_t test_vreinterpret_f16_u8(uint8x8_t a) { 9671 return vreinterpret_f16_u8(a); 9672 } 9673 9674 // CHECK-LABEL: test_vreinterpret_f16_u16 9675 // CHECK-NEXT: ret 9676 float16x4_t test_vreinterpret_f16_u16(uint16x4_t a) { 9677 return vreinterpret_f16_u16(a); 9678 } 9679 9680 // CHECK-LABEL: test_vreinterpret_f16_u32 9681 // CHECK-NEXT: ret 9682 float16x4_t test_vreinterpret_f16_u32(uint32x2_t a) { 9683 return vreinterpret_f16_u32(a); 9684 } 9685 9686 // CHECK-LABEL: test_vreinterpret_f16_u64 9687 // CHECK-NEXT: ret 9688 float16x4_t test_vreinterpret_f16_u64(uint64x1_t a) { 9689 return vreinterpret_f16_u64(a); 9690 } 9691 9692 // CHECK-LABEL: test_vreinterpret_f16_f32 9693 // CHECK-NEXT: ret 9694 float16x4_t test_vreinterpret_f16_f32(float32x2_t a) { 9695 return vreinterpret_f16_f32(a); 9696 } 9697 9698 // CHECK-LABEL: test_vreinterpret_f16_f64 9699 // CHECK-NEXT: ret 9700 float16x4_t test_vreinterpret_f16_f64(float64x1_t a) { 9701 return vreinterpret_f16_f64(a); 9702 } 9703 9704 // CHECK-LABEL: test_vreinterpret_f16_p8 9705 // CHECK-NEXT: ret 9706 float16x4_t test_vreinterpret_f16_p8(poly8x8_t a) { 9707 return vreinterpret_f16_p8(a); 9708 } 9709 9710 // CHECK-LABEL: test_vreinterpret_f16_p16 9711 // CHECK-NEXT: ret 9712 float16x4_t test_vreinterpret_f16_p16(poly16x4_t a) { 9713 return vreinterpret_f16_p16(a); 9714 } 9715 9716 // CHECK-LABEL: test_vreinterpret_f16_p64 9717 // CHECK-NEXT: ret 9718 float16x4_t test_vreinterpret_f16_p64(poly64x1_t a) { 9719 return vreinterpret_f16_p64(a); 9720 } 9721 9722 // CHECK-LABEL: test_vreinterpret_f32_s8 9723 // CHECK-NEXT: ret 9724 float32x2_t test_vreinterpret_f32_s8(int8x8_t a) { 9725 return vreinterpret_f32_s8(a); 9726 } 9727 9728 // CHECK-LABEL: test_vreinterpret_f32_s16 9729 // CHECK-NEXT: ret 9730 float32x2_t test_vreinterpret_f32_s16(int16x4_t a) { 9731 return vreinterpret_f32_s16(a); 9732 } 9733 9734 // CHECK-LABEL: test_vreinterpret_f32_s32 9735 // CHECK-NEXT: ret 9736 float32x2_t test_vreinterpret_f32_s32(int32x2_t a) { 9737 return vreinterpret_f32_s32(a); 9738 } 9739 9740 // CHECK-LABEL: test_vreinterpret_f32_s64 9741 // CHECK-NEXT: ret 9742 float32x2_t test_vreinterpret_f32_s64(int64x1_t a) { 9743 return vreinterpret_f32_s64(a); 9744 } 9745 9746 // CHECK-LABEL: test_vreinterpret_f32_u8 9747 // CHECK-NEXT: ret 9748 float32x2_t test_vreinterpret_f32_u8(uint8x8_t a) { 9749 return vreinterpret_f32_u8(a); 9750 } 9751 9752 // CHECK-LABEL: test_vreinterpret_f32_u16 9753 // CHECK-NEXT: ret 9754 float32x2_t test_vreinterpret_f32_u16(uint16x4_t a) { 9755 return vreinterpret_f32_u16(a); 9756 } 9757 9758 // CHECK-LABEL: test_vreinterpret_f32_u32 9759 // CHECK-NEXT: ret 9760 float32x2_t test_vreinterpret_f32_u32(uint32x2_t a) { 9761 return vreinterpret_f32_u32(a); 9762 } 9763 9764 // CHECK-LABEL: test_vreinterpret_f32_u64 9765 // CHECK-NEXT: ret 9766 float32x2_t test_vreinterpret_f32_u64(uint64x1_t a) { 9767 return vreinterpret_f32_u64(a); 9768 } 9769 9770 // CHECK-LABEL: test_vreinterpret_f32_f16 9771 // CHECK-NEXT: ret 9772 float32x2_t test_vreinterpret_f32_f16(float16x4_t a) { 9773 return vreinterpret_f32_f16(a); 9774 } 9775 9776 // CHECK-LABEL: test_vreinterpret_f32_f64 9777 // CHECK-NEXT: ret 9778 float32x2_t test_vreinterpret_f32_f64(float64x1_t a) { 9779 return vreinterpret_f32_f64(a); 9780 } 9781 9782 // CHECK-LABEL: test_vreinterpret_f32_p8 9783 // CHECK-NEXT: ret 9784 float32x2_t test_vreinterpret_f32_p8(poly8x8_t a) { 9785 return vreinterpret_f32_p8(a); 9786 } 9787 9788 // CHECK-LABEL: test_vreinterpret_f32_p16 9789 // CHECK-NEXT: ret 9790 float32x2_t test_vreinterpret_f32_p16(poly16x4_t a) { 9791 return vreinterpret_f32_p16(a); 9792 } 9793 9794 // CHECK-LABEL: test_vreinterpret_f32_p64 9795 // CHECK-NEXT: ret 9796 float32x2_t test_vreinterpret_f32_p64(poly64x1_t a) { 9797 return vreinterpret_f32_p64(a); 9798 } 9799 9800 // CHECK-LABEL: test_vreinterpret_f64_s8 9801 // CHECK-NEXT: ret 9802 float64x1_t test_vreinterpret_f64_s8(int8x8_t a) { 9803 return vreinterpret_f64_s8(a); 9804 } 9805 9806 // CHECK-LABEL: test_vreinterpret_f64_s16 9807 // CHECK-NEXT: ret 9808 float64x1_t test_vreinterpret_f64_s16(int16x4_t a) { 9809 return vreinterpret_f64_s16(a); 9810 } 9811 9812 // CHECK-LABEL: test_vreinterpret_f64_s32 9813 // CHECK-NEXT: ret 9814 float64x1_t test_vreinterpret_f64_s32(int32x2_t a) { 9815 return vreinterpret_f64_s32(a); 9816 } 9817 9818 // CHECK-LABEL: test_vreinterpret_f64_s64 9819 // CHECK-NEXT: ret 9820 float64x1_t test_vreinterpret_f64_s64(int64x1_t a) { 9821 return vreinterpret_f64_s64(a); 9822 } 9823 9824 // CHECK-LABEL: test_vreinterpret_f64_u8 9825 // CHECK-NEXT: ret 9826 float64x1_t test_vreinterpret_f64_u8(uint8x8_t a) { 9827 return vreinterpret_f64_u8(a); 9828 } 9829 9830 // CHECK-LABEL: test_vreinterpret_f64_u16 9831 // CHECK-NEXT: ret 9832 float64x1_t test_vreinterpret_f64_u16(uint16x4_t a) { 9833 return vreinterpret_f64_u16(a); 9834 } 9835 9836 // CHECK-LABEL: test_vreinterpret_f64_u32 9837 // CHECK-NEXT: ret 9838 float64x1_t test_vreinterpret_f64_u32(uint32x2_t a) { 9839 return vreinterpret_f64_u32(a); 9840 } 9841 9842 // CHECK-LABEL: test_vreinterpret_f64_u64 9843 // CHECK-NEXT: ret 9844 float64x1_t test_vreinterpret_f64_u64(uint64x1_t a) { 9845 return vreinterpret_f64_u64(a); 9846 } 9847 9848 // CHECK-LABEL: test_vreinterpret_f64_f16 9849 // CHECK-NEXT: ret 9850 float64x1_t test_vreinterpret_f64_f16(float16x4_t a) { 9851 return vreinterpret_f64_f16(a); 9852 } 9853 9854 // CHECK-LABEL: test_vreinterpret_f64_f32 9855 // CHECK-NEXT: ret 9856 float64x1_t test_vreinterpret_f64_f32(float32x2_t a) { 9857 return vreinterpret_f64_f32(a); 9858 } 9859 9860 // CHECK-LABEL: test_vreinterpret_f64_p8 9861 // CHECK-NEXT: ret 9862 float64x1_t test_vreinterpret_f64_p8(poly8x8_t a) { 9863 return vreinterpret_f64_p8(a); 9864 } 9865 9866 // CHECK-LABEL: test_vreinterpret_f64_p16 9867 // CHECK-NEXT: ret 9868 float64x1_t test_vreinterpret_f64_p16(poly16x4_t a) { 9869 return vreinterpret_f64_p16(a); 9870 } 9871 9872 // CHECK-LABEL: test_vreinterpret_f64_p64 9873 // CHECK-NEXT: ret 9874 float64x1_t test_vreinterpret_f64_p64(poly64x1_t a) { 9875 return vreinterpret_f64_p64(a); 9876 } 9877 9878 // CHECK-LABEL: test_vreinterpret_p8_s8 9879 // CHECK-NEXT: ret 9880 poly8x8_t test_vreinterpret_p8_s8(int8x8_t a) { 9881 return vreinterpret_p8_s8(a); 9882 } 9883 9884 // CHECK-LABEL: test_vreinterpret_p8_s16 9885 // CHECK-NEXT: ret 9886 poly8x8_t test_vreinterpret_p8_s16(int16x4_t a) { 9887 return vreinterpret_p8_s16(a); 9888 } 9889 9890 // CHECK-LABEL: test_vreinterpret_p8_s32 9891 // CHECK-NEXT: ret 9892 poly8x8_t test_vreinterpret_p8_s32(int32x2_t a) { 9893 return vreinterpret_p8_s32(a); 9894 } 9895 9896 // CHECK-LABEL: test_vreinterpret_p8_s64 9897 // CHECK-NEXT: ret 9898 poly8x8_t test_vreinterpret_p8_s64(int64x1_t a) { 9899 return vreinterpret_p8_s64(a); 9900 } 9901 9902 // CHECK-LABEL: test_vreinterpret_p8_u8 9903 // CHECK-NEXT: ret 9904 poly8x8_t test_vreinterpret_p8_u8(uint8x8_t a) { 9905 return vreinterpret_p8_u8(a); 9906 } 9907 9908 // CHECK-LABEL: test_vreinterpret_p8_u16 9909 // CHECK-NEXT: ret 9910 poly8x8_t test_vreinterpret_p8_u16(uint16x4_t a) { 9911 return vreinterpret_p8_u16(a); 9912 } 9913 9914 // CHECK-LABEL: test_vreinterpret_p8_u32 9915 // CHECK-NEXT: ret 9916 poly8x8_t test_vreinterpret_p8_u32(uint32x2_t a) { 9917 return vreinterpret_p8_u32(a); 9918 } 9919 9920 // CHECK-LABEL: test_vreinterpret_p8_u64 9921 // CHECK-NEXT: ret 9922 poly8x8_t test_vreinterpret_p8_u64(uint64x1_t a) { 9923 return vreinterpret_p8_u64(a); 9924 } 9925 9926 // CHECK-LABEL: test_vreinterpret_p8_f16 9927 // CHECK-NEXT: ret 9928 poly8x8_t test_vreinterpret_p8_f16(float16x4_t a) { 9929 return vreinterpret_p8_f16(a); 9930 } 9931 9932 // CHECK-LABEL: test_vreinterpret_p8_f32 9933 // CHECK-NEXT: ret 9934 poly8x8_t test_vreinterpret_p8_f32(float32x2_t a) { 9935 return vreinterpret_p8_f32(a); 9936 } 9937 9938 // CHECK-LABEL: test_vreinterpret_p8_f64 9939 // CHECK-NEXT: ret 9940 poly8x8_t test_vreinterpret_p8_f64(float64x1_t a) { 9941 return vreinterpret_p8_f64(a); 9942 } 9943 9944 // CHECK-LABEL: test_vreinterpret_p8_p16 9945 // CHECK-NEXT: ret 9946 poly8x8_t test_vreinterpret_p8_p16(poly16x4_t a) { 9947 return vreinterpret_p8_p16(a); 9948 } 9949 9950 // CHECK-LABEL: test_vreinterpret_p8_p64 9951 // CHECK-NEXT: ret 9952 poly8x8_t test_vreinterpret_p8_p64(poly64x1_t a) { 9953 return vreinterpret_p8_p64(a); 9954 } 9955 9956 // CHECK-LABEL: test_vreinterpret_p16_s8 9957 // CHECK-NEXT: ret 9958 poly16x4_t test_vreinterpret_p16_s8(int8x8_t a) { 9959 return vreinterpret_p16_s8(a); 9960 } 9961 9962 // CHECK-LABEL: test_vreinterpret_p16_s16 9963 // CHECK-NEXT: ret 9964 poly16x4_t test_vreinterpret_p16_s16(int16x4_t a) { 9965 return vreinterpret_p16_s16(a); 9966 } 9967 9968 // CHECK-LABEL: test_vreinterpret_p16_s32 9969 // CHECK-NEXT: ret 9970 poly16x4_t test_vreinterpret_p16_s32(int32x2_t a) { 9971 return vreinterpret_p16_s32(a); 9972 } 9973 9974 // CHECK-LABEL: test_vreinterpret_p16_s64 9975 // CHECK-NEXT: ret 9976 poly16x4_t test_vreinterpret_p16_s64(int64x1_t a) { 9977 return vreinterpret_p16_s64(a); 9978 } 9979 9980 // CHECK-LABEL: test_vreinterpret_p16_u8 9981 // CHECK-NEXT: ret 9982 poly16x4_t test_vreinterpret_p16_u8(uint8x8_t a) { 9983 return vreinterpret_p16_u8(a); 9984 } 9985 9986 // CHECK-LABEL: test_vreinterpret_p16_u16 9987 // CHECK-NEXT: ret 9988 poly16x4_t test_vreinterpret_p16_u16(uint16x4_t a) { 9989 return vreinterpret_p16_u16(a); 9990 } 9991 9992 // CHECK-LABEL: test_vreinterpret_p16_u32 9993 // CHECK-NEXT: ret 9994 poly16x4_t test_vreinterpret_p16_u32(uint32x2_t a) { 9995 return vreinterpret_p16_u32(a); 9996 } 9997 9998 // CHECK-LABEL: test_vreinterpret_p16_u64 9999 // CHECK-NEXT: ret 10000 poly16x4_t test_vreinterpret_p16_u64(uint64x1_t a) { 10001 return vreinterpret_p16_u64(a); 10002 } 10003 10004 // CHECK-LABEL: test_vreinterpret_p16_f16 10005 // CHECK-NEXT: ret 10006 poly16x4_t test_vreinterpret_p16_f16(float16x4_t a) { 10007 return vreinterpret_p16_f16(a); 10008 } 10009 10010 // CHECK-LABEL: test_vreinterpret_p16_f32 10011 // CHECK-NEXT: ret 10012 poly16x4_t test_vreinterpret_p16_f32(float32x2_t a) { 10013 return vreinterpret_p16_f32(a); 10014 } 10015 10016 // CHECK-LABEL: test_vreinterpret_p16_f64 10017 // CHECK-NEXT: ret 10018 poly16x4_t test_vreinterpret_p16_f64(float64x1_t a) { 10019 return vreinterpret_p16_f64(a); 10020 } 10021 10022 // CHECK-LABEL: test_vreinterpret_p16_p8 10023 // CHECK-NEXT: ret 10024 poly16x4_t test_vreinterpret_p16_p8(poly8x8_t a) { 10025 return vreinterpret_p16_p8(a); 10026 } 10027 10028 // CHECK-LABEL: test_vreinterpret_p16_p64 10029 // CHECK-NEXT: ret 10030 poly16x4_t test_vreinterpret_p16_p64(poly64x1_t a) { 10031 return vreinterpret_p16_p64(a); 10032 } 10033 10034 // CHECK-LABEL: test_vreinterpret_p64_s8 10035 // CHECK-NEXT: ret 10036 poly64x1_t test_vreinterpret_p64_s8(int8x8_t a) { 10037 return vreinterpret_p64_s8(a); 10038 } 10039 10040 // CHECK-LABEL: test_vreinterpret_p64_s16 10041 // CHECK-NEXT: ret 10042 poly64x1_t test_vreinterpret_p64_s16(int16x4_t a) { 10043 return vreinterpret_p64_s16(a); 10044 } 10045 10046 // CHECK-LABEL: test_vreinterpret_p64_s32 10047 // CHECK-NEXT: ret 10048 poly64x1_t test_vreinterpret_p64_s32(int32x2_t a) { 10049 return vreinterpret_p64_s32(a); 10050 } 10051 10052 // CHECK-LABEL: test_vreinterpret_p64_s64 10053 // CHECK-NEXT: ret 10054 poly64x1_t test_vreinterpret_p64_s64(int64x1_t a) { 10055 return vreinterpret_p64_s64(a); 10056 } 10057 10058 // CHECK-LABEL: test_vreinterpret_p64_u8 10059 // CHECK-NEXT: ret 10060 poly64x1_t test_vreinterpret_p64_u8(uint8x8_t a) { 10061 return vreinterpret_p64_u8(a); 10062 } 10063 10064 // CHECK-LABEL: test_vreinterpret_p64_u16 10065 // CHECK-NEXT: ret 10066 poly64x1_t test_vreinterpret_p64_u16(uint16x4_t a) { 10067 return vreinterpret_p64_u16(a); 10068 } 10069 10070 // CHECK-LABEL: test_vreinterpret_p64_u32 10071 // CHECK-NEXT: ret 10072 poly64x1_t test_vreinterpret_p64_u32(uint32x2_t a) { 10073 return vreinterpret_p64_u32(a); 10074 } 10075 10076 // CHECK-LABEL: test_vreinterpret_p64_u64 10077 // CHECK-NEXT: ret 10078 poly64x1_t test_vreinterpret_p64_u64(uint64x1_t a) { 10079 return vreinterpret_p64_u64(a); 10080 } 10081 10082 // CHECK-LABEL: test_vreinterpret_p64_f16 10083 // CHECK-NEXT: ret 10084 poly64x1_t test_vreinterpret_p64_f16(float16x4_t a) { 10085 return vreinterpret_p64_f16(a); 10086 } 10087 10088 // CHECK-LABEL: test_vreinterpret_p64_f32 10089 // CHECK-NEXT: ret 10090 poly64x1_t test_vreinterpret_p64_f32(float32x2_t a) { 10091 return vreinterpret_p64_f32(a); 10092 } 10093 10094 // CHECK-LABEL: test_vreinterpret_p64_f64 10095 // CHECK-NEXT: ret 10096 poly64x1_t test_vreinterpret_p64_f64(float64x1_t a) { 10097 return vreinterpret_p64_f64(a); 10098 } 10099 10100 // CHECK-LABEL: test_vreinterpret_p64_p8 10101 // CHECK-NEXT: ret 10102 poly64x1_t test_vreinterpret_p64_p8(poly8x8_t a) { 10103 return vreinterpret_p64_p8(a); 10104 } 10105 10106 // CHECK-LABEL: test_vreinterpret_p64_p16 10107 // CHECK-NEXT: ret 10108 poly64x1_t test_vreinterpret_p64_p16(poly16x4_t a) { 10109 return vreinterpret_p64_p16(a); 10110 } 10111 10112 // CHECK-LABEL: test_vreinterpretq_s8_s16 10113 // CHECK-NEXT: ret 10114 int8x16_t test_vreinterpretq_s8_s16(int16x8_t a) { 10115 return vreinterpretq_s8_s16(a); 10116 } 10117 10118 // CHECK-LABEL: test_vreinterpretq_s8_s32 10119 // CHECK-NEXT: ret 10120 int8x16_t test_vreinterpretq_s8_s32(int32x4_t a) { 10121 return vreinterpretq_s8_s32(a); 10122 } 10123 10124 // CHECK-LABEL: test_vreinterpretq_s8_s64 10125 // CHECK-NEXT: ret 10126 int8x16_t test_vreinterpretq_s8_s64(int64x2_t a) { 10127 return vreinterpretq_s8_s64(a); 10128 } 10129 10130 // CHECK-LABEL: test_vreinterpretq_s8_u8 10131 // CHECK-NEXT: ret 10132 int8x16_t test_vreinterpretq_s8_u8(uint8x16_t a) { 10133 return vreinterpretq_s8_u8(a); 10134 } 10135 10136 // CHECK-LABEL: test_vreinterpretq_s8_u16 10137 // CHECK-NEXT: ret 10138 int8x16_t test_vreinterpretq_s8_u16(uint16x8_t a) { 10139 return vreinterpretq_s8_u16(a); 10140 } 10141 10142 // CHECK-LABEL: test_vreinterpretq_s8_u32 10143 // CHECK-NEXT: ret 10144 int8x16_t test_vreinterpretq_s8_u32(uint32x4_t a) { 10145 return vreinterpretq_s8_u32(a); 10146 } 10147 10148 // CHECK-LABEL: test_vreinterpretq_s8_u64 10149 // CHECK-NEXT: ret 10150 int8x16_t test_vreinterpretq_s8_u64(uint64x2_t a) { 10151 return vreinterpretq_s8_u64(a); 10152 } 10153 10154 // CHECK-LABEL: test_vreinterpretq_s8_f16 10155 // CHECK-NEXT: ret 10156 int8x16_t test_vreinterpretq_s8_f16(float16x8_t a) { 10157 return vreinterpretq_s8_f16(a); 10158 } 10159 10160 // CHECK-LABEL: test_vreinterpretq_s8_f32 10161 // CHECK-NEXT: ret 10162 int8x16_t test_vreinterpretq_s8_f32(float32x4_t a) { 10163 return vreinterpretq_s8_f32(a); 10164 } 10165 10166 // CHECK-LABEL: test_vreinterpretq_s8_f64 10167 // CHECK-NEXT: ret 10168 int8x16_t test_vreinterpretq_s8_f64(float64x2_t a) { 10169 return vreinterpretq_s8_f64(a); 10170 } 10171 10172 // CHECK-LABEL: test_vreinterpretq_s8_p8 10173 // CHECK-NEXT: ret 10174 int8x16_t test_vreinterpretq_s8_p8(poly8x16_t a) { 10175 return vreinterpretq_s8_p8(a); 10176 } 10177 10178 // CHECK-LABEL: test_vreinterpretq_s8_p16 10179 // CHECK-NEXT: ret 10180 int8x16_t test_vreinterpretq_s8_p16(poly16x8_t a) { 10181 return vreinterpretq_s8_p16(a); 10182 } 10183 10184 // CHECK-LABEL: test_vreinterpretq_s8_p64 10185 // CHECK-NEXT: ret 10186 int8x16_t test_vreinterpretq_s8_p64(poly64x2_t a) { 10187 return vreinterpretq_s8_p64(a); 10188 } 10189 10190 // CHECK-LABEL: test_vreinterpretq_s16_s8 10191 // CHECK-NEXT: ret 10192 int16x8_t test_vreinterpretq_s16_s8(int8x16_t a) { 10193 return vreinterpretq_s16_s8(a); 10194 } 10195 10196 // CHECK-LABEL: test_vreinterpretq_s16_s32 10197 // CHECK-NEXT: ret 10198 int16x8_t test_vreinterpretq_s16_s32(int32x4_t a) { 10199 return vreinterpretq_s16_s32(a); 10200 } 10201 10202 // CHECK-LABEL: test_vreinterpretq_s16_s64 10203 // CHECK-NEXT: ret 10204 int16x8_t test_vreinterpretq_s16_s64(int64x2_t a) { 10205 return vreinterpretq_s16_s64(a); 10206 } 10207 10208 // CHECK-LABEL: test_vreinterpretq_s16_u8 10209 // CHECK-NEXT: ret 10210 int16x8_t test_vreinterpretq_s16_u8(uint8x16_t a) { 10211 return vreinterpretq_s16_u8(a); 10212 } 10213 10214 // CHECK-LABEL: test_vreinterpretq_s16_u16 10215 // CHECK-NEXT: ret 10216 int16x8_t test_vreinterpretq_s16_u16(uint16x8_t a) { 10217 return vreinterpretq_s16_u16(a); 10218 } 10219 10220 // CHECK-LABEL: test_vreinterpretq_s16_u32 10221 // CHECK-NEXT: ret 10222 int16x8_t test_vreinterpretq_s16_u32(uint32x4_t a) { 10223 return vreinterpretq_s16_u32(a); 10224 } 10225 10226 // CHECK-LABEL: test_vreinterpretq_s16_u64 10227 // CHECK-NEXT: ret 10228 int16x8_t test_vreinterpretq_s16_u64(uint64x2_t a) { 10229 return vreinterpretq_s16_u64(a); 10230 } 10231 10232 // CHECK-LABEL: test_vreinterpretq_s16_f16 10233 // CHECK-NEXT: ret 10234 int16x8_t test_vreinterpretq_s16_f16(float16x8_t a) { 10235 return vreinterpretq_s16_f16(a); 10236 } 10237 10238 // CHECK-LABEL: test_vreinterpretq_s16_f32 10239 // CHECK-NEXT: ret 10240 int16x8_t test_vreinterpretq_s16_f32(float32x4_t a) { 10241 return vreinterpretq_s16_f32(a); 10242 } 10243 10244 // CHECK-LABEL: test_vreinterpretq_s16_f64 10245 // CHECK-NEXT: ret 10246 int16x8_t test_vreinterpretq_s16_f64(float64x2_t a) { 10247 return vreinterpretq_s16_f64(a); 10248 } 10249 10250 // CHECK-LABEL: test_vreinterpretq_s16_p8 10251 // CHECK-NEXT: ret 10252 int16x8_t test_vreinterpretq_s16_p8(poly8x16_t a) { 10253 return vreinterpretq_s16_p8(a); 10254 } 10255 10256 // CHECK-LABEL: test_vreinterpretq_s16_p16 10257 // CHECK-NEXT: ret 10258 int16x8_t test_vreinterpretq_s16_p16(poly16x8_t a) { 10259 return vreinterpretq_s16_p16(a); 10260 } 10261 10262 // CHECK-LABEL: test_vreinterpretq_s16_p64 10263 // CHECK-NEXT: ret 10264 int16x8_t test_vreinterpretq_s16_p64(poly64x2_t a) { 10265 return vreinterpretq_s16_p64(a); 10266 } 10267 10268 // CHECK-LABEL: test_vreinterpretq_s32_s8 10269 // CHECK-NEXT: ret 10270 int32x4_t test_vreinterpretq_s32_s8(int8x16_t a) { 10271 return vreinterpretq_s32_s8(a); 10272 } 10273 10274 // CHECK-LABEL: test_vreinterpretq_s32_s16 10275 // CHECK-NEXT: ret 10276 int32x4_t test_vreinterpretq_s32_s16(int16x8_t a) { 10277 return vreinterpretq_s32_s16(a); 10278 } 10279 10280 // CHECK-LABEL: test_vreinterpretq_s32_s64 10281 // CHECK-NEXT: ret 10282 int32x4_t test_vreinterpretq_s32_s64(int64x2_t a) { 10283 return vreinterpretq_s32_s64(a); 10284 } 10285 10286 // CHECK-LABEL: test_vreinterpretq_s32_u8 10287 // CHECK-NEXT: ret 10288 int32x4_t test_vreinterpretq_s32_u8(uint8x16_t a) { 10289 return vreinterpretq_s32_u8(a); 10290 } 10291 10292 // CHECK-LABEL: test_vreinterpretq_s32_u16 10293 // CHECK-NEXT: ret 10294 int32x4_t test_vreinterpretq_s32_u16(uint16x8_t a) { 10295 return vreinterpretq_s32_u16(a); 10296 } 10297 10298 // CHECK-LABEL: test_vreinterpretq_s32_u32 10299 // CHECK-NEXT: ret 10300 int32x4_t test_vreinterpretq_s32_u32(uint32x4_t a) { 10301 return vreinterpretq_s32_u32(a); 10302 } 10303 10304 // CHECK-LABEL: test_vreinterpretq_s32_u64 10305 // CHECK-NEXT: ret 10306 int32x4_t test_vreinterpretq_s32_u64(uint64x2_t a) { 10307 return vreinterpretq_s32_u64(a); 10308 } 10309 10310 // CHECK-LABEL: test_vreinterpretq_s32_f16 10311 // CHECK-NEXT: ret 10312 int32x4_t test_vreinterpretq_s32_f16(float16x8_t a) { 10313 return vreinterpretq_s32_f16(a); 10314 } 10315 10316 // CHECK-LABEL: test_vreinterpretq_s32_f32 10317 // CHECK-NEXT: ret 10318 int32x4_t test_vreinterpretq_s32_f32(float32x4_t a) { 10319 return vreinterpretq_s32_f32(a); 10320 } 10321 10322 // CHECK-LABEL: test_vreinterpretq_s32_f64 10323 // CHECK-NEXT: ret 10324 int32x4_t test_vreinterpretq_s32_f64(float64x2_t a) { 10325 return vreinterpretq_s32_f64(a); 10326 } 10327 10328 // CHECK-LABEL: test_vreinterpretq_s32_p8 10329 // CHECK-NEXT: ret 10330 int32x4_t test_vreinterpretq_s32_p8(poly8x16_t a) { 10331 return vreinterpretq_s32_p8(a); 10332 } 10333 10334 // CHECK-LABEL: test_vreinterpretq_s32_p16 10335 // CHECK-NEXT: ret 10336 int32x4_t test_vreinterpretq_s32_p16(poly16x8_t a) { 10337 return vreinterpretq_s32_p16(a); 10338 } 10339 10340 // CHECK-LABEL: test_vreinterpretq_s32_p64 10341 // CHECK-NEXT: ret 10342 int32x4_t test_vreinterpretq_s32_p64(poly64x2_t a) { 10343 return vreinterpretq_s32_p64(a); 10344 } 10345 10346 // CHECK-LABEL: test_vreinterpretq_s64_s8 10347 // CHECK-NEXT: ret 10348 int64x2_t test_vreinterpretq_s64_s8(int8x16_t a) { 10349 return vreinterpretq_s64_s8(a); 10350 } 10351 10352 // CHECK-LABEL: test_vreinterpretq_s64_s16 10353 // CHECK-NEXT: ret 10354 int64x2_t test_vreinterpretq_s64_s16(int16x8_t a) { 10355 return vreinterpretq_s64_s16(a); 10356 } 10357 10358 // CHECK-LABEL: test_vreinterpretq_s64_s32 10359 // CHECK-NEXT: ret 10360 int64x2_t test_vreinterpretq_s64_s32(int32x4_t a) { 10361 return vreinterpretq_s64_s32(a); 10362 } 10363 10364 // CHECK-LABEL: test_vreinterpretq_s64_u8 10365 // CHECK-NEXT: ret 10366 int64x2_t test_vreinterpretq_s64_u8(uint8x16_t a) { 10367 return vreinterpretq_s64_u8(a); 10368 } 10369 10370 // CHECK-LABEL: test_vreinterpretq_s64_u16 10371 // CHECK-NEXT: ret 10372 int64x2_t test_vreinterpretq_s64_u16(uint16x8_t a) { 10373 return vreinterpretq_s64_u16(a); 10374 } 10375 10376 // CHECK-LABEL: test_vreinterpretq_s64_u32 10377 // CHECK-NEXT: ret 10378 int64x2_t test_vreinterpretq_s64_u32(uint32x4_t a) { 10379 return vreinterpretq_s64_u32(a); 10380 } 10381 10382 // CHECK-LABEL: test_vreinterpretq_s64_u64 10383 // CHECK-NEXT: ret 10384 int64x2_t test_vreinterpretq_s64_u64(uint64x2_t a) { 10385 return vreinterpretq_s64_u64(a); 10386 } 10387 10388 // CHECK-LABEL: test_vreinterpretq_s64_f16 10389 // CHECK-NEXT: ret 10390 int64x2_t test_vreinterpretq_s64_f16(float16x8_t a) { 10391 return vreinterpretq_s64_f16(a); 10392 } 10393 10394 // CHECK-LABEL: test_vreinterpretq_s64_f32 10395 // CHECK-NEXT: ret 10396 int64x2_t test_vreinterpretq_s64_f32(float32x4_t a) { 10397 return vreinterpretq_s64_f32(a); 10398 } 10399 10400 // CHECK-LABEL: test_vreinterpretq_s64_f64 10401 // CHECK-NEXT: ret 10402 int64x2_t test_vreinterpretq_s64_f64(float64x2_t a) { 10403 return vreinterpretq_s64_f64(a); 10404 } 10405 10406 // CHECK-LABEL: test_vreinterpretq_s64_p8 10407 // CHECK-NEXT: ret 10408 int64x2_t test_vreinterpretq_s64_p8(poly8x16_t a) { 10409 return vreinterpretq_s64_p8(a); 10410 } 10411 10412 // CHECK-LABEL: test_vreinterpretq_s64_p16 10413 // CHECK-NEXT: ret 10414 int64x2_t test_vreinterpretq_s64_p16(poly16x8_t a) { 10415 return vreinterpretq_s64_p16(a); 10416 } 10417 10418 // CHECK-LABEL: test_vreinterpretq_s64_p64 10419 // CHECK-NEXT: ret 10420 int64x2_t test_vreinterpretq_s64_p64(poly64x2_t a) { 10421 return vreinterpretq_s64_p64(a); 10422 } 10423 10424 // CHECK-LABEL: test_vreinterpretq_u8_s8 10425 // CHECK-NEXT: ret 10426 uint8x16_t test_vreinterpretq_u8_s8(int8x16_t a) { 10427 return vreinterpretq_u8_s8(a); 10428 } 10429 10430 // CHECK-LABEL: test_vreinterpretq_u8_s16 10431 // CHECK-NEXT: ret 10432 uint8x16_t test_vreinterpretq_u8_s16(int16x8_t a) { 10433 return vreinterpretq_u8_s16(a); 10434 } 10435 10436 // CHECK-LABEL: test_vreinterpretq_u8_s32 10437 // CHECK-NEXT: ret 10438 uint8x16_t test_vreinterpretq_u8_s32(int32x4_t a) { 10439 return vreinterpretq_u8_s32(a); 10440 } 10441 10442 // CHECK-LABEL: test_vreinterpretq_u8_s64 10443 // CHECK-NEXT: ret 10444 uint8x16_t test_vreinterpretq_u8_s64(int64x2_t a) { 10445 return vreinterpretq_u8_s64(a); 10446 } 10447 10448 // CHECK-LABEL: test_vreinterpretq_u8_u16 10449 // CHECK-NEXT: ret 10450 uint8x16_t test_vreinterpretq_u8_u16(uint16x8_t a) { 10451 return vreinterpretq_u8_u16(a); 10452 } 10453 10454 // CHECK-LABEL: test_vreinterpretq_u8_u32 10455 // CHECK-NEXT: ret 10456 uint8x16_t test_vreinterpretq_u8_u32(uint32x4_t a) { 10457 return vreinterpretq_u8_u32(a); 10458 } 10459 10460 // CHECK-LABEL: test_vreinterpretq_u8_u64 10461 // CHECK-NEXT: ret 10462 uint8x16_t test_vreinterpretq_u8_u64(uint64x2_t a) { 10463 return vreinterpretq_u8_u64(a); 10464 } 10465 10466 // CHECK-LABEL: test_vreinterpretq_u8_f16 10467 // CHECK-NEXT: ret 10468 uint8x16_t test_vreinterpretq_u8_f16(float16x8_t a) { 10469 return vreinterpretq_u8_f16(a); 10470 } 10471 10472 // CHECK-LABEL: test_vreinterpretq_u8_f32 10473 // CHECK-NEXT: ret 10474 uint8x16_t test_vreinterpretq_u8_f32(float32x4_t a) { 10475 return vreinterpretq_u8_f32(a); 10476 } 10477 10478 // CHECK-LABEL: test_vreinterpretq_u8_f64 10479 // CHECK-NEXT: ret 10480 uint8x16_t test_vreinterpretq_u8_f64(float64x2_t a) { 10481 return vreinterpretq_u8_f64(a); 10482 } 10483 10484 // CHECK-LABEL: test_vreinterpretq_u8_p8 10485 // CHECK-NEXT: ret 10486 uint8x16_t test_vreinterpretq_u8_p8(poly8x16_t a) { 10487 return vreinterpretq_u8_p8(a); 10488 } 10489 10490 // CHECK-LABEL: test_vreinterpretq_u8_p16 10491 // CHECK-NEXT: ret 10492 uint8x16_t test_vreinterpretq_u8_p16(poly16x8_t a) { 10493 return vreinterpretq_u8_p16(a); 10494 } 10495 10496 // CHECK-LABEL: test_vreinterpretq_u8_p64 10497 // CHECK-NEXT: ret 10498 uint8x16_t test_vreinterpretq_u8_p64(poly64x2_t a) { 10499 return vreinterpretq_u8_p64(a); 10500 } 10501 10502 // CHECK-LABEL: test_vreinterpretq_u16_s8 10503 // CHECK-NEXT: ret 10504 uint16x8_t test_vreinterpretq_u16_s8(int8x16_t a) { 10505 return vreinterpretq_u16_s8(a); 10506 } 10507 10508 // CHECK-LABEL: test_vreinterpretq_u16_s16 10509 // CHECK-NEXT: ret 10510 uint16x8_t test_vreinterpretq_u16_s16(int16x8_t a) { 10511 return vreinterpretq_u16_s16(a); 10512 } 10513 10514 // CHECK-LABEL: test_vreinterpretq_u16_s32 10515 // CHECK-NEXT: ret 10516 uint16x8_t test_vreinterpretq_u16_s32(int32x4_t a) { 10517 return vreinterpretq_u16_s32(a); 10518 } 10519 10520 // CHECK-LABEL: test_vreinterpretq_u16_s64 10521 // CHECK-NEXT: ret 10522 uint16x8_t test_vreinterpretq_u16_s64(int64x2_t a) { 10523 return vreinterpretq_u16_s64(a); 10524 } 10525 10526 // CHECK-LABEL: test_vreinterpretq_u16_u8 10527 // CHECK-NEXT: ret 10528 uint16x8_t test_vreinterpretq_u16_u8(uint8x16_t a) { 10529 return vreinterpretq_u16_u8(a); 10530 } 10531 10532 // CHECK-LABEL: test_vreinterpretq_u16_u32 10533 // CHECK-NEXT: ret 10534 uint16x8_t test_vreinterpretq_u16_u32(uint32x4_t a) { 10535 return vreinterpretq_u16_u32(a); 10536 } 10537 10538 // CHECK-LABEL: test_vreinterpretq_u16_u64 10539 // CHECK-NEXT: ret 10540 uint16x8_t test_vreinterpretq_u16_u64(uint64x2_t a) { 10541 return vreinterpretq_u16_u64(a); 10542 } 10543 10544 // CHECK-LABEL: test_vreinterpretq_u16_f16 10545 // CHECK-NEXT: ret 10546 uint16x8_t test_vreinterpretq_u16_f16(float16x8_t a) { 10547 return vreinterpretq_u16_f16(a); 10548 } 10549 10550 // CHECK-LABEL: test_vreinterpretq_u16_f32 10551 // CHECK-NEXT: ret 10552 uint16x8_t test_vreinterpretq_u16_f32(float32x4_t a) { 10553 return vreinterpretq_u16_f32(a); 10554 } 10555 10556 // CHECK-LABEL: test_vreinterpretq_u16_f64 10557 // CHECK-NEXT: ret 10558 uint16x8_t test_vreinterpretq_u16_f64(float64x2_t a) { 10559 return vreinterpretq_u16_f64(a); 10560 } 10561 10562 // CHECK-LABEL: test_vreinterpretq_u16_p8 10563 // CHECK-NEXT: ret 10564 uint16x8_t test_vreinterpretq_u16_p8(poly8x16_t a) { 10565 return vreinterpretq_u16_p8(a); 10566 } 10567 10568 // CHECK-LABEL: test_vreinterpretq_u16_p16 10569 // CHECK-NEXT: ret 10570 uint16x8_t test_vreinterpretq_u16_p16(poly16x8_t a) { 10571 return vreinterpretq_u16_p16(a); 10572 } 10573 10574 // CHECK-LABEL: test_vreinterpretq_u16_p64 10575 // CHECK-NEXT: ret 10576 uint16x8_t test_vreinterpretq_u16_p64(poly64x2_t a) { 10577 return vreinterpretq_u16_p64(a); 10578 } 10579 10580 // CHECK-LABEL: test_vreinterpretq_u32_s8 10581 // CHECK-NEXT: ret 10582 uint32x4_t test_vreinterpretq_u32_s8(int8x16_t a) { 10583 return vreinterpretq_u32_s8(a); 10584 } 10585 10586 // CHECK-LABEL: test_vreinterpretq_u32_s16 10587 // CHECK-NEXT: ret 10588 uint32x4_t test_vreinterpretq_u32_s16(int16x8_t a) { 10589 return vreinterpretq_u32_s16(a); 10590 } 10591 10592 // CHECK-LABEL: test_vreinterpretq_u32_s32 10593 // CHECK-NEXT: ret 10594 uint32x4_t test_vreinterpretq_u32_s32(int32x4_t a) { 10595 return vreinterpretq_u32_s32(a); 10596 } 10597 10598 // CHECK-LABEL: test_vreinterpretq_u32_s64 10599 // CHECK-NEXT: ret 10600 uint32x4_t test_vreinterpretq_u32_s64(int64x2_t a) { 10601 return vreinterpretq_u32_s64(a); 10602 } 10603 10604 // CHECK-LABEL: test_vreinterpretq_u32_u8 10605 // CHECK-NEXT: ret 10606 uint32x4_t test_vreinterpretq_u32_u8(uint8x16_t a) { 10607 return vreinterpretq_u32_u8(a); 10608 } 10609 10610 // CHECK-LABEL: test_vreinterpretq_u32_u16 10611 // CHECK-NEXT: ret 10612 uint32x4_t test_vreinterpretq_u32_u16(uint16x8_t a) { 10613 return vreinterpretq_u32_u16(a); 10614 } 10615 10616 // CHECK-LABEL: test_vreinterpretq_u32_u64 10617 // CHECK-NEXT: ret 10618 uint32x4_t test_vreinterpretq_u32_u64(uint64x2_t a) { 10619 return vreinterpretq_u32_u64(a); 10620 } 10621 10622 // CHECK-LABEL: test_vreinterpretq_u32_f16 10623 // CHECK-NEXT: ret 10624 uint32x4_t test_vreinterpretq_u32_f16(float16x8_t a) { 10625 return vreinterpretq_u32_f16(a); 10626 } 10627 10628 // CHECK-LABEL: test_vreinterpretq_u32_f32 10629 // CHECK-NEXT: ret 10630 uint32x4_t test_vreinterpretq_u32_f32(float32x4_t a) { 10631 return vreinterpretq_u32_f32(a); 10632 } 10633 10634 // CHECK-LABEL: test_vreinterpretq_u32_f64 10635 // CHECK-NEXT: ret 10636 uint32x4_t test_vreinterpretq_u32_f64(float64x2_t a) { 10637 return vreinterpretq_u32_f64(a); 10638 } 10639 10640 // CHECK-LABEL: test_vreinterpretq_u32_p8 10641 // CHECK-NEXT: ret 10642 uint32x4_t test_vreinterpretq_u32_p8(poly8x16_t a) { 10643 return vreinterpretq_u32_p8(a); 10644 } 10645 10646 // CHECK-LABEL: test_vreinterpretq_u32_p16 10647 // CHECK-NEXT: ret 10648 uint32x4_t test_vreinterpretq_u32_p16(poly16x8_t a) { 10649 return vreinterpretq_u32_p16(a); 10650 } 10651 10652 // CHECK-LABEL: test_vreinterpretq_u32_p64 10653 // CHECK-NEXT: ret 10654 uint32x4_t test_vreinterpretq_u32_p64(poly64x2_t a) { 10655 return vreinterpretq_u32_p64(a); 10656 } 10657 10658 // CHECK-LABEL: test_vreinterpretq_u64_s8 10659 // CHECK-NEXT: ret 10660 uint64x2_t test_vreinterpretq_u64_s8(int8x16_t a) { 10661 return vreinterpretq_u64_s8(a); 10662 } 10663 10664 // CHECK-LABEL: test_vreinterpretq_u64_s16 10665 // CHECK-NEXT: ret 10666 uint64x2_t test_vreinterpretq_u64_s16(int16x8_t a) { 10667 return vreinterpretq_u64_s16(a); 10668 } 10669 10670 // CHECK-LABEL: test_vreinterpretq_u64_s32 10671 // CHECK-NEXT: ret 10672 uint64x2_t test_vreinterpretq_u64_s32(int32x4_t a) { 10673 return vreinterpretq_u64_s32(a); 10674 } 10675 10676 // CHECK-LABEL: test_vreinterpretq_u64_s64 10677 // CHECK-NEXT: ret 10678 uint64x2_t test_vreinterpretq_u64_s64(int64x2_t a) { 10679 return vreinterpretq_u64_s64(a); 10680 } 10681 10682 // CHECK-LABEL: test_vreinterpretq_u64_u8 10683 // CHECK-NEXT: ret 10684 uint64x2_t test_vreinterpretq_u64_u8(uint8x16_t a) { 10685 return vreinterpretq_u64_u8(a); 10686 } 10687 10688 // CHECK-LABEL: test_vreinterpretq_u64_u16 10689 // CHECK-NEXT: ret 10690 uint64x2_t test_vreinterpretq_u64_u16(uint16x8_t a) { 10691 return vreinterpretq_u64_u16(a); 10692 } 10693 10694 // CHECK-LABEL: test_vreinterpretq_u64_u32 10695 // CHECK-NEXT: ret 10696 uint64x2_t test_vreinterpretq_u64_u32(uint32x4_t a) { 10697 return vreinterpretq_u64_u32(a); 10698 } 10699 10700 // CHECK-LABEL: test_vreinterpretq_u64_f16 10701 // CHECK-NEXT: ret 10702 uint64x2_t test_vreinterpretq_u64_f16(float16x8_t a) { 10703 return vreinterpretq_u64_f16(a); 10704 } 10705 10706 // CHECK-LABEL: test_vreinterpretq_u64_f32 10707 // CHECK-NEXT: ret 10708 uint64x2_t test_vreinterpretq_u64_f32(float32x4_t a) { 10709 return vreinterpretq_u64_f32(a); 10710 } 10711 10712 // CHECK-LABEL: test_vreinterpretq_u64_f64 10713 // CHECK-NEXT: ret 10714 uint64x2_t test_vreinterpretq_u64_f64(float64x2_t a) { 10715 return vreinterpretq_u64_f64(a); 10716 } 10717 10718 // CHECK-LABEL: test_vreinterpretq_u64_p8 10719 // CHECK-NEXT: ret 10720 uint64x2_t test_vreinterpretq_u64_p8(poly8x16_t a) { 10721 return vreinterpretq_u64_p8(a); 10722 } 10723 10724 // CHECK-LABEL: test_vreinterpretq_u64_p16 10725 // CHECK-NEXT: ret 10726 uint64x2_t test_vreinterpretq_u64_p16(poly16x8_t a) { 10727 return vreinterpretq_u64_p16(a); 10728 } 10729 10730 // CHECK-LABEL: test_vreinterpretq_u64_p64 10731 // CHECK-NEXT: ret 10732 uint64x2_t test_vreinterpretq_u64_p64(poly64x2_t a) { 10733 return vreinterpretq_u64_p64(a); 10734 } 10735 10736 // CHECK-LABEL: test_vreinterpretq_f16_s8 10737 // CHECK-NEXT: ret 10738 float16x8_t test_vreinterpretq_f16_s8(int8x16_t a) { 10739 return vreinterpretq_f16_s8(a); 10740 } 10741 10742 // CHECK-LABEL: test_vreinterpretq_f16_s16 10743 // CHECK-NEXT: ret 10744 float16x8_t test_vreinterpretq_f16_s16(int16x8_t a) { 10745 return vreinterpretq_f16_s16(a); 10746 } 10747 10748 // CHECK-LABEL: test_vreinterpretq_f16_s32 10749 // CHECK-NEXT: ret 10750 float16x8_t test_vreinterpretq_f16_s32(int32x4_t a) { 10751 return vreinterpretq_f16_s32(a); 10752 } 10753 10754 // CHECK-LABEL: test_vreinterpretq_f16_s64 10755 // CHECK-NEXT: ret 10756 float16x8_t test_vreinterpretq_f16_s64(int64x2_t a) { 10757 return vreinterpretq_f16_s64(a); 10758 } 10759 10760 // CHECK-LABEL: test_vreinterpretq_f16_u8 10761 // CHECK-NEXT: ret 10762 float16x8_t test_vreinterpretq_f16_u8(uint8x16_t a) { 10763 return vreinterpretq_f16_u8(a); 10764 } 10765 10766 // CHECK-LABEL: test_vreinterpretq_f16_u16 10767 // CHECK-NEXT: ret 10768 float16x8_t test_vreinterpretq_f16_u16(uint16x8_t a) { 10769 return vreinterpretq_f16_u16(a); 10770 } 10771 10772 // CHECK-LABEL: test_vreinterpretq_f16_u32 10773 // CHECK-NEXT: ret 10774 float16x8_t test_vreinterpretq_f16_u32(uint32x4_t a) { 10775 return vreinterpretq_f16_u32(a); 10776 } 10777 10778 // CHECK-LABEL: test_vreinterpretq_f16_u64 10779 // CHECK-NEXT: ret 10780 float16x8_t test_vreinterpretq_f16_u64(uint64x2_t a) { 10781 return vreinterpretq_f16_u64(a); 10782 } 10783 10784 // CHECK-LABEL: test_vreinterpretq_f16_f32 10785 // CHECK-NEXT: ret 10786 float16x8_t test_vreinterpretq_f16_f32(float32x4_t a) { 10787 return vreinterpretq_f16_f32(a); 10788 } 10789 10790 // CHECK-LABEL: test_vreinterpretq_f16_f64 10791 // CHECK-NEXT: ret 10792 float16x8_t test_vreinterpretq_f16_f64(float64x2_t a) { 10793 return vreinterpretq_f16_f64(a); 10794 } 10795 10796 // CHECK-LABEL: test_vreinterpretq_f16_p8 10797 // CHECK-NEXT: ret 10798 float16x8_t test_vreinterpretq_f16_p8(poly8x16_t a) { 10799 return vreinterpretq_f16_p8(a); 10800 } 10801 10802 // CHECK-LABEL: test_vreinterpretq_f16_p16 10803 // CHECK-NEXT: ret 10804 float16x8_t test_vreinterpretq_f16_p16(poly16x8_t a) { 10805 return vreinterpretq_f16_p16(a); 10806 } 10807 10808 // CHECK-LABEL: test_vreinterpretq_f16_p64 10809 // CHECK-NEXT: ret 10810 float16x8_t test_vreinterpretq_f16_p64(poly64x2_t a) { 10811 return vreinterpretq_f16_p64(a); 10812 } 10813 10814 // CHECK-LABEL: test_vreinterpretq_f32_s8 10815 // CHECK-NEXT: ret 10816 float32x4_t test_vreinterpretq_f32_s8(int8x16_t a) { 10817 return vreinterpretq_f32_s8(a); 10818 } 10819 10820 // CHECK-LABEL: test_vreinterpretq_f32_s16 10821 // CHECK-NEXT: ret 10822 float32x4_t test_vreinterpretq_f32_s16(int16x8_t a) { 10823 return vreinterpretq_f32_s16(a); 10824 } 10825 10826 // CHECK-LABEL: test_vreinterpretq_f32_s32 10827 // CHECK-NEXT: ret 10828 float32x4_t test_vreinterpretq_f32_s32(int32x4_t a) { 10829 return vreinterpretq_f32_s32(a); 10830 } 10831 10832 // CHECK-LABEL: test_vreinterpretq_f32_s64 10833 // CHECK-NEXT: ret 10834 float32x4_t test_vreinterpretq_f32_s64(int64x2_t a) { 10835 return vreinterpretq_f32_s64(a); 10836 } 10837 10838 // CHECK-LABEL: test_vreinterpretq_f32_u8 10839 // CHECK-NEXT: ret 10840 float32x4_t test_vreinterpretq_f32_u8(uint8x16_t a) { 10841 return vreinterpretq_f32_u8(a); 10842 } 10843 10844 // CHECK-LABEL: test_vreinterpretq_f32_u16 10845 // CHECK-NEXT: ret 10846 float32x4_t test_vreinterpretq_f32_u16(uint16x8_t a) { 10847 return vreinterpretq_f32_u16(a); 10848 } 10849 10850 // CHECK-LABEL: test_vreinterpretq_f32_u32 10851 // CHECK-NEXT: ret 10852 float32x4_t test_vreinterpretq_f32_u32(uint32x4_t a) { 10853 return vreinterpretq_f32_u32(a); 10854 } 10855 10856 // CHECK-LABEL: test_vreinterpretq_f32_u64 10857 // CHECK-NEXT: ret 10858 float32x4_t test_vreinterpretq_f32_u64(uint64x2_t a) { 10859 return vreinterpretq_f32_u64(a); 10860 } 10861 10862 // CHECK-LABEL: test_vreinterpretq_f32_f16 10863 // CHECK-NEXT: ret 10864 float32x4_t test_vreinterpretq_f32_f16(float16x8_t a) { 10865 return vreinterpretq_f32_f16(a); 10866 } 10867 10868 // CHECK-LABEL: test_vreinterpretq_f32_f64 10869 // CHECK-NEXT: ret 10870 float32x4_t test_vreinterpretq_f32_f64(float64x2_t a) { 10871 return vreinterpretq_f32_f64(a); 10872 } 10873 10874 // CHECK-LABEL: test_vreinterpretq_f32_p8 10875 // CHECK-NEXT: ret 10876 float32x4_t test_vreinterpretq_f32_p8(poly8x16_t a) { 10877 return vreinterpretq_f32_p8(a); 10878 } 10879 10880 // CHECK-LABEL: test_vreinterpretq_f32_p16 10881 // CHECK-NEXT: ret 10882 float32x4_t test_vreinterpretq_f32_p16(poly16x8_t a) { 10883 return vreinterpretq_f32_p16(a); 10884 } 10885 10886 // CHECK-LABEL: test_vreinterpretq_f32_p64 10887 // CHECK-NEXT: ret 10888 float32x4_t test_vreinterpretq_f32_p64(poly64x2_t a) { 10889 return vreinterpretq_f32_p64(a); 10890 } 10891 10892 // CHECK-LABEL: test_vreinterpretq_f64_s8 10893 // CHECK-NEXT: ret 10894 float64x2_t test_vreinterpretq_f64_s8(int8x16_t a) { 10895 return vreinterpretq_f64_s8(a); 10896 } 10897 10898 // CHECK-LABEL: test_vreinterpretq_f64_s16 10899 // CHECK-NEXT: ret 10900 float64x2_t test_vreinterpretq_f64_s16(int16x8_t a) { 10901 return vreinterpretq_f64_s16(a); 10902 } 10903 10904 // CHECK-LABEL: test_vreinterpretq_f64_s32 10905 // CHECK-NEXT: ret 10906 float64x2_t test_vreinterpretq_f64_s32(int32x4_t a) { 10907 return vreinterpretq_f64_s32(a); 10908 } 10909 10910 // CHECK-LABEL: test_vreinterpretq_f64_s64 10911 // CHECK-NEXT: ret 10912 float64x2_t test_vreinterpretq_f64_s64(int64x2_t a) { 10913 return vreinterpretq_f64_s64(a); 10914 } 10915 10916 // CHECK-LABEL: test_vreinterpretq_f64_u8 10917 // CHECK-NEXT: ret 10918 float64x2_t test_vreinterpretq_f64_u8(uint8x16_t a) { 10919 return vreinterpretq_f64_u8(a); 10920 } 10921 10922 // CHECK-LABEL: test_vreinterpretq_f64_u16 10923 // CHECK-NEXT: ret 10924 float64x2_t test_vreinterpretq_f64_u16(uint16x8_t a) { 10925 return vreinterpretq_f64_u16(a); 10926 } 10927 10928 // CHECK-LABEL: test_vreinterpretq_f64_u32 10929 // CHECK-NEXT: ret 10930 float64x2_t test_vreinterpretq_f64_u32(uint32x4_t a) { 10931 return vreinterpretq_f64_u32(a); 10932 } 10933 10934 // CHECK-LABEL: test_vreinterpretq_f64_u64 10935 // CHECK-NEXT: ret 10936 float64x2_t test_vreinterpretq_f64_u64(uint64x2_t a) { 10937 return vreinterpretq_f64_u64(a); 10938 } 10939 10940 // CHECK-LABEL: test_vreinterpretq_f64_f16 10941 // CHECK-NEXT: ret 10942 float64x2_t test_vreinterpretq_f64_f16(float16x8_t a) { 10943 return vreinterpretq_f64_f16(a); 10944 } 10945 10946 // CHECK-LABEL: test_vreinterpretq_f64_f32 10947 // CHECK-NEXT: ret 10948 float64x2_t test_vreinterpretq_f64_f32(float32x4_t a) { 10949 return vreinterpretq_f64_f32(a); 10950 } 10951 10952 // CHECK-LABEL: test_vreinterpretq_f64_p8 10953 // CHECK-NEXT: ret 10954 float64x2_t test_vreinterpretq_f64_p8(poly8x16_t a) { 10955 return vreinterpretq_f64_p8(a); 10956 } 10957 10958 // CHECK-LABEL: test_vreinterpretq_f64_p16 10959 // CHECK-NEXT: ret 10960 float64x2_t test_vreinterpretq_f64_p16(poly16x8_t a) { 10961 return vreinterpretq_f64_p16(a); 10962 } 10963 10964 // CHECK-LABEL: test_vreinterpretq_f64_p64 10965 // CHECK-NEXT: ret 10966 float64x2_t test_vreinterpretq_f64_p64(poly64x2_t a) { 10967 return vreinterpretq_f64_p64(a); 10968 } 10969 10970 // CHECK-LABEL: test_vreinterpretq_p8_s8 10971 // CHECK-NEXT: ret 10972 poly8x16_t test_vreinterpretq_p8_s8(int8x16_t a) { 10973 return vreinterpretq_p8_s8(a); 10974 } 10975 10976 // CHECK-LABEL: test_vreinterpretq_p8_s16 10977 // CHECK-NEXT: ret 10978 poly8x16_t test_vreinterpretq_p8_s16(int16x8_t a) { 10979 return vreinterpretq_p8_s16(a); 10980 } 10981 10982 // CHECK-LABEL: test_vreinterpretq_p8_s32 10983 // CHECK-NEXT: ret 10984 poly8x16_t test_vreinterpretq_p8_s32(int32x4_t a) { 10985 return vreinterpretq_p8_s32(a); 10986 } 10987 10988 // CHECK-LABEL: test_vreinterpretq_p8_s64 10989 // CHECK-NEXT: ret 10990 poly8x16_t test_vreinterpretq_p8_s64(int64x2_t a) { 10991 return vreinterpretq_p8_s64(a); 10992 } 10993 10994 // CHECK-LABEL: test_vreinterpretq_p8_u8 10995 // CHECK-NEXT: ret 10996 poly8x16_t test_vreinterpretq_p8_u8(uint8x16_t a) { 10997 return vreinterpretq_p8_u8(a); 10998 } 10999 11000 // CHECK-LABEL: test_vreinterpretq_p8_u16 11001 // CHECK-NEXT: ret 11002 poly8x16_t test_vreinterpretq_p8_u16(uint16x8_t a) { 11003 return vreinterpretq_p8_u16(a); 11004 } 11005 11006 // CHECK-LABEL: test_vreinterpretq_p8_u32 11007 // CHECK-NEXT: ret 11008 poly8x16_t test_vreinterpretq_p8_u32(uint32x4_t a) { 11009 return vreinterpretq_p8_u32(a); 11010 } 11011 11012 // CHECK-LABEL: test_vreinterpretq_p8_u64 11013 // CHECK-NEXT: ret 11014 poly8x16_t test_vreinterpretq_p8_u64(uint64x2_t a) { 11015 return vreinterpretq_p8_u64(a); 11016 } 11017 11018 // CHECK-LABEL: test_vreinterpretq_p8_f16 11019 // CHECK-NEXT: ret 11020 poly8x16_t test_vreinterpretq_p8_f16(float16x8_t a) { 11021 return vreinterpretq_p8_f16(a); 11022 } 11023 11024 // CHECK-LABEL: test_vreinterpretq_p8_f32 11025 // CHECK-NEXT: ret 11026 poly8x16_t test_vreinterpretq_p8_f32(float32x4_t a) { 11027 return vreinterpretq_p8_f32(a); 11028 } 11029 11030 // CHECK-LABEL: test_vreinterpretq_p8_f64 11031 // CHECK-NEXT: ret 11032 poly8x16_t test_vreinterpretq_p8_f64(float64x2_t a) { 11033 return vreinterpretq_p8_f64(a); 11034 } 11035 11036 // CHECK-LABEL: test_vreinterpretq_p8_p16 11037 // CHECK-NEXT: ret 11038 poly8x16_t test_vreinterpretq_p8_p16(poly16x8_t a) { 11039 return vreinterpretq_p8_p16(a); 11040 } 11041 11042 // CHECK-LABEL: test_vreinterpretq_p8_p64 11043 // CHECK-NEXT: ret 11044 poly8x16_t test_vreinterpretq_p8_p64(poly64x2_t a) { 11045 return vreinterpretq_p8_p64(a); 11046 } 11047 11048 // CHECK-LABEL: test_vreinterpretq_p16_s8 11049 // CHECK-NEXT: ret 11050 poly16x8_t test_vreinterpretq_p16_s8(int8x16_t a) { 11051 return vreinterpretq_p16_s8(a); 11052 } 11053 11054 // CHECK-LABEL: test_vreinterpretq_p16_s16 11055 // CHECK-NEXT: ret 11056 poly16x8_t test_vreinterpretq_p16_s16(int16x8_t a) { 11057 return vreinterpretq_p16_s16(a); 11058 } 11059 11060 // CHECK-LABEL: test_vreinterpretq_p16_s32 11061 // CHECK-NEXT: ret 11062 poly16x8_t test_vreinterpretq_p16_s32(int32x4_t a) { 11063 return vreinterpretq_p16_s32(a); 11064 } 11065 11066 // CHECK-LABEL: test_vreinterpretq_p16_s64 11067 // CHECK-NEXT: ret 11068 poly16x8_t test_vreinterpretq_p16_s64(int64x2_t a) { 11069 return vreinterpretq_p16_s64(a); 11070 } 11071 11072 // CHECK-LABEL: test_vreinterpretq_p16_u8 11073 // CHECK-NEXT: ret 11074 poly16x8_t test_vreinterpretq_p16_u8(uint8x16_t a) { 11075 return vreinterpretq_p16_u8(a); 11076 } 11077 11078 // CHECK-LABEL: test_vreinterpretq_p16_u16 11079 // CHECK-NEXT: ret 11080 poly16x8_t test_vreinterpretq_p16_u16(uint16x8_t a) { 11081 return vreinterpretq_p16_u16(a); 11082 } 11083 11084 // CHECK-LABEL: test_vreinterpretq_p16_u32 11085 // CHECK-NEXT: ret 11086 poly16x8_t test_vreinterpretq_p16_u32(uint32x4_t a) { 11087 return vreinterpretq_p16_u32(a); 11088 } 11089 11090 // CHECK-LABEL: test_vreinterpretq_p16_u64 11091 // CHECK-NEXT: ret 11092 poly16x8_t test_vreinterpretq_p16_u64(uint64x2_t a) { 11093 return vreinterpretq_p16_u64(a); 11094 } 11095 11096 // CHECK-LABEL: test_vreinterpretq_p16_f16 11097 // CHECK-NEXT: ret 11098 poly16x8_t test_vreinterpretq_p16_f16(float16x8_t a) { 11099 return vreinterpretq_p16_f16(a); 11100 } 11101 11102 // CHECK-LABEL: test_vreinterpretq_p16_f32 11103 // CHECK-NEXT: ret 11104 poly16x8_t test_vreinterpretq_p16_f32(float32x4_t a) { 11105 return vreinterpretq_p16_f32(a); 11106 } 11107 11108 // CHECK-LABEL: test_vreinterpretq_p16_f64 11109 // CHECK-NEXT: ret 11110 poly16x8_t test_vreinterpretq_p16_f64(float64x2_t a) { 11111 return vreinterpretq_p16_f64(a); 11112 } 11113 11114 // CHECK-LABEL: test_vreinterpretq_p16_p8 11115 // CHECK-NEXT: ret 11116 poly16x8_t test_vreinterpretq_p16_p8(poly8x16_t a) { 11117 return vreinterpretq_p16_p8(a); 11118 } 11119 11120 // CHECK-LABEL: test_vreinterpretq_p16_p64 11121 // CHECK-NEXT: ret 11122 poly16x8_t test_vreinterpretq_p16_p64(poly64x2_t a) { 11123 return vreinterpretq_p16_p64(a); 11124 } 11125 11126 // CHECK-LABEL: test_vreinterpretq_p64_s8 11127 // CHECK-NEXT: ret 11128 poly64x2_t test_vreinterpretq_p64_s8(int8x16_t a) { 11129 return vreinterpretq_p64_s8(a); 11130 } 11131 11132 // CHECK-LABEL: test_vreinterpretq_p64_s16 11133 // CHECK-NEXT: ret 11134 poly64x2_t test_vreinterpretq_p64_s16(int16x8_t a) { 11135 return vreinterpretq_p64_s16(a); 11136 } 11137 11138 // CHECK-LABEL: test_vreinterpretq_p64_s32 11139 // CHECK-NEXT: ret 11140 poly64x2_t test_vreinterpretq_p64_s32(int32x4_t a) { 11141 return vreinterpretq_p64_s32(a); 11142 } 11143 11144 // CHECK-LABEL: test_vreinterpretq_p64_s64 11145 // CHECK-NEXT: ret 11146 poly64x2_t test_vreinterpretq_p64_s64(int64x2_t a) { 11147 return vreinterpretq_p64_s64(a); 11148 } 11149 11150 // CHECK-LABEL: test_vreinterpretq_p64_u8 11151 // CHECK-NEXT: ret 11152 poly64x2_t test_vreinterpretq_p64_u8(uint8x16_t a) { 11153 return vreinterpretq_p64_u8(a); 11154 } 11155 11156 // CHECK-LABEL: test_vreinterpretq_p64_u16 11157 // CHECK-NEXT: ret 11158 poly64x2_t test_vreinterpretq_p64_u16(uint16x8_t a) { 11159 return vreinterpretq_p64_u16(a); 11160 } 11161 11162 // CHECK-LABEL: test_vreinterpretq_p64_u32 11163 // CHECK-NEXT: ret 11164 poly64x2_t test_vreinterpretq_p64_u32(uint32x4_t a) { 11165 return vreinterpretq_p64_u32(a); 11166 } 11167 11168 // CHECK-LABEL: test_vreinterpretq_p64_u64 11169 // CHECK-NEXT: ret 11170 poly64x2_t test_vreinterpretq_p64_u64(uint64x2_t a) { 11171 return vreinterpretq_p64_u64(a); 11172 } 11173 11174 // CHECK-LABEL: test_vreinterpretq_p64_f16 11175 // CHECK-NEXT: ret 11176 poly64x2_t test_vreinterpretq_p64_f16(float16x8_t a) { 11177 return vreinterpretq_p64_f16(a); 11178 } 11179 11180 // CHECK-LABEL: test_vreinterpretq_p64_f32 11181 // CHECK-NEXT: ret 11182 poly64x2_t test_vreinterpretq_p64_f32(float32x4_t a) { 11183 return vreinterpretq_p64_f32(a); 11184 } 11185 11186 // CHECK-LABEL: test_vreinterpretq_p64_f64 11187 // CHECK-NEXT: ret 11188 poly64x2_t test_vreinterpretq_p64_f64(float64x2_t a) { 11189 return vreinterpretq_p64_f64(a); 11190 } 11191 11192 // CHECK-LABEL: test_vreinterpretq_p64_p8 11193 // CHECK-NEXT: ret 11194 poly64x2_t test_vreinterpretq_p64_p8(poly8x16_t a) { 11195 return vreinterpretq_p64_p8(a); 11196 } 11197 11198 // CHECK-LABEL: test_vreinterpretq_p64_p16 11199 // CHECK-NEXT: ret 11200 poly64x2_t test_vreinterpretq_p64_p16(poly16x8_t a) { 11201 return vreinterpretq_p64_p16(a); 11202 } 11203