test/CodeGen/aarch64-neon-3v.c

   1 // RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon  -disable-O0-optnone -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
   2
   3 // Test new aarch64 intrinsics and types
   4
   5 #include <arm_neon.h>
   6
   7 // CHECK-LABEL: define <8 x i8> @test_vand_s8(<8 x i8> %a, <8 x i8> %b) #0 {
   8 // CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, %b
   9 // CHECK:   ret <8 x i8> [[AND_I]]
  10 int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) {
  11   return vand_s8(a, b);
  12 }
  13
  14 // CHECK-LABEL: define <16 x i8> @test_vandq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
  15 // CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, %b
  16 // CHECK:   ret <16 x i8> [[AND_I]]
  17 int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) {
  18   return vandq_s8(a, b);
  19 }
  20
  21 // CHECK-LABEL: define <4 x i16> @test_vand_s16(<4 x i16> %a, <4 x i16> %b) #0 {
  22 // CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, %b
  23 // CHECK:   ret <4 x i16> [[AND_I]]
  24 int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) {
  25   return vand_s16(a, b);
  26 }
  27
  28 // CHECK-LABEL: define <8 x i16> @test_vandq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
  29 // CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, %b
  30 // CHECK:   ret <8 x i16> [[AND_I]]
  31 int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) {
  32   return vandq_s16(a, b);
  33 }
  34
  35 // CHECK-LABEL: define <2 x i32> @test_vand_s32(<2 x i32> %a, <2 x i32> %b) #0 {
  36 // CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, %b
  37 // CHECK:   ret <2 x i32> [[AND_I]]
  38 int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) {
  39   return vand_s32(a, b);
  40 }
  41
  42 // CHECK-LABEL: define <4 x i32> @test_vandq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
  43 // CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, %b
  44 // CHECK:   ret <4 x i32> [[AND_I]]
  45 int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) {
  46   return vandq_s32(a, b);
  47 }
  48
  49 // CHECK-LABEL: define <1 x i64> @test_vand_s64(<1 x i64> %a, <1 x i64> %b) #0 {
  50 // CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, %b
  51 // CHECK:   ret <1 x i64> [[AND_I]]
  52 int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) {
  53   return vand_s64(a, b);
  54 }
  55
  56 // CHECK-LABEL: define <2 x i64> @test_vandq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
  57 // CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, %b
  58 // CHECK:   ret <2 x i64> [[AND_I]]
  59 int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) {
  60   return vandq_s64(a, b);
  61 }
  62
  63 // CHECK-LABEL: define <8 x i8> @test_vand_u8(<8 x i8> %a, <8 x i8> %b) #0 {
  64 // CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, %b
  65 // CHECK:   ret <8 x i8> [[AND_I]]
  66 uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) {
  67   return vand_u8(a, b);
  68 }
  69
  70 // CHECK-LABEL: define <16 x i8> @test_vandq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
  71 // CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, %b
  72 // CHECK:   ret <16 x i8> [[AND_I]]
  73 uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) {
  74   return vandq_u8(a, b);
  75 }
  76
  77 // CHECK-LABEL: define <4 x i16> @test_vand_u16(<4 x i16> %a, <4 x i16> %b) #0 {
  78 // CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, %b
  79 // CHECK:   ret <4 x i16> [[AND_I]]
  80 uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) {
  81   return vand_u16(a, b);
  82 }
  83
  84 // CHECK-LABEL: define <8 x i16> @test_vandq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
  85 // CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, %b
  86 // CHECK:   ret <8 x i16> [[AND_I]]
  87 uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) {
  88   return vandq_u16(a, b);
  89 }
  90
  91 // CHECK-LABEL: define <2 x i32> @test_vand_u32(<2 x i32> %a, <2 x i32> %b) #0 {
  92 // CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, %b
  93 // CHECK:   ret <2 x i32> [[AND_I]]
  94 uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) {
  95   return vand_u32(a, b);
  96 }
  97
  98 // CHECK-LABEL: define <4 x i32> @test_vandq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
  99 // CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, %b
 100 // CHECK:   ret <4 x i32> [[AND_I]]
 101 uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) {
 102   return vandq_u32(a, b);
 103 }
 104
 105 // CHECK-LABEL: define <1 x i64> @test_vand_u64(<1 x i64> %a, <1 x i64> %b) #0 {
 106 // CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, %b
 107 // CHECK:   ret <1 x i64> [[AND_I]]
 108 uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) {
 109   return vand_u64(a, b);
 110 }
 111
 112 // CHECK-LABEL: define <2 x i64> @test_vandq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
 113 // CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, %b
 114 // CHECK:   ret <2 x i64> [[AND_I]]
 115 uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) {
 116   return vandq_u64(a, b);
 117 }
 118
 119 // CHECK-LABEL: define <8 x i8> @test_vorr_s8(<8 x i8> %a, <8 x i8> %b) #0 {
 120 // CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, %b
 121 // CHECK:   ret <8 x i8> [[OR_I]]
 122 int8x8_t test_vorr_s8(int8x8_t a, int8x8_t b) {
 123   return vorr_s8(a, b);
 124 }
 125
 126 // CHECK-LABEL: define <16 x i8> @test_vorrq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
 127 // CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, %b
 128 // CHECK:   ret <16 x i8> [[OR_I]]
 129 int8x16_t test_vorrq_s8(int8x16_t a, int8x16_t b) {
 130   return vorrq_s8(a, b);
 131 }
 132
 133 // CHECK-LABEL: define <4 x i16> @test_vorr_s16(<4 x i16> %a, <4 x i16> %b) #0 {
 134 // CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, %b
 135 // CHECK:   ret <4 x i16> [[OR_I]]
 136 int16x4_t test_vorr_s16(int16x4_t a, int16x4_t b) {
 137   return vorr_s16(a, b);
 138 }
 139
 140 // CHECK-LABEL: define <8 x i16> @test_vorrq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
 141 // CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, %b
 142 // CHECK:   ret <8 x i16> [[OR_I]]
 143 int16x8_t test_vorrq_s16(int16x8_t a, int16x8_t b) {
 144   return vorrq_s16(a, b);
 145 }
 146
 147 // CHECK-LABEL: define <2 x i32> @test_vorr_s32(<2 x i32> %a, <2 x i32> %b) #0 {
 148 // CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, %b
 149 // CHECK:   ret <2 x i32> [[OR_I]]
 150 int32x2_t test_vorr_s32(int32x2_t a, int32x2_t b) {
 151   return vorr_s32(a, b);
 152 }
 153
 154 // CHECK-LABEL: define <4 x i32> @test_vorrq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
 155 // CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, %b
 156 // CHECK:   ret <4 x i32> [[OR_I]]
 157 int32x4_t test_vorrq_s32(int32x4_t a, int32x4_t b) {
 158   return vorrq_s32(a, b);
 159 }
 160
 161 // CHECK-LABEL: define <1 x i64> @test_vorr_s64(<1 x i64> %a, <1 x i64> %b) #0 {
 162 // CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, %b
 163 // CHECK:   ret <1 x i64> [[OR_I]]
 164 int64x1_t test_vorr_s64(int64x1_t a, int64x1_t b) {
 165   return vorr_s64(a, b);
 166 }
 167
 168 // CHECK-LABEL: define <2 x i64> @test_vorrq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
 169 // CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, %b
 170 // CHECK:   ret <2 x i64> [[OR_I]]
 171 int64x2_t test_vorrq_s64(int64x2_t a, int64x2_t b) {
 172   return vorrq_s64(a, b);
 173 }
 174
 175 // CHECK-LABEL: define <8 x i8> @test_vorr_u8(<8 x i8> %a, <8 x i8> %b) #0 {
 176 // CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, %b
 177 // CHECK:   ret <8 x i8> [[OR_I]]
 178 uint8x8_t test_vorr_u8(uint8x8_t a, uint8x8_t b) {
 179   return vorr_u8(a, b);
 180 }
 181
 182 // CHECK-LABEL: define <16 x i8> @test_vorrq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
 183 // CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, %b
 184 // CHECK:   ret <16 x i8> [[OR_I]]
 185 uint8x16_t test_vorrq_u8(uint8x16_t a, uint8x16_t b) {
 186   return vorrq_u8(a, b);
 187 }
 188
 189 // CHECK-LABEL: define <4 x i16> @test_vorr_u16(<4 x i16> %a, <4 x i16> %b) #0 {
 190 // CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, %b
 191 // CHECK:   ret <4 x i16> [[OR_I]]
 192 uint16x4_t test_vorr_u16(uint16x4_t a, uint16x4_t b) {
 193   return vorr_u16(a, b);
 194 }
 195
 196 // CHECK-LABEL: define <8 x i16> @test_vorrq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
 197 // CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, %b
 198 // CHECK:   ret <8 x i16> [[OR_I]]
 199 uint16x8_t test_vorrq_u16(uint16x8_t a, uint16x8_t b) {
 200   return vorrq_u16(a, b);
 201 }
 202
 203 // CHECK-LABEL: define <2 x i32> @test_vorr_u32(<2 x i32> %a, <2 x i32> %b) #0 {
 204 // CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, %b
 205 // CHECK:   ret <2 x i32> [[OR_I]]
 206 uint32x2_t test_vorr_u32(uint32x2_t a, uint32x2_t b) {
 207   return vorr_u32(a, b);
 208 }
 209
 210 // CHECK-LABEL: define <4 x i32> @test_vorrq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
 211 // CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, %b
 212 // CHECK:   ret <4 x i32> [[OR_I]]
 213 uint32x4_t test_vorrq_u32(uint32x4_t a, uint32x4_t b) {
 214   return vorrq_u32(a, b);
 215 }
 216
 217 // CHECK-LABEL: define <1 x i64> @test_vorr_u64(<1 x i64> %a, <1 x i64> %b) #0 {
 218 // CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, %b
 219 // CHECK:   ret <1 x i64> [[OR_I]]
 220 uint64x1_t test_vorr_u64(uint64x1_t a, uint64x1_t b) {
 221   return vorr_u64(a, b);
 222 }
 223
 224 // CHECK-LABEL: define <2 x i64> @test_vorrq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
 225 // CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, %b
 226 // CHECK:   ret <2 x i64> [[OR_I]]
 227 uint64x2_t test_vorrq_u64(uint64x2_t a, uint64x2_t b) {
 228   return vorrq_u64(a, b);
 229 }
 230
 231 // CHECK-LABEL: define <8 x i8> @test_veor_s8(<8 x i8> %a, <8 x i8> %b) #0 {
 232 // CHECK:   [[XOR_I:%.*]] = xor <8 x i8> %a, %b
 233 // CHECK:   ret <8 x i8> [[XOR_I]]
 234 int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) {
 235   return veor_s8(a, b);
 236 }
 237
 238 // CHECK-LABEL: define <16 x i8> @test_veorq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
 239 // CHECK:   [[XOR_I:%.*]] = xor <16 x i8> %a, %b
 240 // CHECK:   ret <16 x i8> [[XOR_I]]
 241 int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) {
 242   return veorq_s8(a, b);
 243 }
 244
 245 // CHECK-LABEL: define <4 x i16> @test_veor_s16(<4 x i16> %a, <4 x i16> %b) #0 {
 246 // CHECK:   [[XOR_I:%.*]] = xor <4 x i16> %a, %b
 247 // CHECK:   ret <4 x i16> [[XOR_I]]
 248 int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) {
 249   return veor_s16(a, b);
 250 }
 251
 252 // CHECK-LABEL: define <8 x i16> @test_veorq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
 253 // CHECK:   [[XOR_I:%.*]] = xor <8 x i16> %a, %b
 254 // CHECK:   ret <8 x i16> [[XOR_I]]
 255 int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) {
 256   return veorq_s16(a, b);
 257 }
 258
 259 // CHECK-LABEL: define <2 x i32> @test_veor_s32(<2 x i32> %a, <2 x i32> %b) #0 {
 260 // CHECK:   [[XOR_I:%.*]] = xor <2 x i32> %a, %b
 261 // CHECK:   ret <2 x i32> [[XOR_I]]
 262 int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) {
 263   return veor_s32(a, b);
 264 }
 265
 266 // CHECK-LABEL: define <4 x i32> @test_veorq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
 267 // CHECK:   [[XOR_I:%.*]] = xor <4 x i32> %a, %b
 268 // CHECK:   ret <4 x i32> [[XOR_I]]
 269 int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) {
 270   return veorq_s32(a, b);
 271 }
 272
 273 // CHECK-LABEL: define <1 x i64> @test_veor_s64(<1 x i64> %a, <1 x i64> %b) #0 {
 274 // CHECK:   [[XOR_I:%.*]] = xor <1 x i64> %a, %b
 275 // CHECK:   ret <1 x i64> [[XOR_I]]
 276 int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) {
 277   return veor_s64(a, b);
 278 }
 279
 280 // CHECK-LABEL: define <2 x i64> @test_veorq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
 281 // CHECK:   [[XOR_I:%.*]] = xor <2 x i64> %a, %b
 282 // CHECK:   ret <2 x i64> [[XOR_I]]
 283 int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) {
 284   return veorq_s64(a, b);
 285 }
 286
 287 // CHECK-LABEL: define <8 x i8> @test_veor_u8(<8 x i8> %a, <8 x i8> %b) #0 {
 288 // CHECK:   [[XOR_I:%.*]] = xor <8 x i8> %a, %b
 289 // CHECK:   ret <8 x i8> [[XOR_I]]
 290 uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) {
 291   return veor_u8(a, b);
 292 }
 293
 294 // CHECK-LABEL: define <16 x i8> @test_veorq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
 295 // CHECK:   [[XOR_I:%.*]] = xor <16 x i8> %a, %b
 296 // CHECK:   ret <16 x i8> [[XOR_I]]
 297 uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) {
 298   return veorq_u8(a, b);
 299 }
 300
 301 // CHECK-LABEL: define <4 x i16> @test_veor_u16(<4 x i16> %a, <4 x i16> %b) #0 {
 302 // CHECK:   [[XOR_I:%.*]] = xor <4 x i16> %a, %b
 303 // CHECK:   ret <4 x i16> [[XOR_I]]
 304 uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) {
 305   return veor_u16(a, b);
 306 }
 307
 308 // CHECK-LABEL: define <8 x i16> @test_veorq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
 309 // CHECK:   [[XOR_I:%.*]] = xor <8 x i16> %a, %b
 310 // CHECK:   ret <8 x i16> [[XOR_I]]
 311 uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) {
 312   return veorq_u16(a, b);
 313 }
 314
 315 // CHECK-LABEL: define <2 x i32> @test_veor_u32(<2 x i32> %a, <2 x i32> %b) #0 {
 316 // CHECK:   [[XOR_I:%.*]] = xor <2 x i32> %a, %b
 317 // CHECK:   ret <2 x i32> [[XOR_I]]
 318 uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) {
 319   return veor_u32(a, b);
 320 }
 321
 322 // CHECK-LABEL: define <4 x i32> @test_veorq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
 323 // CHECK:   [[XOR_I:%.*]] = xor <4 x i32> %a, %b
 324 // CHECK:   ret <4 x i32> [[XOR_I]]
 325 uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) {
 326   return veorq_u32(a, b);
 327 }
 328
 329 // CHECK-LABEL: define <1 x i64> @test_veor_u64(<1 x i64> %a, <1 x i64> %b) #0 {
 330 // CHECK:   [[XOR_I:%.*]] = xor <1 x i64> %a, %b
 331 // CHECK:   ret <1 x i64> [[XOR_I]]
 332 uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) {
 333   return veor_u64(a, b);
 334 }
 335
 336 // CHECK-LABEL: define <2 x i64> @test_veorq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
 337 // CHECK:   [[XOR_I:%.*]] = xor <2 x i64> %a, %b
 338 // CHECK:   ret <2 x i64> [[XOR_I]]
 339 uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) {
 340   return veorq_u64(a, b);
 341 }
 342
 343 // CHECK-LABEL: define <8 x i8> @test_vbic_s8(<8 x i8> %a, <8 x i8> %b) #0 {
 344 // CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 345 // CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, [[NEG_I]]
 346 // CHECK:   ret <8 x i8> [[AND_I]]
 347 int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) {
 348   return vbic_s8(a, b);
 349 }
 350
 351 // CHECK-LABEL: define <16 x i8> @test_vbicq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
 352 // CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 353 // CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, [[NEG_I]]
 354 // CHECK:   ret <16 x i8> [[AND_I]]
 355 int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) {
 356   return vbicq_s8(a, b);
 357 }
 358
 359 // CHECK-LABEL: define <4 x i16> @test_vbic_s16(<4 x i16> %a, <4 x i16> %b) #0 {
 360 // CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
 361 // CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, [[NEG_I]]
 362 // CHECK:   ret <4 x i16> [[AND_I]]
 363 int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) {
 364   return vbic_s16(a, b);
 365 }
 366
 367 // CHECK-LABEL: define <8 x i16> @test_vbicq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
 368 // CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 369 // CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, [[NEG_I]]
 370 // CHECK:   ret <8 x i16> [[AND_I]]
 371 int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) {
 372   return vbicq_s16(a, b);
 373 }
 374
 375 // CHECK-LABEL: define <2 x i32> @test_vbic_s32(<2 x i32> %a, <2 x i32> %b) #0 {
 376 // CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
 377 // CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, [[NEG_I]]
 378 // CHECK:   ret <2 x i32> [[AND_I]]
 379 int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) {
 380   return vbic_s32(a, b);
 381 }
 382
 383 // CHECK-LABEL: define <4 x i32> @test_vbicq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
 384 // CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
 385 // CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, [[NEG_I]]
 386 // CHECK:   ret <4 x i32> [[AND_I]]
 387 int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) {
 388   return vbicq_s32(a, b);
 389 }
 390
 391 // CHECK-LABEL: define <1 x i64> @test_vbic_s64(<1 x i64> %a, <1 x i64> %b) #0 {
 392 // CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
 393 // CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, [[NEG_I]]
 394 // CHECK:   ret <1 x i64> [[AND_I]]
 395 int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) {
 396   return vbic_s64(a, b);
 397 }
 398
 399 // CHECK-LABEL: define <2 x i64> @test_vbicq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
 400 // CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
 401 // CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, [[NEG_I]]
 402 // CHECK:   ret <2 x i64> [[AND_I]]
 403 int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) {
 404   return vbicq_s64(a, b);
 405 }
 406
 407 // CHECK-LABEL: define <8 x i8> @test_vbic_u8(<8 x i8> %a, <8 x i8> %b) #0 {
 408 // CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 409 // CHECK:   [[AND_I:%.*]] = and <8 x i8> %a, [[NEG_I]]
 410 // CHECK:   ret <8 x i8> [[AND_I]]
 411 uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) {
 412   return vbic_u8(a, b);
 413 }
 414
 415 // CHECK-LABEL: define <16 x i8> @test_vbicq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
 416 // CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 417 // CHECK:   [[AND_I:%.*]] = and <16 x i8> %a, [[NEG_I]]
 418 // CHECK:   ret <16 x i8> [[AND_I]]
 419 uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) {
 420   return vbicq_u8(a, b);
 421 }
 422
 423 // CHECK-LABEL: define <4 x i16> @test_vbic_u16(<4 x i16> %a, <4 x i16> %b) #0 {
 424 // CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
 425 // CHECK:   [[AND_I:%.*]] = and <4 x i16> %a, [[NEG_I]]
 426 // CHECK:   ret <4 x i16> [[AND_I]]
 427 uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) {
 428   return vbic_u16(a, b);
 429 }
 430
 431 // CHECK-LABEL: define <8 x i16> @test_vbicq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
 432 // CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 433 // CHECK:   [[AND_I:%.*]] = and <8 x i16> %a, [[NEG_I]]
 434 // CHECK:   ret <8 x i16> [[AND_I]]
 435 uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) {
 436   return vbicq_u16(a, b);
 437 }
 438
 439 // CHECK-LABEL: define <2 x i32> @test_vbic_u32(<2 x i32> %a, <2 x i32> %b) #0 {
 440 // CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
 441 // CHECK:   [[AND_I:%.*]] = and <2 x i32> %a, [[NEG_I]]
 442 // CHECK:   ret <2 x i32> [[AND_I]]
 443 uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) {
 444   return vbic_u32(a, b);
 445 }
 446
 447 // CHECK-LABEL: define <4 x i32> @test_vbicq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
 448 // CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
 449 // CHECK:   [[AND_I:%.*]] = and <4 x i32> %a, [[NEG_I]]
 450 // CHECK:   ret <4 x i32> [[AND_I]]
 451 uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) {
 452   return vbicq_u32(a, b);
 453 }
 454
 455 // CHECK-LABEL: define <1 x i64> @test_vbic_u64(<1 x i64> %a, <1 x i64> %b) #0 {
 456 // CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
 457 // CHECK:   [[AND_I:%.*]] = and <1 x i64> %a, [[NEG_I]]
 458 // CHECK:   ret <1 x i64> [[AND_I]]
 459 uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) {
 460   return vbic_u64(a, b);
 461 }
 462
 463 // CHECK-LABEL: define <2 x i64> @test_vbicq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
 464 // CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
 465 // CHECK:   [[AND_I:%.*]] = and <2 x i64> %a, [[NEG_I]]
 466 // CHECK:   ret <2 x i64> [[AND_I]]
 467 uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) {
 468   return vbicq_u64(a, b);
 469 }
 470
 471 // CHECK-LABEL: define <8 x i8> @test_vorn_s8(<8 x i8> %a, <8 x i8> %b) #0 {
 472 // CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 473 // CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, [[NEG_I]]
 474 // CHECK:   ret <8 x i8> [[OR_I]]
 475 int8x8_t test_vorn_s8(int8x8_t a, int8x8_t b) {
 476   return vorn_s8(a, b);
 477 }
 478
 479 // CHECK-LABEL: define <16 x i8> @test_vornq_s8(<16 x i8> %a, <16 x i8> %b) #1 {
 480 // CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 481 // CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, [[NEG_I]]
 482 // CHECK:   ret <16 x i8> [[OR_I]]
 483 int8x16_t test_vornq_s8(int8x16_t a, int8x16_t b) {
 484   return vornq_s8(a, b);
 485 }
 486
 487 // CHECK-LABEL: define <4 x i16> @test_vorn_s16(<4 x i16> %a, <4 x i16> %b) #0 {
 488 // CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
 489 // CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, [[NEG_I]]
 490 // CHECK:   ret <4 x i16> [[OR_I]]
 491 int16x4_t test_vorn_s16(int16x4_t a, int16x4_t b) {
 492   return vorn_s16(a, b);
 493 }
 494
 495 // CHECK-LABEL: define <8 x i16> @test_vornq_s16(<8 x i16> %a, <8 x i16> %b) #1 {
 496 // CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 497 // CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, [[NEG_I]]
 498 // CHECK:   ret <8 x i16> [[OR_I]]
 499 int16x8_t test_vornq_s16(int16x8_t a, int16x8_t b) {
 500   return vornq_s16(a, b);
 501 }
 502
 503 // CHECK-LABEL: define <2 x i32> @test_vorn_s32(<2 x i32> %a, <2 x i32> %b) #0 {
 504 // CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
 505 // CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, [[NEG_I]]
 506 // CHECK:   ret <2 x i32> [[OR_I]]
 507 int32x2_t test_vorn_s32(int32x2_t a, int32x2_t b) {
 508   return vorn_s32(a, b);
 509 }
 510
 511 // CHECK-LABEL: define <4 x i32> @test_vornq_s32(<4 x i32> %a, <4 x i32> %b) #1 {
 512 // CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
 513 // CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, [[NEG_I]]
 514 // CHECK:   ret <4 x i32> [[OR_I]]
 515 int32x4_t test_vornq_s32(int32x4_t a, int32x4_t b) {
 516   return vornq_s32(a, b);
 517 }
 518
 519 // CHECK-LABEL: define <1 x i64> @test_vorn_s64(<1 x i64> %a, <1 x i64> %b) #0 {
 520 // CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
 521 // CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, [[NEG_I]]
 522 // CHECK:   ret <1 x i64> [[OR_I]]
 523 int64x1_t test_vorn_s64(int64x1_t a, int64x1_t b) {
 524   return vorn_s64(a, b);
 525 }
 526
 527 // CHECK-LABEL: define <2 x i64> @test_vornq_s64(<2 x i64> %a, <2 x i64> %b) #1 {
 528 // CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
 529 // CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, [[NEG_I]]
 530 // CHECK:   ret <2 x i64> [[OR_I]]
 531 int64x2_t test_vornq_s64(int64x2_t a, int64x2_t b) {
 532   return vornq_s64(a, b);
 533 }
 534
 535 // CHECK-LABEL: define <8 x i8> @test_vorn_u8(<8 x i8> %a, <8 x i8> %b) #0 {
 536 // CHECK:   [[NEG_I:%.*]] = xor <8 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 537 // CHECK:   [[OR_I:%.*]] = or <8 x i8> %a, [[NEG_I]]
 538 // CHECK:   ret <8 x i8> [[OR_I]]
 539 uint8x8_t test_vorn_u8(uint8x8_t a, uint8x8_t b) {
 540   return vorn_u8(a, b);
 541 }
 542
 543 // CHECK-LABEL: define <16 x i8> @test_vornq_u8(<16 x i8> %a, <16 x i8> %b) #1 {
 544 // CHECK:   [[NEG_I:%.*]] = xor <16 x i8> %b, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 545 // CHECK:   [[OR_I:%.*]] = or <16 x i8> %a, [[NEG_I]]
 546 // CHECK:   ret <16 x i8> [[OR_I]]
 547 uint8x16_t test_vornq_u8(uint8x16_t a, uint8x16_t b) {
 548   return vornq_u8(a, b);
 549 }
 550
 551 // CHECK-LABEL: define <4 x i16> @test_vorn_u16(<4 x i16> %a, <4 x i16> %b) #0 {
 552 // CHECK:   [[NEG_I:%.*]] = xor <4 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1>
 553 // CHECK:   [[OR_I:%.*]] = or <4 x i16> %a, [[NEG_I]]
 554 // CHECK:   ret <4 x i16> [[OR_I]]
 555 uint16x4_t test_vorn_u16(uint16x4_t a, uint16x4_t b) {
 556   return vorn_u16(a, b);
 557 }
 558
 559 // CHECK-LABEL: define <8 x i16> @test_vornq_u16(<8 x i16> %a, <8 x i16> %b) #1 {
 560 // CHECK:   [[NEG_I:%.*]] = xor <8 x i16> %b, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 561 // CHECK:   [[OR_I:%.*]] = or <8 x i16> %a, [[NEG_I]]
 562 // CHECK:   ret <8 x i16> [[OR_I]]
 563 uint16x8_t test_vornq_u16(uint16x8_t a, uint16x8_t b) {
 564   return vornq_u16(a, b);
 565 }
 566
 567 // CHECK-LABEL: define <2 x i32> @test_vorn_u32(<2 x i32> %a, <2 x i32> %b) #0 {
 568 // CHECK:   [[NEG_I:%.*]] = xor <2 x i32> %b, <i32 -1, i32 -1>
 569 // CHECK:   [[OR_I:%.*]] = or <2 x i32> %a, [[NEG_I]]
 570 // CHECK:   ret <2 x i32> [[OR_I]]
 571 uint32x2_t test_vorn_u32(uint32x2_t a, uint32x2_t b) {
 572   return vorn_u32(a, b);
 573 }
 574
 575 // CHECK-LABEL: define <4 x i32> @test_vornq_u32(<4 x i32> %a, <4 x i32> %b) #1 {
 576 // CHECK:   [[NEG_I:%.*]] = xor <4 x i32> %b, <i32 -1, i32 -1, i32 -1, i32 -1>
 577 // CHECK:   [[OR_I:%.*]] = or <4 x i32> %a, [[NEG_I]]
 578 // CHECK:   ret <4 x i32> [[OR_I]]
 579 uint32x4_t test_vornq_u32(uint32x4_t a, uint32x4_t b) {
 580   return vornq_u32(a, b);
 581 }
 582
 583 // CHECK-LABEL: define <1 x i64> @test_vorn_u64(<1 x i64> %a, <1 x i64> %b) #0 {
 584 // CHECK:   [[NEG_I:%.*]] = xor <1 x i64> %b, <i64 -1>
 585 // CHECK:   [[OR_I:%.*]] = or <1 x i64> %a, [[NEG_I]]
 586 // CHECK:   ret <1 x i64> [[OR_I]]
 587 uint64x1_t test_vorn_u64(uint64x1_t a, uint64x1_t b) {
 588   return vorn_u64(a, b);
 589 }
 590
 591 // CHECK-LABEL: define <2 x i64> @test_vornq_u64(<2 x i64> %a, <2 x i64> %b) #1 {
 592 // CHECK:   [[NEG_I:%.*]] = xor <2 x i64> %b, <i64 -1, i64 -1>
 593 // CHECK:   [[OR_I:%.*]] = or <2 x i64> %a, [[NEG_I]]
 594 // CHECK:   ret <2 x i64> [[OR_I]]
 595 uint64x2_t test_vornq_u64(uint64x2_t a, uint64x2_t b) {
 596   return vornq_u64(a, b);
 597 }
 598
 599 // CHECK: attributes #0 ={{.*}}"min-legal-vector-width"="64"
 600 // CHECK: attributes #1 ={{.*}}"min-legal-vector-width"="128"