Home | History | Annotate | Download | only in CodeGen 
      1 // RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon -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) #0 {
     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) #0 {
     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) #0 {
     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) #0 {
     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) #0 {
     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) #0 {
     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) #0 {
     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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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) #0 {
    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