test/CodeGen/AArch64/neon-misc.ll

   1 ; RUN: llc < %s -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -mattr=+neon -fp-contract=fast | FileCheck %s
   2
   3
   4 define <8 x i8> @test_vrev16_s8(<8 x i8> %a) #0 {
   5 ; CHECK: rev16 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
   6   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> undef, <8 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6>
   7   ret <8 x i8> %shuffle.i
   8 }
   9
  10 define <16 x i8> @test_vrev16q_s8(<16 x i8> %a) #0 {
  11 ; CHECK: rev16 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
  12   %shuffle.i = shufflevector <16 x i8> %a, <16 x i8> undef, <16 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6, i32 9, i32 8, i32 11, i32 10, i32 13, i32 12, i32 15, i32 14>
  13   ret <16 x i8> %shuffle.i
  14 }
  15
  16 define <8 x i8> @test_vrev32_s8(<8 x i8> %a) #0 {
  17 ; CHECK: rev32 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
  18   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> undef, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
  19   ret <8 x i8> %shuffle.i
  20 }
  21
  22 define <4 x i16> @test_vrev32_s16(<4 x i16> %a) #0 {
  23 ; CHECK: rev32 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
  24   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
  25   ret <4 x i16> %shuffle.i
  26 }
  27
  28 define <16 x i8> @test_vrev32q_s8(<16 x i8> %a) #0 {
  29 ; CHECK: rev32 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
  30   %shuffle.i = shufflevector <16 x i8> %a, <16 x i8> undef, <16 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4, i32 11, i32 10, i32 9, i32 8, i32 15, i32 14, i32 13, i32 12>
  31   ret <16 x i8> %shuffle.i
  32 }
  33
  34 define <8 x i16> @test_vrev32q_s16(<8 x i16> %a) #0 {
  35 ; CHECK: rev32 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
  36   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <8 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6>
  37   ret <8 x i16> %shuffle.i
  38 }
  39
  40 define <8 x i8> @test_vrev64_s8(<8 x i8> %a) #0 {
  41 ; CHECK: rev64 v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
  42   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> undef, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
  43   ret <8 x i8> %shuffle.i
  44 }
  45
  46 define <4 x i16> @test_vrev64_s16(<4 x i16> %a) #0 {
  47 ; CHECK: rev64 v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
  48   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
  49   ret <4 x i16> %shuffle.i
  50 }
  51
  52 define <2 x i32> @test_vrev64_s32(<2 x i32> %a) #0 {
  53 ; CHECK: rev64 v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
  54   %shuffle.i = shufflevector <2 x i32> %a, <2 x i32> undef, <2 x i32> <i32 1, i32 0>
  55   ret <2 x i32> %shuffle.i
  56 }
  57
  58 define <2 x float> @test_vrev64_f32(<2 x float> %a) #0 {
  59 ; CHECK: rev64 v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
  60   %shuffle.i = shufflevector <2 x float> %a, <2 x float> undef, <2 x i32> <i32 1, i32 0>
  61   ret <2 x float> %shuffle.i
  62 }
  63
  64 define <16 x i8> @test_vrev64q_s8(<16 x i8> %a) #0 {
  65 ; CHECK: rev64 v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
  66   %shuffle.i = shufflevector <16 x i8> %a, <16 x i8> undef, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
  67   ret <16 x i8> %shuffle.i
  68 }
  69
  70 define <8 x i16> @test_vrev64q_s16(<8 x i16> %a) #0 {
  71 ; CHECK: rev64 v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
  72   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
  73   ret <8 x i16> %shuffle.i
  74 }
  75
  76 define <4 x i32> @test_vrev64q_s32(<4 x i32> %a) #0 {
  77 ; CHECK: rev64 v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
  78   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
  79   ret <4 x i32> %shuffle.i
  80 }
  81
  82 define <4 x float> @test_vrev64q_f32(<4 x float> %a) #0 {
  83 ; CHECK: rev64 v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
  84   %shuffle.i = shufflevector <4 x float> %a, <4 x float> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
  85   ret <4 x float> %shuffle.i
  86 }
  87
  88 define <4 x i16> @test_vpaddl_s8(<8 x i8> %a) #0 {
  89 ; CHECK: saddlp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
  90   %vpaddl.i = tail call <4 x i16> @llvm.arm.neon.vpaddls.v4i16.v8i8(<8 x i8> %a) #4
  91   ret <4 x i16> %vpaddl.i
  92 }
  93
  94 define <2 x i32> @test_vpaddl_s16(<4 x i16> %a) #0 {
  95 ; CHECK: saddlp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
  96   %vpaddl1.i = tail call <2 x i32> @llvm.arm.neon.vpaddls.v2i32.v4i16(<4 x i16> %a) #4
  97   ret <2 x i32> %vpaddl1.i
  98 }
  99
 100 define <1 x i64> @test_vpaddl_s32(<2 x i32> %a) #0 {
 101 ; CHECK: saddlp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 102   %vpaddl1.i = tail call <1 x i64> @llvm.arm.neon.vpaddls.v1i64.v2i32(<2 x i32> %a) #4
 103   ret <1 x i64> %vpaddl1.i
 104 }
 105
 106 define <4 x i16> @test_vpaddl_u8(<8 x i8> %a) #0 {
 107 ; CHECK: uaddlp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 108   %vpaddl.i = tail call <4 x i16> @llvm.arm.neon.vpaddlu.v4i16.v8i8(<8 x i8> %a) #4
 109   ret <4 x i16> %vpaddl.i
 110 }
 111
 112 define <2 x i32> @test_vpaddl_u16(<4 x i16> %a) #0 {
 113 ; CHECK: uaddlp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 114   %vpaddl1.i = tail call <2 x i32> @llvm.arm.neon.vpaddlu.v2i32.v4i16(<4 x i16> %a) #4
 115   ret <2 x i32> %vpaddl1.i
 116 }
 117
 118 define <1 x i64> @test_vpaddl_u32(<2 x i32> %a) #0 {
 119 ; CHECK: uaddlp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 120   %vpaddl1.i = tail call <1 x i64> @llvm.arm.neon.vpaddlu.v1i64.v2i32(<2 x i32> %a) #4
 121   ret <1 x i64> %vpaddl1.i
 122 }
 123
 124 define <8 x i16> @test_vpaddlq_s8(<16 x i8> %a) #0 {
 125 ; CHECK: saddlp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 126   %vpaddl.i = tail call <8 x i16> @llvm.arm.neon.vpaddls.v8i16.v16i8(<16 x i8> %a) #4
 127   ret <8 x i16> %vpaddl.i
 128 }
 129
 130 define <4 x i32> @test_vpaddlq_s16(<8 x i16> %a) #0 {
 131 ; CHECK: saddlp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 132   %vpaddl1.i = tail call <4 x i32> @llvm.arm.neon.vpaddls.v4i32.v8i16(<8 x i16> %a) #4
 133   ret <4 x i32> %vpaddl1.i
 134 }
 135
 136 define <2 x i64> @test_vpaddlq_s32(<4 x i32> %a) #0 {
 137 ; CHECK: saddlp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 138   %vpaddl1.i = tail call <2 x i64> @llvm.arm.neon.vpaddls.v2i64.v4i32(<4 x i32> %a) #4
 139   ret <2 x i64> %vpaddl1.i
 140 }
 141
 142 define <8 x i16> @test_vpaddlq_u8(<16 x i8> %a) #0 {
 143 ; CHECK: uaddlp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 144   %vpaddl.i = tail call <8 x i16> @llvm.arm.neon.vpaddlu.v8i16.v16i8(<16 x i8> %a) #4
 145   ret <8 x i16> %vpaddl.i
 146 }
 147
 148 define <4 x i32> @test_vpaddlq_u16(<8 x i16> %a) #0 {
 149 ; CHECK: uaddlp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 150   %vpaddl1.i = tail call <4 x i32> @llvm.arm.neon.vpaddlu.v4i32.v8i16(<8 x i16> %a) #4
 151   ret <4 x i32> %vpaddl1.i
 152 }
 153
 154 define <2 x i64> @test_vpaddlq_u32(<4 x i32> %a) #0 {
 155 ; CHECK: uaddlp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 156   %vpaddl1.i = tail call <2 x i64> @llvm.arm.neon.vpaddlu.v2i64.v4i32(<4 x i32> %a) #4
 157   ret <2 x i64> %vpaddl1.i
 158 }
 159
 160 define <4 x i16> @test_vpadal_s8(<4 x i16> %a, <8 x i8> %b) #0 {
 161 ; CHECK: sadalp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 162   %vpadal1.i = tail call <4 x i16> @llvm.arm.neon.vpadals.v4i16.v8i8(<4 x i16> %a, <8 x i8> %b) #4
 163   ret <4 x i16> %vpadal1.i
 164 }
 165
 166 define <2 x i32> @test_vpadal_s16(<2 x i32> %a, <4 x i16> %b) #0 {
 167 ; CHECK: sadalp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 168   %vpadal2.i = tail call <2 x i32> @llvm.arm.neon.vpadals.v2i32.v4i16(<2 x i32> %a, <4 x i16> %b) #4
 169   ret <2 x i32> %vpadal2.i
 170 }
 171
 172 define <1 x i64> @test_vpadal_s32(<1 x i64> %a, <2 x i32> %b) #0 {
 173 ; CHECK: sadalp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 174   %vpadal2.i = tail call <1 x i64> @llvm.arm.neon.vpadals.v1i64.v2i32(<1 x i64> %a, <2 x i32> %b) #4
 175   ret <1 x i64> %vpadal2.i
 176 }
 177
 178 define <4 x i16> @test_vpadal_u8(<4 x i16> %a, <8 x i8> %b) #0 {
 179 ; CHECK: uadalp v{{[0-9]+}}.4h, v{{[0-9]+}}.8b
 180   %vpadal1.i = tail call <4 x i16> @llvm.arm.neon.vpadalu.v4i16.v8i8(<4 x i16> %a, <8 x i8> %b) #4
 181   ret <4 x i16> %vpadal1.i
 182 }
 183
 184 define <2 x i32> @test_vpadal_u16(<2 x i32> %a, <4 x i16> %b) #0 {
 185 ; CHECK: uadalp v{{[0-9]+}}.2s, v{{[0-9]+}}.4h
 186   %vpadal2.i = tail call <2 x i32> @llvm.arm.neon.vpadalu.v2i32.v4i16(<2 x i32> %a, <4 x i16> %b) #4
 187   ret <2 x i32> %vpadal2.i
 188 }
 189
 190 define <1 x i64> @test_vpadal_u32(<1 x i64> %a, <2 x i32> %b) #0 {
 191 ; CHECK: uadalp v{{[0-9]+}}.1d, v{{[0-9]+}}.2s
 192   %vpadal2.i = tail call <1 x i64> @llvm.arm.neon.vpadalu.v1i64.v2i32(<1 x i64> %a, <2 x i32> %b) #4
 193   ret <1 x i64> %vpadal2.i
 194 }
 195
 196 define <8 x i16> @test_vpadalq_s8(<8 x i16> %a, <16 x i8> %b) #0 {
 197 ; CHECK: sadalp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 198   %vpadal1.i = tail call <8 x i16> @llvm.arm.neon.vpadals.v8i16.v16i8(<8 x i16> %a, <16 x i8> %b) #4
 199   ret <8 x i16> %vpadal1.i
 200 }
 201
 202 define <4 x i32> @test_vpadalq_s16(<4 x i32> %a, <8 x i16> %b) #0 {
 203 ; CHECK: sadalp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 204   %vpadal2.i = tail call <4 x i32> @llvm.arm.neon.vpadals.v4i32.v8i16(<4 x i32> %a, <8 x i16> %b) #4
 205   ret <4 x i32> %vpadal2.i
 206 }
 207
 208 define <2 x i64> @test_vpadalq_s32(<2 x i64> %a, <4 x i32> %b) #0 {
 209 ; CHECK: sadalp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 210   %vpadal2.i = tail call <2 x i64> @llvm.arm.neon.vpadals.v2i64.v4i32(<2 x i64> %a, <4 x i32> %b) #4
 211   ret <2 x i64> %vpadal2.i
 212 }
 213
 214 define <8 x i16> @test_vpadalq_u8(<8 x i16> %a, <16 x i8> %b) #0 {
 215 ; CHECK: uadalp v{{[0-9]+}}.8h, v{{[0-9]+}}.16b
 216   %vpadal1.i = tail call <8 x i16> @llvm.arm.neon.vpadalu.v8i16.v16i8(<8 x i16> %a, <16 x i8> %b) #4
 217   ret <8 x i16> %vpadal1.i
 218 }
 219
 220 define <4 x i32> @test_vpadalq_u16(<4 x i32> %a, <8 x i16> %b) #0 {
 221 ; CHECK: uadalp v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 222   %vpadal2.i = tail call <4 x i32> @llvm.arm.neon.vpadalu.v4i32.v8i16(<4 x i32> %a, <8 x i16> %b) #4
 223   ret <4 x i32> %vpadal2.i
 224 }
 225
 226 define <2 x i64> @test_vpadalq_u32(<2 x i64> %a, <4 x i32> %b) #0 {
 227 ; CHECK: uadalp v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 228   %vpadal2.i = tail call <2 x i64> @llvm.arm.neon.vpadalu.v2i64.v4i32(<2 x i64> %a, <4 x i32> %b) #4
 229   ret <2 x i64> %vpadal2.i
 230 }
 231
 232 define <8 x i8> @test_vqabs_s8(<8 x i8> %a) #0 {
 233 ; CHECK: sqabs v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 234   %vqabs.i = tail call <8 x i8> @llvm.arm.neon.vqabs.v8i8(<8 x i8> %a) #4
 235   ret <8 x i8> %vqabs.i
 236 }
 237
 238 define <16 x i8> @test_vqabsq_s8(<16 x i8> %a) #0 {
 239 ; CHECK: sqabs v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 240   %vqabs.i = tail call <16 x i8> @llvm.arm.neon.vqabs.v16i8(<16 x i8> %a) #4
 241   ret <16 x i8> %vqabs.i
 242 }
 243
 244 define <4 x i16> @test_vqabs_s16(<4 x i16> %a) #0 {
 245 ; CHECK: sqabs v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 246   %vqabs1.i = tail call <4 x i16> @llvm.arm.neon.vqabs.v4i16(<4 x i16> %a) #4
 247   ret <4 x i16> %vqabs1.i
 248 }
 249
 250 define <8 x i16> @test_vqabsq_s16(<8 x i16> %a) #0 {
 251 ; CHECK: sqabs v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 252   %vqabs1.i = tail call <8 x i16> @llvm.arm.neon.vqabs.v8i16(<8 x i16> %a) #4
 253   ret <8 x i16> %vqabs1.i
 254 }
 255
 256 define <2 x i32> @test_vqabs_s32(<2 x i32> %a) #0 {
 257 ; CHECK: sqabs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 258   %vqabs1.i = tail call <2 x i32> @llvm.arm.neon.vqabs.v2i32(<2 x i32> %a) #4
 259   ret <2 x i32> %vqabs1.i
 260 }
 261
 262 define <4 x i32> @test_vqabsq_s32(<4 x i32> %a) #0 {
 263 ; CHECK: sqabs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 264   %vqabs1.i = tail call <4 x i32> @llvm.arm.neon.vqabs.v4i32(<4 x i32> %a) #4
 265   ret <4 x i32> %vqabs1.i
 266 }
 267
 268 define <2 x i64> @test_vqabsq_s64(<2 x i64> %a) #0 {
 269 ; CHECK: sqabs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 270   %vqabs1.i = tail call <2 x i64> @llvm.arm.neon.vqabs.v2i64(<2 x i64> %a) #4
 271   ret <2 x i64> %vqabs1.i
 272 }
 273
 274 define <8 x i8> @test_vqneg_s8(<8 x i8> %a) #0 {
 275 ; CHECK: sqneg v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 276   %vqneg.i = tail call <8 x i8> @llvm.arm.neon.vqneg.v8i8(<8 x i8> %a) #4
 277   ret <8 x i8> %vqneg.i
 278 }
 279
 280 define <16 x i8> @test_vqnegq_s8(<16 x i8> %a) #0 {
 281 ; CHECK: sqneg v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 282   %vqneg.i = tail call <16 x i8> @llvm.arm.neon.vqneg.v16i8(<16 x i8> %a) #4
 283   ret <16 x i8> %vqneg.i
 284 }
 285
 286 define <4 x i16> @test_vqneg_s16(<4 x i16> %a) #0 {
 287 ; CHECK: sqneg v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 288   %vqneg1.i = tail call <4 x i16> @llvm.arm.neon.vqneg.v4i16(<4 x i16> %a) #4
 289   ret <4 x i16> %vqneg1.i
 290 }
 291
 292 define <8 x i16> @test_vqnegq_s16(<8 x i16> %a) #0 {
 293 ; CHECK: sqneg v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 294   %vqneg1.i = tail call <8 x i16> @llvm.arm.neon.vqneg.v8i16(<8 x i16> %a) #4
 295   ret <8 x i16> %vqneg1.i
 296 }
 297
 298 define <2 x i32> @test_vqneg_s32(<2 x i32> %a) #0 {
 299 ; CHECK: sqneg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 300   %vqneg1.i = tail call <2 x i32> @llvm.arm.neon.vqneg.v2i32(<2 x i32> %a) #4
 301   ret <2 x i32> %vqneg1.i
 302 }
 303
 304 define <4 x i32> @test_vqnegq_s32(<4 x i32> %a) #0 {
 305 ; CHECK: sqneg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 306   %vqneg1.i = tail call <4 x i32> @llvm.arm.neon.vqneg.v4i32(<4 x i32> %a) #4
 307   ret <4 x i32> %vqneg1.i
 308 }
 309
 310 define <2 x i64> @test_vqnegq_s64(<2 x i64> %a) #0 {
 311 ; CHECK: sqneg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 312   %vqneg1.i = tail call <2 x i64> @llvm.arm.neon.vqneg.v2i64(<2 x i64> %a) #4
 313   ret <2 x i64> %vqneg1.i
 314 }
 315
 316 define <8 x i8> @test_vneg_s8(<8 x i8> %a) #0 {
 317 ; CHECK: neg v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 318   %sub.i = sub <8 x i8> zeroinitializer, %a
 319   ret <8 x i8> %sub.i
 320 }
 321
 322 define <16 x i8> @test_vnegq_s8(<16 x i8> %a) #0 {
 323 ; CHECK: neg v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 324   %sub.i = sub <16 x i8> zeroinitializer, %a
 325   ret <16 x i8> %sub.i
 326 }
 327
 328 define <4 x i16> @test_vneg_s16(<4 x i16> %a) #0 {
 329 ; CHECK: neg v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 330   %sub.i = sub <4 x i16> zeroinitializer, %a
 331   ret <4 x i16> %sub.i
 332 }
 333
 334 define <8 x i16> @test_vnegq_s16(<8 x i16> %a) #0 {
 335 ; CHECK: neg v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 336   %sub.i = sub <8 x i16> zeroinitializer, %a
 337   ret <8 x i16> %sub.i
 338 }
 339
 340 define <2 x i32> @test_vneg_s32(<2 x i32> %a) #0 {
 341 ; CHECK: neg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 342   %sub.i = sub <2 x i32> zeroinitializer, %a
 343   ret <2 x i32> %sub.i
 344 }
 345
 346 define <4 x i32> @test_vnegq_s32(<4 x i32> %a) #0 {
 347 ; CHECK: neg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 348   %sub.i = sub <4 x i32> zeroinitializer, %a
 349   ret <4 x i32> %sub.i
 350 }
 351
 352 define <2 x i64> @test_vnegq_s64(<2 x i64> %a) #0 {
 353 ; CHECK: neg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 354   %sub.i = sub <2 x i64> zeroinitializer, %a
 355   ret <2 x i64> %sub.i
 356 }
 357
 358 define <2 x float> @test_vneg_f32(<2 x float> %a) #0 {
 359 ; CHECK: fneg v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 360   %sub.i = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, %a
 361   ret <2 x float> %sub.i
 362 }
 363
 364 define <4 x float> @test_vnegq_f32(<4 x float> %a) #0 {
 365 ; CHECK: fneg v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 366   %sub.i = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %a
 367   ret <4 x float> %sub.i
 368 }
 369
 370 define <2 x double> @test_vnegq_f64(<2 x double> %a) #0 {
 371 ; CHECK: fneg v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 372   %sub.i = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %a
 373   ret <2 x double> %sub.i
 374 }
 375
 376 define <8 x i8> @test_vabs_s8(<8 x i8> %a) #0 {
 377 ; CHECK: abs v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 378   %vabs.i = tail call <8 x i8> @llvm.arm.neon.vabs.v8i8(<8 x i8> %a) #4
 379   ret <8 x i8> %vabs.i
 380 }
 381
 382 define <16 x i8> @test_vabsq_s8(<16 x i8> %a) #0 {
 383 ; CHECK: abs v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 384   %vabs.i = tail call <16 x i8> @llvm.arm.neon.vabs.v16i8(<16 x i8> %a) #4
 385   ret <16 x i8> %vabs.i
 386 }
 387
 388 define <4 x i16> @test_vabs_s16(<4 x i16> %a) #0 {
 389 ; CHECK: abs v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 390   %vabs1.i = tail call <4 x i16> @llvm.arm.neon.vabs.v4i16(<4 x i16> %a) #4
 391   ret <4 x i16> %vabs1.i
 392 }
 393
 394 define <8 x i16> @test_vabsq_s16(<8 x i16> %a) #0 {
 395 ; CHECK: abs v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 396   %vabs1.i = tail call <8 x i16> @llvm.arm.neon.vabs.v8i16(<8 x i16> %a) #4
 397   ret <8 x i16> %vabs1.i
 398 }
 399
 400 define <2 x i32> @test_vabs_s32(<2 x i32> %a) #0 {
 401 ; CHECK: abs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 402   %vabs1.i = tail call <2 x i32> @llvm.arm.neon.vabs.v2i32(<2 x i32> %a) #4
 403   ret <2 x i32> %vabs1.i
 404 }
 405
 406 define <4 x i32> @test_vabsq_s32(<4 x i32> %a) #0 {
 407 ; CHECK: abs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 408   %vabs1.i = tail call <4 x i32> @llvm.arm.neon.vabs.v4i32(<4 x i32> %a) #4
 409   ret <4 x i32> %vabs1.i
 410 }
 411
 412 define <2 x i64> @test_vabsq_s64(<2 x i64> %a) #0 {
 413 ; CHECK: abs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 414   %vabs1.i = tail call <2 x i64> @llvm.arm.neon.vabs.v2i64(<2 x i64> %a) #4
 415   ret <2 x i64> %vabs1.i
 416 }
 417
 418 define <2 x float> @test_vabs_f32(<2 x float> %a) #1 {
 419 ; CHECK: fabs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 420   %vabs1.i = tail call <2 x float> @llvm.fabs.v2f32(<2 x float> %a) #4
 421   ret <2 x float> %vabs1.i
 422 }
 423
 424 define <4 x float> @test_vabsq_f32(<4 x float> %a) #1 {
 425 ; CHECK: fabs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 426   %vabs1.i = tail call <4 x float> @llvm.fabs.v4f32(<4 x float> %a) #4
 427   ret <4 x float> %vabs1.i
 428 }
 429
 430 define <2 x double> @test_vabsq_f64(<2 x double> %a) #1 {
 431 ; CHECK: fabs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 432   %vabs1.i = tail call <2 x double> @llvm.fabs.v2f64(<2 x double> %a) #4
 433   ret <2 x double> %vabs1.i
 434 }
 435
 436 define <8 x i8> @test_vuqadd_s8(<8 x i8> %a, <8 x i8> %b) #0 {
 437 ; CHECK: suqadd v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 438   %vuqadd.i = tail call <8 x i8> @llvm.aarch64.neon.suqadd.v8i8(<8 x i8> %a, <8 x i8> %b) #4
 439   ret <8 x i8> %vuqadd.i
 440 }
 441
 442 define <16 x i8> @test_vuqaddq_s8(<16 x i8> %a, <16 x i8> %b) #0 {
 443 ; CHECK: suqadd v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 444   %vuqadd.i = tail call <16 x i8> @llvm.aarch64.neon.suqadd.v16i8(<16 x i8> %a, <16 x i8> %b) #4
 445   ret <16 x i8> %vuqadd.i
 446 }
 447
 448 define <4 x i16> @test_vuqadd_s16(<4 x i16> %a, <4 x i16> %b) #0 {
 449 ; CHECK: suqadd v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 450   %vuqadd2.i = tail call <4 x i16> @llvm.aarch64.neon.suqadd.v4i16(<4 x i16> %a, <4 x i16> %b) #4
 451   ret <4 x i16> %vuqadd2.i
 452 }
 453
 454 define <8 x i16> @test_vuqaddq_s16(<8 x i16> %a, <8 x i16> %b) #0 {
 455 ; CHECK: suqadd v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 456   %vuqadd2.i = tail call <8 x i16> @llvm.aarch64.neon.suqadd.v8i16(<8 x i16> %a, <8 x i16> %b) #4
 457   ret <8 x i16> %vuqadd2.i
 458 }
 459
 460 define <2 x i32> @test_vuqadd_s32(<2 x i32> %a, <2 x i32> %b) #0 {
 461 ; CHECK: suqadd v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 462   %vuqadd2.i = tail call <2 x i32> @llvm.aarch64.neon.suqadd.v2i32(<2 x i32> %a, <2 x i32> %b) #4
 463   ret <2 x i32> %vuqadd2.i
 464 }
 465
 466 define <4 x i32> @test_vuqaddq_s32(<4 x i32> %a, <4 x i32> %b) #0 {
 467 ; CHECK: suqadd v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 468   %vuqadd2.i = tail call <4 x i32> @llvm.aarch64.neon.suqadd.v4i32(<4 x i32> %a, <4 x i32> %b) #4
 469   ret <4 x i32> %vuqadd2.i
 470 }
 471
 472 define <2 x i64> @test_vuqaddq_s64(<2 x i64> %a, <2 x i64> %b) #0 {
 473 ; CHECK: suqadd v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 474   %vuqadd2.i = tail call <2 x i64> @llvm.aarch64.neon.suqadd.v2i64(<2 x i64> %a, <2 x i64> %b) #4
 475   ret <2 x i64> %vuqadd2.i
 476 }
 477
 478 define <8 x i8> @test_vcls_s8(<8 x i8> %a) #0 {
 479 ; CHECK: cls v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 480   %vcls.i = tail call <8 x i8> @llvm.arm.neon.vcls.v8i8(<8 x i8> %a) #4
 481   ret <8 x i8> %vcls.i
 482 }
 483
 484 define <16 x i8> @test_vclsq_s8(<16 x i8> %a) #0 {
 485 ; CHECK: cls v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 486   %vcls.i = tail call <16 x i8> @llvm.arm.neon.vcls.v16i8(<16 x i8> %a) #4
 487   ret <16 x i8> %vcls.i
 488 }
 489
 490 define <4 x i16> @test_vcls_s16(<4 x i16> %a) #0 {
 491 ; CHECK: cls v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 492   %vcls1.i = tail call <4 x i16> @llvm.arm.neon.vcls.v4i16(<4 x i16> %a) #4
 493   ret <4 x i16> %vcls1.i
 494 }
 495
 496 define <8 x i16> @test_vclsq_s16(<8 x i16> %a) #0 {
 497 ; CHECK: cls v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 498   %vcls1.i = tail call <8 x i16> @llvm.arm.neon.vcls.v8i16(<8 x i16> %a) #4
 499   ret <8 x i16> %vcls1.i
 500 }
 501
 502 define <2 x i32> @test_vcls_s32(<2 x i32> %a) #0 {
 503 ; CHECK: cls v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 504   %vcls1.i = tail call <2 x i32> @llvm.arm.neon.vcls.v2i32(<2 x i32> %a) #4
 505   ret <2 x i32> %vcls1.i
 506 }
 507
 508 define <4 x i32> @test_vclsq_s32(<4 x i32> %a) #0 {
 509 ; CHECK: cls v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 510   %vcls1.i = tail call <4 x i32> @llvm.arm.neon.vcls.v4i32(<4 x i32> %a) #4
 511   ret <4 x i32> %vcls1.i
 512 }
 513
 514 define <8 x i8> @test_vclz_s8(<8 x i8> %a) #0 {
 515 ; CHECK: clz v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 516   %vclz.i = tail call <8 x i8> @llvm.ctlz.v8i8(<8 x i8> %a, i1 false) #4
 517   ret <8 x i8> %vclz.i
 518 }
 519
 520 define <16 x i8> @test_vclzq_s8(<16 x i8> %a) #0 {
 521 ; CHECK: clz v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 522   %vclz.i = tail call <16 x i8> @llvm.ctlz.v16i8(<16 x i8> %a, i1 false) #4
 523   ret <16 x i8> %vclz.i
 524 }
 525
 526 define <4 x i16> @test_vclz_s16(<4 x i16> %a) #0 {
 527 ; CHECK: clz v{{[0-9]+}}.4h, v{{[0-9]+}}.4h
 528   %vclz1.i = tail call <4 x i16> @llvm.ctlz.v4i16(<4 x i16> %a, i1 false) #4
 529   ret <4 x i16> %vclz1.i
 530 }
 531
 532 define <8 x i16> @test_vclzq_s16(<8 x i16> %a) #0 {
 533 ; CHECK: clz v{{[0-9]+}}.8h, v{{[0-9]+}}.8h
 534   %vclz1.i = tail call <8 x i16> @llvm.ctlz.v8i16(<8 x i16> %a, i1 false) #4
 535   ret <8 x i16> %vclz1.i
 536 }
 537
 538 define <2 x i32> @test_vclz_s32(<2 x i32> %a) #0 {
 539 ; CHECK: clz v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 540   %vclz1.i = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %a, i1 false) #4
 541   ret <2 x i32> %vclz1.i
 542 }
 543
 544 define <4 x i32> @test_vclzq_s32(<4 x i32> %a) #0 {
 545 ; CHECK: clz v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 546   %vclz1.i = tail call <4 x i32> @llvm.ctlz.v4i32(<4 x i32> %a, i1 false) #4
 547   ret <4 x i32> %vclz1.i
 548 }
 549
 550 define <8 x i8> @test_vcnt_s8(<8 x i8> %a) #0 {
 551 ; CHECK: cnt v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 552   %vctpop.i = tail call <8 x i8> @llvm.ctpop.v8i8(<8 x i8> %a) #4
 553   ret <8 x i8> %vctpop.i
 554 }
 555
 556 define <16 x i8> @test_vcntq_s8(<16 x i8> %a) #0 {
 557 ; CHECK: cnt v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 558   %vctpop.i = tail call <16 x i8> @llvm.ctpop.v16i8(<16 x i8> %a) #4
 559   ret <16 x i8> %vctpop.i
 560 }
 561
 562 define <8 x i8> @test_vmvn_s8(<8 x i8> %a) #0 {
 563 ; CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 564   %neg.i = xor <8 x i8> %a, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
 565   ret <8 x i8> %neg.i
 566 }
 567
 568 define <16 x i8> @test_vmvnq_s8(<16 x i8> %a) #0 {
 569 ; CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 570   %neg.i = xor <16 x i8> %a, <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>
 571   ret <16 x i8> %neg.i
 572 }
 573
 574 define <4 x i16> @test_vmvn_s16(<4 x i16> %a) #0 {
 575 ; CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 576   %neg.i = xor <4 x i16> %a, <i16 -1, i16 -1, i16 -1, i16 -1>
 577   ret <4 x i16> %neg.i
 578 }
 579
 580 define <8 x i16> @test_vmvnq_s16(<8 x i16> %a) #0 {
 581 ; CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 582   %neg.i = xor <8 x i16> %a, <i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1, i16 -1>
 583   ret <8 x i16> %neg.i
 584 }
 585
 586 define <2 x i32> @test_vmvn_s32(<2 x i32> %a) #0 {
 587 ; CHECK: not v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 588   %neg.i = xor <2 x i32> %a, <i32 -1, i32 -1>
 589   ret <2 x i32> %neg.i
 590 }
 591
 592 define <4 x i32> @test_vmvnq_s32(<4 x i32> %a) #0 {
 593 ; CHECK: not v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 594   %neg.i = xor <4 x i32> %a, <i32 -1, i32 -1, i32 -1, i32 -1>
 595   ret <4 x i32> %neg.i
 596 }
 597
 598 define <8 x i8> @test_vrbit_s8(<8 x i8> %a) #0 {
 599 ; CHECK: rbit v{{[0-9]+}}.8b, v{{[0-9]+}}.8b
 600   %vrbit.i = tail call <8 x i8> @llvm.aarch64.neon.rbit.v8i8(<8 x i8> %a) #4
 601   ret <8 x i8> %vrbit.i
 602 }
 603
 604 define <16 x i8> @test_vrbitq_s8(<16 x i8> %a) #0 {
 605 ; CHECK: rbit v{{[0-9]+}}.16b, v{{[0-9]+}}.16b
 606   %vrbit.i = tail call <16 x i8> @llvm.aarch64.neon.rbit.v16i8(<16 x i8> %a) #4
 607   ret <16 x i8> %vrbit.i
 608 }
 609
 610 define <8 x i8> @test_vmovn_s16(<8 x i16> %a) #0 {
 611 ; CHECK: xtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 612   %vmovn.i = trunc <8 x i16> %a to <8 x i8>
 613   ret <8 x i8> %vmovn.i
 614 }
 615
 616 define <4 x i16> @test_vmovn_s32(<4 x i32> %a) #0 {
 617 ; CHECK: xtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 618   %vmovn.i = trunc <4 x i32> %a to <4 x i16>
 619   ret <4 x i16> %vmovn.i
 620 }
 621
 622 define <2 x i32> @test_vmovn_s64(<2 x i64> %a) #0 {
 623 ; CHECK: xtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 624   %vmovn.i = trunc <2 x i64> %a to <2 x i32>
 625   ret <2 x i32> %vmovn.i
 626 }
 627
 628 define <16 x i8> @test_vmovn_high_s16(<8 x i8> %a, <8 x i16> %b) #0 {
 629 ; CHECK: xtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 630   %vmovn.i.i = trunc <8 x i16> %b to <8 x i8>
 631   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> %vmovn.i.i, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 632   ret <16 x i8> %shuffle.i
 633 }
 634
 635 define <8 x i16> @test_vmovn_high_s32(<4 x i16> %a, <4 x i32> %b) #0 {
 636 ; CHECK: xtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 637   %vmovn.i.i = trunc <4 x i32> %b to <4 x i16>
 638   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> %vmovn.i.i, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 639   ret <8 x i16> %shuffle.i
 640 }
 641
 642 define <4 x i32> @test_vmovn_high_s64(<2 x i32> %a, <2 x i64> %b) #0 {
 643 ; CHECK: xtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 644   %vmovn.i.i = trunc <2 x i64> %b to <2 x i32>
 645   %shuffle.i = shufflevector <2 x i32> %a, <2 x i32> %vmovn.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 646   ret <4 x i32> %shuffle.i
 647 }
 648
 649 define <8 x i8> @test_vqmovun_s16(<8 x i16> %a) #0 {
 650 ; CHECK: sqxtun v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 651   %vqdmull1.i = tail call <8 x i8> @llvm.arm.neon.vqmovnsu.v8i8(<8 x i16> %a) #4
 652   ret <8 x i8> %vqdmull1.i
 653 }
 654
 655 define <4 x i16> @test_vqmovun_s32(<4 x i32> %a) #0 {
 656 ; CHECK: sqxtun v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 657   %vqdmull1.i = tail call <4 x i16> @llvm.arm.neon.vqmovnsu.v4i16(<4 x i32> %a) #4
 658   ret <4 x i16> %vqdmull1.i
 659 }
 660
 661 define <2 x i32> @test_vqmovun_s64(<2 x i64> %a) #0 {
 662 ; CHECK: sqxtun v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 663   %vqdmull1.i = tail call <2 x i32> @llvm.arm.neon.vqmovnsu.v2i32(<2 x i64> %a) #4
 664   ret <2 x i32> %vqdmull1.i
 665 }
 666
 667 define <16 x i8> @test_vqmovun_high_s16(<8 x i8> %a, <8 x i16> %b) #0 {
 668 ; CHECK: sqxtun2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 669   %vqdmull1.i.i = tail call <8 x i8> @llvm.arm.neon.vqmovnsu.v8i8(<8 x i16> %b) #4
 670   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> %vqdmull1.i.i, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 671   ret <16 x i8> %shuffle.i
 672 }
 673
 674 define <8 x i16> @test_vqmovun_high_s32(<4 x i16> %a, <4 x i32> %b) #0 {
 675 ; CHECK: sqxtun2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 676   %vqdmull1.i.i = tail call <4 x i16> @llvm.arm.neon.vqmovnsu.v4i16(<4 x i32> %b) #4
 677   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> %vqdmull1.i.i, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 678   ret <8 x i16> %shuffle.i
 679 }
 680
 681 define <4 x i32> @test_vqmovun_high_s64(<2 x i32> %a, <2 x i64> %b) #0 {
 682 ; CHECK: sqxtun2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 683   %vqdmull1.i.i = tail call <2 x i32> @llvm.arm.neon.vqmovnsu.v2i32(<2 x i64> %b) #4
 684   %shuffle.i = shufflevector <2 x i32> %a, <2 x i32> %vqdmull1.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 685   ret <4 x i32> %shuffle.i
 686 }
 687
 688 define <8 x i8> @test_vqmovn_s16(<8 x i16> %a) #0 {
 689 ; CHECK: sqxtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 690   %vqmovn1.i = tail call <8 x i8> @llvm.arm.neon.vqmovns.v8i8(<8 x i16> %a) #4
 691   ret <8 x i8> %vqmovn1.i
 692 }
 693
 694 define <4 x i16> @test_vqmovn_s32(<4 x i32> %a) #0 {
 695 ; CHECK: sqxtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 696   %vqmovn1.i = tail call <4 x i16> @llvm.arm.neon.vqmovns.v4i16(<4 x i32> %a) #4
 697   ret <4 x i16> %vqmovn1.i
 698 }
 699
 700 define <2 x i32> @test_vqmovn_s64(<2 x i64> %a) #0 {
 701 ; CHECK: sqxtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 702   %vqmovn1.i = tail call <2 x i32> @llvm.arm.neon.vqmovns.v2i32(<2 x i64> %a) #4
 703   ret <2 x i32> %vqmovn1.i
 704 }
 705
 706 define <16 x i8> @test_vqmovn_high_s16(<8 x i8> %a, <8 x i16> %b) #0 {
 707 ; CHECK: sqxtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 708   %vqmovn1.i.i = tail call <8 x i8> @llvm.arm.neon.vqmovns.v8i8(<8 x i16> %b) #4
 709   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> %vqmovn1.i.i, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 710   ret <16 x i8> %shuffle.i
 711 }
 712
 713 define <8 x i16> @test_vqmovn_high_s32(<4 x i16> %a, <4 x i32> %b) #0 {
 714 ; CHECK: test_vqmovn_high_s32
 715   %vqmovn1.i.i = tail call <4 x i16> @llvm.arm.neon.vqmovns.v4i16(<4 x i32> %b) #4
 716   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> %vqmovn1.i.i, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 717   ret <8 x i16> %shuffle.i
 718 }
 719
 720 define <4 x i32> @test_vqmovn_high_s64(<2 x i32> %a, <2 x i64> %b) #0 {
 721 ; CHECK: test_vqmovn_high_s64
 722   %vqmovn1.i.i = tail call <2 x i32> @llvm.arm.neon.vqmovns.v2i32(<2 x i64> %b) #4
 723   %shuffle.i = shufflevector <2 x i32> %a, <2 x i32> %vqmovn1.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 724   ret <4 x i32> %shuffle.i
 725 }
 726
 727 define <8 x i8> @test_vqmovn_u16(<8 x i16> %a) #0 {
 728 ; CHECK: uqxtn v{{[0-9]+}}.8b, v{{[0-9]+}}.8h
 729   %vqmovn1.i = tail call <8 x i8> @llvm.arm.neon.vqmovnu.v8i8(<8 x i16> %a) #4
 730   ret <8 x i8> %vqmovn1.i
 731 }
 732
 733 define <4 x i16> @test_vqmovn_u32(<4 x i32> %a) #0 {
 734 ; CHECK: uqxtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 735   %vqmovn1.i = tail call <4 x i16> @llvm.arm.neon.vqmovnu.v4i16(<4 x i32> %a) #4
 736   ret <4 x i16> %vqmovn1.i
 737 }
 738
 739 define <2 x i32> @test_vqmovn_u64(<2 x i64> %a) #0 {
 740 ; CHECK: uqxtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 741   %vqmovn1.i = tail call <2 x i32> @llvm.arm.neon.vqmovnu.v2i32(<2 x i64> %a) #4
 742   ret <2 x i32> %vqmovn1.i
 743 }
 744
 745 define <16 x i8> @test_vqmovn_high_u16(<8 x i8> %a, <8 x i16> %b) #0 {
 746 ; CHECK: uqxtn2 v{{[0-9]+}}.16b, v{{[0-9]+}}.8h
 747   %vqmovn1.i.i = tail call <8 x i8> @llvm.arm.neon.vqmovnu.v8i8(<8 x i16> %b) #4
 748   %shuffle.i = shufflevector <8 x i8> %a, <8 x i8> %vqmovn1.i.i, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 749   ret <16 x i8> %shuffle.i
 750 }
 751
 752 define <8 x i16> @test_vqmovn_high_u32(<4 x i16> %a, <4 x i32> %b) #0 {
 753 ; CHECK: uqxtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 754   %vqmovn1.i.i = tail call <4 x i16> @llvm.arm.neon.vqmovnu.v4i16(<4 x i32> %b) #4
 755   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> %vqmovn1.i.i, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 756   ret <8 x i16> %shuffle.i
 757 }
 758
 759 define <4 x i32> @test_vqmovn_high_u64(<2 x i32> %a, <2 x i64> %b) #0 {
 760 ; CHECK: uqxtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 761   %vqmovn1.i.i = tail call <2 x i32> @llvm.arm.neon.vqmovnu.v2i32(<2 x i64> %b) #4
 762   %shuffle.i = shufflevector <2 x i32> %a, <2 x i32> %vqmovn1.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 763   ret <4 x i32> %shuffle.i
 764 }
 765
 766 define <8 x i16> @test_vshll_n_s8(<8 x i8> %a) #0 {
 767 ; CHECK: shll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #8
 768   %1 = sext <8 x i8> %a to <8 x i16>
 769   %vshll_n = shl <8 x i16> %1, <i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8>
 770   ret <8 x i16> %vshll_n
 771 }
 772
 773 define <4 x i32> @test_vshll_n_s16(<4 x i16> %a) #0 {
 774 ; CHECK: shll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #16
 775   %1 = sext <4 x i16> %a to <4 x i32>
 776   %vshll_n = shl <4 x i32> %1, <i32 16, i32 16, i32 16, i32 16>
 777   ret <4 x i32> %vshll_n
 778 }
 779
 780 define <2 x i64> @test_vshll_n_s32(<2 x i32> %a) #0 {
 781 ; CHECK: shll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #32
 782   %1 = sext <2 x i32> %a to <2 x i64>
 783   %vshll_n = shl <2 x i64> %1, <i64 32, i64 32>
 784   ret <2 x i64> %vshll_n
 785 }
 786
 787 define <8 x i16> @test_vshll_n_u8(<8 x i8> %a) #0 {
 788 ; CHECK: shll {{v[0-9]+}}.8h, {{v[0-9]+}}.8b, #8
 789   %1 = zext <8 x i8> %a to <8 x i16>
 790   %vshll_n = shl <8 x i16> %1, <i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8>
 791   ret <8 x i16> %vshll_n
 792 }
 793
 794 define <4 x i32> @test_vshll_n_u16(<4 x i16> %a) #0 {
 795 ; CHECK: shll {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, #16
 796   %1 = zext <4 x i16> %a to <4 x i32>
 797   %vshll_n = shl <4 x i32> %1, <i32 16, i32 16, i32 16, i32 16>
 798   ret <4 x i32> %vshll_n
 799 }
 800
 801 define <2 x i64> @test_vshll_n_u32(<2 x i32> %a) #0 {
 802 ; CHECK: shll {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, #32
 803   %1 = zext <2 x i32> %a to <2 x i64>
 804   %vshll_n = shl <2 x i64> %1, <i64 32, i64 32>
 805   ret <2 x i64> %vshll_n
 806 }
 807
 808 define <8 x i16> @test_vshll_high_n_s8(<16 x i8> %a) #0 {
 809 ; CHECK: shll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #8
 810   %shuffle.i = shufflevector <16 x i8> %a, <16 x i8> undef, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 811   %1 = sext <8 x i8> %shuffle.i to <8 x i16>
 812   %vshll_n = shl <8 x i16> %1, <i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8>
 813   ret <8 x i16> %vshll_n
 814 }
 815
 816 define <4 x i32> @test_vshll_high_n_s16(<8 x i16> %a) #0 {
 817 ; CHECK: shll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #16
 818   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 819   %1 = sext <4 x i16> %shuffle.i to <4 x i32>
 820   %vshll_n = shl <4 x i32> %1, <i32 16, i32 16, i32 16, i32 16>
 821   ret <4 x i32> %vshll_n
 822 }
 823
 824 define <2 x i64> @test_vshll_high_n_s32(<4 x i32> %a) #0 {
 825 ; CHECK: shll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #32
 826   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 827   %1 = sext <2 x i32> %shuffle.i to <2 x i64>
 828   %vshll_n = shl <2 x i64> %1, <i64 32, i64 32>
 829   ret <2 x i64> %vshll_n
 830 }
 831
 832 define <8 x i16> @test_vshll_high_n_u8(<16 x i8> %a) #0 {
 833 ; CHECK: shll2 {{v[0-9]+}}.8h, {{v[0-9]+}}.16b, #8
 834   %shuffle.i = shufflevector <16 x i8> %a, <16 x i8> undef, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 835   %1 = zext <8 x i8> %shuffle.i to <8 x i16>
 836   %vshll_n = shl <8 x i16> %1, <i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8, i16 8>
 837   ret <8 x i16> %vshll_n
 838 }
 839
 840 define <4 x i32> @test_vshll_high_n_u16(<8 x i16> %a) #0 {
 841 ; CHECK: shll2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, #16
 842   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 843   %1 = zext <4 x i16> %shuffle.i to <4 x i32>
 844   %vshll_n = shl <4 x i32> %1, <i32 16, i32 16, i32 16, i32 16>
 845   ret <4 x i32> %vshll_n
 846 }
 847
 848 define <2 x i64> @test_vshll_high_n_u32(<4 x i32> %a) #0 {
 849 ; CHECK: shll2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, #32
 850   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 851   %1 = zext <2 x i32> %shuffle.i to <2 x i64>
 852   %vshll_n = shl <2 x i64> %1, <i64 32, i64 32>
 853   ret <2 x i64> %vshll_n
 854 }
 855
 856 define <4 x i16> @test_vcvt_f16_f32(<4 x float> %a) #0 {
 857 ; CHECK: fcvtn v{{[0-9]+}}.4h, v{{[0-9]+}}.4s
 858   %vcvt1.i = tail call <4 x i16> @llvm.arm.neon.vcvtfp2hf(<4 x float> %a) #4
 859   ret <4 x i16> %vcvt1.i
 860 }
 861
 862 define <8 x i16> @test_vcvt_high_f16_f32(<4 x i16> %a, <4 x float> %b) #0 {
 863 ; CHECK: fcvtn2 v{{[0-9]+}}.8h, v{{[0-9]+}}.4s
 864   %vcvt1.i.i = tail call <4 x i16> @llvm.arm.neon.vcvtfp2hf(<4 x float> %b) #4
 865   %shuffle.i = shufflevector <4 x i16> %a, <4 x i16> %vcvt1.i.i, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 866   ret <8 x i16> %shuffle.i
 867 }
 868
 869 define <4 x float> @test_vcvt_f32_f16(<4 x i16> %a) #0 {
 870 ; CHECK: fcvtl v{{[0-9]+}}.4s, v{{[0-9]+}}.4h
 871   %vcvt1.i = tail call <4 x float> @llvm.arm.neon.vcvthf2fp(<4 x i16> %a) #4
 872   ret <4 x float> %vcvt1.i
 873 }
 874
 875 define <4 x float> @test_vcvt_high_f32_f16(<8 x i16> %a) #0 {
 876 ; CHECK: fcvtl2 v{{[0-9]+}}.4s, v{{[0-9]+}}.8h
 877   %shuffle.i.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 878   %vcvt1.i.i = tail call <4 x float> @llvm.arm.neon.vcvthf2fp(<4 x i16> %shuffle.i.i) #4
 879   ret <4 x float> %vcvt1.i.i
 880 }
 881
 882 define <2 x float> @test_vcvt_f32_f64(<2 x double> %a) #0 {
 883 ; CHECK: fcvtn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 884   %vcvt.i = fptrunc <2 x double> %a to <2 x float>
 885   ret <2 x float> %vcvt.i
 886 }
 887
 888 define <4 x float> @test_vcvt_high_f32_f64(<2 x float> %a, <2 x double> %b) #0 {
 889 ; CHECK: fcvtn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 890   %vcvt.i.i = fptrunc <2 x double> %b to <2 x float>
 891   %shuffle.i = shufflevector <2 x float> %a, <2 x float> %vcvt.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 892   ret <4 x float> %shuffle.i
 893 }
 894
 895 define <2 x float> @test_vcvtx_f32_f64(<2 x double> %a) #0 {
 896 ; CHECK: fcvtxn v{{[0-9]+}}.2s, v{{[0-9]+}}.2d
 897   %vcvtx_f32_f641.i = tail call <2 x float> @llvm.aarch64.neon.fcvtxn.v2f32.v2f64(<2 x double> %a) #4
 898   ret <2 x float> %vcvtx_f32_f641.i
 899 }
 900
 901 define <4 x float> @test_vcvtx_high_f32_f64(<2 x float> %a, <2 x double> %b) #0 {
 902 ; CHECK: fcvtxn2 v{{[0-9]+}}.4s, v{{[0-9]+}}.2d
 903   %vcvtx_f32_f641.i.i = tail call <2 x float> @llvm.aarch64.neon.fcvtxn.v2f32.v2f64(<2 x double> %b) #4
 904   %shuffle.i = shufflevector <2 x float> %a, <2 x float> %vcvtx_f32_f641.i.i, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 905   ret <4 x float> %shuffle.i
 906 }
 907
 908 define <2 x double> @test_vcvt_f64_f32(<2 x float> %a) #0 {
 909 ; CHECK: fcvtl v{{[0-9]+}}.2d, v{{[0-9]+}}.2s
 910   %vcvt.i = fpext <2 x float> %a to <2 x double>
 911   ret <2 x double> %vcvt.i
 912 }
 913
 914 define <2 x double> @test_vcvt_high_f64_f32(<4 x float> %a) #0 {
 915 ; CHECK: fcvtl2 v{{[0-9]+}}.2d, v{{[0-9]+}}.4s
 916   %shuffle.i.i = shufflevector <4 x float> %a, <4 x float> undef, <2 x i32> <i32 2, i32 3>
 917   %vcvt.i.i = fpext <2 x float> %shuffle.i.i to <2 x double>
 918   ret <2 x double> %vcvt.i.i
 919 }
 920
 921 define <2 x float> @test_vrndn_f32(<2 x float> %a) #0 {
 922 ; CHECK: frintn v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 923   %vrndn1.i = tail call <2 x float> @llvm.aarch64.neon.frintn.v2f32(<2 x float> %a) #4
 924   ret <2 x float> %vrndn1.i
 925 }
 926
 927 define <4 x float> @test_vrndnq_f32(<4 x float> %a) #0 {
 928 ; CHECK: frintn v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 929   %vrndn1.i = tail call <4 x float> @llvm.aarch64.neon.frintn.v4f32(<4 x float> %a) #4
 930   ret <4 x float> %vrndn1.i
 931 }
 932
 933 define <2 x double> @test_vrndnq_f64(<2 x double> %a) #0 {
 934 ; CHECK: frintn v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 935   %vrndn1.i = tail call <2 x double> @llvm.aarch64.neon.frintn.v2f64(<2 x double> %a) #4
 936   ret <2 x double> %vrndn1.i
 937 }
 938
 939 define <2 x float> @test_vrnda_f32(<2 x float> %a) #0 {
 940 ; CHECK: frinta v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 941   %vrnda1.i = tail call <2 x float> @llvm.round.v2f32(<2 x float> %a) #4
 942   ret <2 x float> %vrnda1.i
 943 }
 944
 945 define <4 x float> @test_vrndaq_f32(<4 x float> %a) #0 {
 946 ; CHECK: frinta v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 947    %vrnda1.i = tail call <4 x float> @llvm.round.v4f32(<4 x float> %a) #4
 948   ret <4 x float> %vrnda1.i
 949 }
 950
 951 define <2 x double> @test_vrndaq_f64(<2 x double> %a) #0 {
 952 ; CHECK: frinta v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 953   %vrnda1.i = tail call <2 x double> @llvm.round.v2f64(<2 x double> %a) #4
 954   ret <2 x double> %vrnda1.i
 955 }
 956
 957 define <2 x float> @test_vrndp_f32(<2 x float> %a) #0 {
 958 ; CHECK: frintp v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 959   %vrndp1.i = tail call <2 x float> @llvm.ceil.v2f32(<2 x float> %a) #4
 960   ret <2 x float> %vrndp1.i
 961 }
 962
 963 define <4 x float> @test_vrndpq_f32(<4 x float> %a) #0 {
 964 ; CHECK: frintp v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 965  %vrndp1.i = tail call <4 x float> @llvm.ceil.v4f32(<4 x float> %a) #4
 966   ret <4 x float> %vrndp1.i
 967 }
 968
 969 define <2 x double> @test_vrndpq_f64(<2 x double> %a) #0 {
 970 ; CHECK: frintp v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 971   %vrndp1.i = tail call <2 x double> @llvm.ceil.v2f64(<2 x double> %a) #4
 972   ret <2 x double> %vrndp1.i
 973 }
 974
 975 define <2 x float> @test_vrndm_f32(<2 x float> %a) #0 {
 976 ; CHECK: frintm v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 977   %vrndm1.i = tail call <2 x float> @llvm.floor.v2f32(<2 x float> %a) #4
 978   ret <2 x float> %vrndm1.i
 979 }
 980
 981 define <4 x float> @test_vrndmq_f32(<4 x float> %a) #0 {
 982 ; CHECK: frintm v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
 983   %vrndm1.i = tail call <4 x float> @llvm.floor.v4f32(<4 x float> %a) #4
 984   ret <4 x float> %vrndm1.i
 985 }
 986
 987 define <2 x double> @test_vrndmq_f64(<2 x double> %a) #0 {
 988 ; CHECK: frintm v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
 989    %vrndm1.i = tail call <2 x double> @llvm.floor.v2f64(<2 x double> %a) #4
 990   ret <2 x double> %vrndm1.i
 991 }
 992
 993 define <2 x float> @test_vrndx_f32(<2 x float> %a) #0 {
 994 ; CHECK: frintx v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
 995   %vrndx1.i = tail call <2 x float> @llvm.rint.v2f32(<2 x float> %a) #4
 996   ret <2 x float> %vrndx1.i
 997 }
 998
 999 define <4 x float> @test_vrndxq_f32(<4 x float> %a) #0 {
1000 ; CHECK: frintx v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1001   %vrndx1.i = tail call <4 x float> @llvm.rint.v4f32(<4 x float> %a) #4
1002   ret <4 x float> %vrndx1.i
1003 }
1004
1005 define <2 x double> @test_vrndxq_f64(<2 x double> %a) #0 {
1006 ; CHECK: frintx v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1007   %vrndx1.i = tail call <2 x double> @llvm.rint.v2f64(<2 x double> %a) #4
1008   ret <2 x double> %vrndx1.i
1009 }
1010
1011 define <2 x float> @test_vrnd_f32(<2 x float> %a) #0 {
1012 ; CHECK: frintz v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1013    %vrnd1.i = tail call <2 x float> @llvm.trunc.v2f32(<2 x float> %a) #4
1014   ret <2 x float> %vrnd1.i
1015 }
1016
1017 define <4 x float> @test_vrndq_f32(<4 x float> %a) #0 {
1018 ; CHECK: frintz v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1019   %vrnd1.i = tail call <4 x float> @llvm.trunc.v4f32(<4 x float> %a) #4
1020   ret <4 x float> %vrnd1.i
1021 }
1022
1023 define <2 x double> @test_vrndq_f64(<2 x double> %a) #0 {
1024 ; CHECK: frintz v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1025   %vrnd1.i = tail call <2 x double> @llvm.trunc.v2f64(<2 x double> %a) #4
1026   ret <2 x double> %vrnd1.i
1027 }
1028
1029 define <2 x float> @test_vrndi_f32(<2 x float> %a) #0 {
1030 ; CHECK: frinti v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1031   %vrndi1.i = tail call <2 x float> @llvm.nearbyint.v2f32(<2 x float> %a) #4
1032   ret <2 x float> %vrndi1.i
1033 }
1034
1035 define <4 x float> @test_vrndiq_f32(<4 x float> %a) #0 {
1036 ; CHECK: frinti v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1037   %vrndi1.i = tail call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %a) #4
1038   ret <4 x float> %vrndi1.i
1039 }
1040
1041 define <2 x double> @test_vrndiq_f64(<2 x double> %a) #0 {
1042 ; CHECK: frinti v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1043   %vrndi1.i = tail call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %a) #4
1044   ret <2 x double> %vrndi1.i
1045 }
1046
1047 define <2 x i32> @test_vcvt_s32_f32(<2 x float> %a) #0 {
1048 ; CHECK: fcvtzs v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1049   %vcvt.i = fptosi <2 x float> %a to <2 x i32>
1050   ret <2 x i32> %vcvt.i
1051 }
1052
1053 define <4 x i32> @test_vcvtq_s32_f32(<4 x float> %a) #0 {
1054 ; CHECK: fcvtzs v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1055   %vcvt.i = fptosi <4 x float> %a to <4 x i32>
1056   ret <4 x i32> %vcvt.i
1057 }
1058
1059 define <2 x i64> @test_vcvtq_s64_f64(<2 x double> %a) #0 {
1060 ; CHECK: fcvtzs v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1061   %vcvt.i = fptosi <2 x double> %a to <2 x i64>
1062   ret <2 x i64> %vcvt.i
1063 }
1064
1065 define <2 x i32> @test_vcvt_u32_f32(<2 x float> %a) #0 {
1066 ; CHECK: fcvtzu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1067   %vcvt.i = fptoui <2 x float> %a to <2 x i32>
1068   ret <2 x i32> %vcvt.i
1069 }
1070
1071 define <4 x i32> @test_vcvtq_u32_f32(<4 x float> %a) #0 {
1072 ; CHECK: fcvtzu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1073   %vcvt.i = fptoui <4 x float> %a to <4 x i32>
1074   ret <4 x i32> %vcvt.i
1075 }
1076
1077 define <2 x i64> @test_vcvtq_u64_f64(<2 x double> %a) #0 {
1078 ; CHECK: fcvtzu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1079   %vcvt.i = fptoui <2 x double> %a to <2 x i64>
1080   ret <2 x i64> %vcvt.i
1081 }
1082
1083 define <2 x i32> @test_vcvtn_s32_f32(<2 x float> %a) #0 {
1084 ; CHECK: fcvtns v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1085   %vcvtns_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtns.v2i32.v2f32(<2 x float> %a) #4
1086   ret <2 x i32> %vcvtns_f321.i
1087 }
1088
1089 define <4 x i32> @test_vcvtnq_s32_f32(<4 x float> %a) #0 {
1090 ; CHECK: fcvtns v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1091   %vcvtns_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtns.v4i32.v4f32(<4 x float> %a) #4
1092   ret <4 x i32> %vcvtns_f321.i
1093 }
1094
1095 define <2 x i64> @test_vcvtnq_s64_f64(<2 x double> %a) #0 {
1096 ; CHECK: fcvtns v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1097   %vcvtns_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtns.v2i64.v2f64(<2 x double> %a) #4
1098   ret <2 x i64> %vcvtns_f641.i
1099 }
1100
1101 define <2 x i32> @test_vcvtn_u32_f32(<2 x float> %a) #0 {
1102 ; CHECK: fcvtnu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1103   %vcvtnu_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtnu.v2i32.v2f32(<2 x float> %a) #4
1104   ret <2 x i32> %vcvtnu_f321.i
1105 }
1106
1107 define <4 x i32> @test_vcvtnq_u32_f32(<4 x float> %a) #0 {
1108 ; CHECK: fcvtnu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1109   %vcvtnu_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtnu.v4i32.v4f32(<4 x float> %a) #4
1110   ret <4 x i32> %vcvtnu_f321.i
1111 }
1112
1113 define <2 x i64> @test_vcvtnq_u64_f64(<2 x double> %a) #0 {
1114 ; CHECK: fcvtnu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1115   %vcvtnu_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtnu.v2i64.v2f64(<2 x double> %a) #4
1116   ret <2 x i64> %vcvtnu_f641.i
1117 }
1118
1119 define <2 x i32> @test_vcvtp_s32_f32(<2 x float> %a) #0 {
1120 ; CHECK: fcvtps v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1121   %vcvtps_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtps.v2i32.v2f32(<2 x float> %a) #4
1122   ret <2 x i32> %vcvtps_f321.i
1123 }
1124
1125 define <4 x i32> @test_vcvtpq_s32_f32(<4 x float> %a) #0 {
1126 ; CHECK: fcvtps v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1127   %vcvtps_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtps.v4i32.v4f32(<4 x float> %a) #4
1128   ret <4 x i32> %vcvtps_f321.i
1129 }
1130
1131 define <2 x i64> @test_vcvtpq_s64_f64(<2 x double> %a) #0 {
1132 ; CHECK: fcvtps v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1133   %vcvtps_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtps.v2i64.v2f64(<2 x double> %a) #4
1134   ret <2 x i64> %vcvtps_f641.i
1135 }
1136
1137 define <2 x i32> @test_vcvtp_u32_f32(<2 x float> %a) #0 {
1138 ; CHECK: fcvtpu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1139   %vcvtpu_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtpu.v2i32.v2f32(<2 x float> %a) #4
1140   ret <2 x i32> %vcvtpu_f321.i
1141 }
1142
1143 define <4 x i32> @test_vcvtpq_u32_f32(<4 x float> %a) #0 {
1144 ; CHECK: fcvtpu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1145   %vcvtpu_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtpu.v4i32.v4f32(<4 x float> %a) #4
1146   ret <4 x i32> %vcvtpu_f321.i
1147 }
1148
1149 define <2 x i64> @test_vcvtpq_u64_f64(<2 x double> %a) #0 {
1150 ; CHECK: fcvtpu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1151   %vcvtpu_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtpu.v2i64.v2f64(<2 x double> %a) #4
1152   ret <2 x i64> %vcvtpu_f641.i
1153 }
1154
1155 define <2 x i32> @test_vcvtm_s32_f32(<2 x float> %a) #0 {
1156 ; CHECK: fcvtms v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1157   %vcvtms_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtms.v2i32.v2f32(<2 x float> %a) #4
1158   ret <2 x i32> %vcvtms_f321.i
1159 }
1160
1161 define <4 x i32> @test_vcvtmq_s32_f32(<4 x float> %a) #0 {
1162 ; CHECK: fcvtms v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1163   %vcvtms_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtms.v4i32.v4f32(<4 x float> %a) #4
1164   ret <4 x i32> %vcvtms_f321.i
1165 }
1166
1167 define <2 x i64> @test_vcvtmq_s64_f64(<2 x double> %a) #0 {
1168 ; CHECK: fcvtms v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1169   %vcvtms_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtms.v2i64.v2f64(<2 x double> %a) #4
1170   ret <2 x i64> %vcvtms_f641.i
1171 }
1172
1173 define <2 x i32> @test_vcvtm_u32_f32(<2 x float> %a) #0 {
1174 ; CHECK: fcvtmu v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1175   %vcvtmu_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtmu.v2i32.v2f32(<2 x float> %a) #4
1176   ret <2 x i32> %vcvtmu_f321.i
1177 }
1178
1179 define <4 x i32> @test_vcvtmq_u32_f32(<4 x float> %a) #0 {
1180 ; CHECK: fcvtmu v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1181   %vcvtmu_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtmu.v4i32.v4f32(<4 x float> %a) #4
1182   ret <4 x i32> %vcvtmu_f321.i
1183 }
1184
1185 define <2 x i64> @test_vcvtmq_u64_f64(<2 x double> %a) #0 {
1186 ; CHECK: fcvtmu v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1187   %vcvtmu_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtmu.v2i64.v2f64(<2 x double> %a) #4
1188   ret <2 x i64> %vcvtmu_f641.i
1189 }
1190
1191 define <2 x i32> @test_vcvta_s32_f32(<2 x float> %a) #0 {
1192 ; CHECK: fcvtas v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1193   %vcvtas_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtas.v2i32.v2f32(<2 x float> %a) #4
1194   ret <2 x i32> %vcvtas_f321.i
1195 }
1196
1197 define <4 x i32> @test_vcvtaq_s32_f32(<4 x float> %a) #0 {
1198 ; CHECK: fcvtas v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1199   %vcvtas_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtas.v4i32.v4f32(<4 x float> %a) #4
1200   ret <4 x i32> %vcvtas_f321.i
1201 }
1202
1203 define <2 x i64> @test_vcvtaq_s64_f64(<2 x double> %a) #0 {
1204 ; CHECK: fcvtas v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1205   %vcvtas_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtas.v2i64.v2f64(<2 x double> %a) #4
1206   ret <2 x i64> %vcvtas_f641.i
1207 }
1208
1209 define <2 x i32> @test_vcvta_u32_f32(<2 x float> %a) #0 {
1210 ; CHECK: fcvtau v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1211   %vcvtau_f321.i = tail call <2 x i32> @llvm.aarch64.neon.fcvtau.v2i32.v2f32(<2 x float> %a) #4
1212   ret <2 x i32> %vcvtau_f321.i
1213 }
1214
1215 define <4 x i32> @test_vcvtaq_u32_f32(<4 x float> %a) #0 {
1216 ; CHECK: fcvtau v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1217   %vcvtau_f321.i = tail call <4 x i32> @llvm.aarch64.neon.fcvtau.v4i32.v4f32(<4 x float> %a) #4
1218   ret <4 x i32> %vcvtau_f321.i
1219 }
1220
1221 define <2 x i64> @test_vcvtaq_u64_f64(<2 x double> %a) #0 {
1222 ; CHECK: fcvtau v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1223   %vcvtau_f641.i = tail call <2 x i64> @llvm.aarch64.neon.fcvtau.v2i64.v2f64(<2 x double> %a) #4
1224   ret <2 x i64> %vcvtau_f641.i
1225 }
1226
1227 define <2 x float> @test_vrsqrte_f32(<2 x float> %a) #0 {
1228 ; CHECK: frsqrte v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1229   %vrsqrte1.i = tail call <2 x float> @llvm.arm.neon.vrsqrte.v2f32(<2 x float> %a) #4
1230   ret <2 x float> %vrsqrte1.i
1231 }
1232
1233 define <4 x float> @test_vrsqrteq_f32(<4 x float> %a) #0 {
1234 ; CHECK: frsqrte v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1235   %vrsqrte1.i = tail call <4 x float> @llvm.arm.neon.vrsqrte.v4f32(<4 x float> %a) #4
1236   ret <4 x float> %vrsqrte1.i
1237 }
1238
1239 define <2 x double> @test_vrsqrteq_f64(<2 x double> %a) #0 {
1240 ; CHECK: frsqrte v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1241   %vrsqrte1.i = tail call <2 x double> @llvm.arm.neon.vrsqrte.v2f64(<2 x double> %a) #4
1242   ret <2 x double> %vrsqrte1.i
1243 }
1244
1245 define <2 x float> @test_vrecpe_f32(<2 x float> %a) #0 {
1246 ; CHECK: frecpe v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1247   %vrecpe1.i = tail call <2 x float> @llvm.arm.neon.vrecpe.v2f32(<2 x float> %a) #4
1248   ret <2 x float> %vrecpe1.i
1249 }
1250
1251 define <4 x float> @test_vrecpeq_f32(<4 x float> %a) #0 {
1252 ; CHECK: frecpe v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1253   %vrecpe1.i = tail call <4 x float> @llvm.arm.neon.vrecpe.v4f32(<4 x float> %a) #4
1254   ret <4 x float> %vrecpe1.i
1255 }
1256
1257 define <2 x double> @test_vrecpeq_f64(<2 x double> %a) #0 {
1258 ; CHECK: frecpe v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1259   %vrecpe1.i = tail call <2 x double> @llvm.arm.neon.vrecpe.v2f64(<2 x double> %a) #4
1260   ret <2 x double> %vrecpe1.i
1261 }
1262
1263 define <2 x i32> @test_vrecpe_u32(<2 x i32> %a) #0 {
1264 ; CHECK: urecpe v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1265   %vrecpe1.i = tail call <2 x i32> @llvm.arm.neon.vrecpe.v2i32(<2 x i32> %a) #4
1266   ret <2 x i32> %vrecpe1.i
1267 }
1268
1269 define <4 x i32> @test_vrecpeq_u32(<4 x i32> %a) #0 {
1270 ; CHECK: urecpe v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1271   %vrecpe1.i = tail call <4 x i32> @llvm.arm.neon.vrecpe.v4i32(<4 x i32> %a) #4
1272   ret <4 x i32> %vrecpe1.i
1273 }
1274
1275 define <2 x float> @test_vsqrt_f32(<2 x float> %a) #0 {
1276 ; CHECK: fsqrt v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1277   %vsqrt1.i = tail call <2 x float> @llvm.sqrt.v2f32(<2 x float> %a) #4
1278   ret <2 x float> %vsqrt1.i
1279 }
1280
1281 define <4 x float> @test_vsqrtq_f32(<4 x float> %a) #0 {
1282 ; CHECK: fsqrt v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1283   %vsqrt1.i = tail call <4 x float> @llvm.sqrt.v4f32(<4 x float> %a) #4
1284   ret <4 x float> %vsqrt1.i
1285 }
1286
1287 define <2 x double> @test_vsqrtq_f64(<2 x double> %a) #0 {
1288 ; CHECK: fsqrt v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1289   %vsqrt1.i = tail call <2 x double> @llvm.sqrt.v2f64(<2 x double> %a) #4
1290   ret <2 x double> %vsqrt1.i
1291 }
1292
1293 define <2 x float> @test_vcvt_f32_s32(<2 x i32> %a) #0 {
1294 ; CHECK: scvtf v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1295   %vcvt.i = sitofp <2 x i32> %a to <2 x float>
1296   ret <2 x float> %vcvt.i
1297 }
1298
1299 define <2 x float> @test_vcvt_f32_u32(<2 x i32> %a) #0 {
1300 ; CHECK: ucvtf v{{[0-9]+}}.2s, v{{[0-9]+}}.2s
1301   %vcvt.i = uitofp <2 x i32> %a to <2 x float>
1302   ret <2 x float> %vcvt.i
1303 }
1304
1305 define <4 x float> @test_vcvtq_f32_s32(<4 x i32> %a) #0 {
1306 ; CHECK: scvtf v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1307   %vcvt.i = sitofp <4 x i32> %a to <4 x float>
1308   ret <4 x float> %vcvt.i
1309 }
1310
1311 define <4 x float> @test_vcvtq_f32_u32(<4 x i32> %a) #0 {
1312 ; CHECK: ucvtf v{{[0-9]+}}.4s, v{{[0-9]+}}.4s
1313   %vcvt.i = uitofp <4 x i32> %a to <4 x float>
1314   ret <4 x float> %vcvt.i
1315 }
1316
1317 define <2 x double> @test_vcvtq_f64_s64(<2 x i64> %a) #0 {
1318 ; CHECK: scvtf v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1319   %vcvt.i = sitofp <2 x i64> %a to <2 x double>
1320   ret <2 x double> %vcvt.i
1321 }
1322
1323 define <2 x double> @test_vcvtq_f64_u64(<2 x i64> %a) #0 {
1324 ; CHECK: ucvtf v{{[0-9]+}}.2d, v{{[0-9]+}}.2d
1325   %vcvt.i = uitofp <2 x i64> %a to <2 x double>
1326   ret <2 x double> %vcvt.i
1327 }
1328
1329 declare <2 x double> @llvm.sqrt.v2f64(<2 x double>) #2
1330
1331 declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) #2
1332
1333 declare <2 x float> @llvm.sqrt.v2f32(<2 x float>) #2
1334
1335 declare <4 x i32> @llvm.arm.neon.vrecpe.v4i32(<4 x i32>) #2
1336
1337 declare <2 x i32> @llvm.arm.neon.vrecpe.v2i32(<2 x i32>) #2
1338
1339 declare <2 x double> @llvm.arm.neon.vrecpe.v2f64(<2 x double>) #2
1340
1341 declare <4 x float> @llvm.arm.neon.vrecpe.v4f32(<4 x float>) #2
1342
1343 declare <2 x float> @llvm.arm.neon.vrecpe.v2f32(<2 x float>) #2
1344
1345 declare <2 x double> @llvm.arm.neon.vrsqrte.v2f64(<2 x double>) #2
1346
1347 declare <4 x float> @llvm.arm.neon.vrsqrte.v4f32(<4 x float>) #2
1348
1349 declare <2 x float> @llvm.arm.neon.vrsqrte.v2f32(<2 x float>) #2
1350
1351 declare <2 x i64> @llvm.aarch64.neon.fcvtau.v2i64.v2f64(<2 x double>) #2
1352
1353 declare <4 x i32> @llvm.aarch64.neon.fcvtau.v4i32.v4f32(<4 x float>) #2
1354
1355 declare <2 x i32> @llvm.aarch64.neon.fcvtau.v2i32.v2f32(<2 x float>) #2
1356
1357 declare <2 x i64> @llvm.aarch64.neon.fcvtas.v2i64.v2f64(<2 x double>) #2
1358
1359 declare <4 x i32> @llvm.aarch64.neon.fcvtas.v4i32.v4f32(<4 x float>) #2
1360
1361 declare <2 x i32> @llvm.aarch64.neon.fcvtas.v2i32.v2f32(<2 x float>) #2
1362
1363 declare <2 x i64> @llvm.aarch64.neon.fcvtmu.v2i64.v2f64(<2 x double>) #2
1364
1365 declare <4 x i32> @llvm.aarch64.neon.fcvtmu.v4i32.v4f32(<4 x float>) #2
1366
1367 declare <2 x i32> @llvm.aarch64.neon.fcvtmu.v2i32.v2f32(<2 x float>) #2
1368
1369 declare <2 x i64> @llvm.aarch64.neon.fcvtms.v2i64.v2f64(<2 x double>) #2
1370
1371 declare <4 x i32> @llvm.aarch64.neon.fcvtms.v4i32.v4f32(<4 x float>) #2
1372
1373 declare <2 x i32> @llvm.aarch64.neon.fcvtms.v2i32.v2f32(<2 x float>) #2
1374
1375 declare <2 x i64> @llvm.aarch64.neon.fcvtpu.v2i64.v2f64(<2 x double>) #2
1376
1377 declare <4 x i32> @llvm.aarch64.neon.fcvtpu.v4i32.v4f32(<4 x float>) #2
1378
1379 declare <2 x i32> @llvm.aarch64.neon.fcvtpu.v2i32.v2f32(<2 x float>) #2
1380
1381 declare <2 x i64> @llvm.aarch64.neon.fcvtps.v2i64.v2f64(<2 x double>) #2
1382
1383 declare <4 x i32> @llvm.aarch64.neon.fcvtps.v4i32.v4f32(<4 x float>) #2
1384
1385 declare <2 x i32> @llvm.aarch64.neon.fcvtps.v2i32.v2f32(<2 x float>) #2
1386
1387 declare <2 x i64> @llvm.aarch64.neon.fcvtnu.v2i64.v2f64(<2 x double>) #2
1388
1389 declare <4 x i32> @llvm.aarch64.neon.fcvtnu.v4i32.v4f32(<4 x float>) #2
1390
1391 declare <2 x i32> @llvm.aarch64.neon.fcvtnu.v2i32.v2f32(<2 x float>) #2
1392
1393 declare <2 x i64> @llvm.aarch64.neon.fcvtns.v2i64.v2f64(<2 x double>) #2
1394
1395 declare <4 x i32> @llvm.aarch64.neon.fcvtns.v4i32.v4f32(<4 x float>) #2
1396
1397 declare <2 x i32> @llvm.aarch64.neon.fcvtns.v2i32.v2f32(<2 x float>) #2
1398
1399 declare <2 x double> @llvm.nearbyint.v2f64(<2 x double>) #3
1400
1401 declare <4 x float> @llvm.nearbyint.v4f32(<4 x float>) #3
1402
1403 declare <2 x float> @llvm.nearbyint.v2f32(<2 x float>) #3
1404
1405 declare <2 x double> @llvm.trunc.v2f64(<2 x double>) #3
1406
1407 declare <4 x float> @llvm.trunc.v4f32(<4 x float>) #3
1408
1409 declare <2 x float> @llvm.trunc.v2f32(<2 x float>) #3
1410
1411 declare <2 x double> @llvm.rint.v2f64(<2 x double>) #3
1412
1413 declare <4 x float> @llvm.rint.v4f32(<4 x float>) #3
1414
1415 declare <2 x float> @llvm.rint.v2f32(<2 x float>) #3
1416
1417 declare <2 x double> @llvm.floor.v2f64(<2 x double>) #3
1418
1419 declare <4 x float> @llvm.floor.v4f32(<4 x float>) #3
1420
1421 declare <2 x float> @llvm.floor.v2f32(<2 x float>) #3
1422
1423 declare <2 x double> @llvm.ceil.v2f64(<2 x double>) #3
1424
1425 declare <4 x float> @llvm.ceil.v4f32(<4 x float>) #3
1426
1427 declare <2 x float> @llvm.ceil.v2f32(<2 x float>) #3
1428
1429 declare <2 x double> @llvm.round.v2f64(<2 x double>) #3
1430
1431 declare <4 x float> @llvm.round.v4f32(<4 x float>) #3
1432
1433 declare <2 x float> @llvm.round.v2f32(<2 x float>) #3
1434
1435 declare <2 x double> @llvm.aarch64.neon.frintn.v2f64(<2 x double>) #2
1436
1437 declare <4 x float> @llvm.aarch64.neon.frintn.v4f32(<4 x float>) #2
1438
1439 declare <2 x float> @llvm.aarch64.neon.frintn.v2f32(<2 x float>) #2
1440
1441 declare <2 x float> @llvm.aarch64.neon.fcvtxn.v2f32.v2f64(<2 x double>) #2
1442
1443 declare <2 x float> @llvm.aarch64.neon.fcvtn.v2f32.v2f64(<2 x double>) #2
1444
1445 declare <2 x i32> @llvm.arm.neon.vqmovnu.v2i32(<2 x i64>) #2
1446
1447 declare <4 x i16> @llvm.arm.neon.vqmovnu.v4i16(<4 x i32>) #2
1448
1449 declare <8 x i8> @llvm.arm.neon.vqmovnu.v8i8(<8 x i16>) #2
1450
1451 declare <2 x i32> @llvm.arm.neon.vqmovns.v2i32(<2 x i64>) #2
1452
1453 declare <4 x i16> @llvm.arm.neon.vqmovns.v4i16(<4 x i32>) #2
1454
1455 declare <8 x i8> @llvm.arm.neon.vqmovns.v8i8(<8 x i16>) #2
1456
1457 declare <2 x i32> @llvm.arm.neon.vqmovnsu.v2i32(<2 x i64>) #2
1458
1459 declare <4 x i16> @llvm.arm.neon.vqmovnsu.v4i16(<4 x i32>) #2
1460
1461 declare <8 x i8> @llvm.arm.neon.vqmovnsu.v8i8(<8 x i16>) #2
1462
1463 declare <16 x i8> @llvm.aarch64.neon.rbit.v16i8(<16 x i8>) #2
1464
1465 declare <8 x i8> @llvm.aarch64.neon.rbit.v8i8(<8 x i8>) #2
1466
1467 declare <16 x i8> @llvm.ctpop.v16i8(<16 x i8>) #2
1468
1469 declare <8 x i8> @llvm.ctpop.v8i8(<8 x i8>) #2
1470
1471 declare <4 x i32> @llvm.ctlz.v4i32(<4 x i32>, i1) #2
1472
1473 declare <2 x i32> @llvm.ctlz.v2i32(<2 x i32>, i1) #2
1474
1475 declare <8 x i16> @llvm.ctlz.v8i16(<8 x i16>, i1) #2
1476
1477 declare <4 x i16> @llvm.ctlz.v4i16(<4 x i16>, i1) #2
1478
1479 declare <16 x i8> @llvm.ctlz.v16i8(<16 x i8>, i1) #2
1480
1481 declare <8 x i8> @llvm.ctlz.v8i8(<8 x i8>, i1) #2
1482
1483 declare <4 x i32> @llvm.arm.neon.vcls.v4i32(<4 x i32>) #2
1484
1485 declare <2 x i32> @llvm.arm.neon.vcls.v2i32(<2 x i32>) #2
1486
1487 declare <8 x i16> @llvm.arm.neon.vcls.v8i16(<8 x i16>) #2
1488
1489 declare <4 x i16> @llvm.arm.neon.vcls.v4i16(<4 x i16>) #2
1490
1491 declare <16 x i8> @llvm.arm.neon.vcls.v16i8(<16 x i8>) #2
1492
1493 declare <8 x i8> @llvm.arm.neon.vcls.v8i8(<8 x i8>) #2
1494
1495 declare <2 x i64> @llvm.aarch64.neon.suqadd.v2i64(<2 x i64>, <2 x i64>) #2
1496
1497 declare <4 x i32> @llvm.aarch64.neon.suqadd.v4i32(<4 x i32>, <4 x i32>) #2
1498
1499 declare <2 x i32> @llvm.aarch64.neon.suqadd.v2i32(<2 x i32>, <2 x i32>) #2
1500
1501 declare <8 x i16> @llvm.aarch64.neon.suqadd.v8i16(<8 x i16>, <8 x i16>) #2
1502
1503 declare <4 x i16> @llvm.aarch64.neon.suqadd.v4i16(<4 x i16>, <4 x i16>) #2
1504
1505 declare <16 x i8> @llvm.aarch64.neon.suqadd.v16i8(<16 x i8>, <16 x i8>) #2
1506
1507 declare <8 x i8> @llvm.aarch64.neon.suqadd.v8i8(<8 x i8>, <8 x i8>) #2
1508
1509 declare <2 x double> @llvm.fabs.v2f64(<2 x double>) #3
1510
1511 declare <4 x float> @llvm.fabs.v4f32(<4 x float>) #3
1512
1513 declare <2 x float> @llvm.fabs.v2f32(<2 x float>) #3
1514
1515 declare <2 x i64> @llvm.arm.neon.vabs.v2i64(<2 x i64>) #2
1516
1517 declare <4 x i32> @llvm.arm.neon.vabs.v4i32(<4 x i32>) #2
1518
1519 declare <2 x i32> @llvm.arm.neon.vabs.v2i32(<2 x i32>) #2
1520
1521 declare <8 x i16> @llvm.arm.neon.vabs.v8i16(<8 x i16>) #2
1522
1523 declare <4 x i16> @llvm.arm.neon.vabs.v4i16(<4 x i16>) #2
1524
1525 declare <16 x i8> @llvm.arm.neon.vabs.v16i8(<16 x i8>) #2
1526
1527 declare <8 x i8> @llvm.arm.neon.vabs.v8i8(<8 x i8>) #2
1528
1529 declare <2 x i64> @llvm.arm.neon.vqneg.v2i64(<2 x i64>) #2
1530
1531 declare <4 x i32> @llvm.arm.neon.vqneg.v4i32(<4 x i32>) #2
1532
1533 declare <2 x i32> @llvm.arm.neon.vqneg.v2i32(<2 x i32>) #2
1534
1535 declare <8 x i16> @llvm.arm.neon.vqneg.v8i16(<8 x i16>) #2
1536
1537 declare <4 x i16> @llvm.arm.neon.vqneg.v4i16(<4 x i16>) #2
1538
1539 declare <16 x i8> @llvm.arm.neon.vqneg.v16i8(<16 x i8>) #2
1540
1541 declare <8 x i8> @llvm.arm.neon.vqneg.v8i8(<8 x i8>) #2
1542
1543 declare <2 x i64> @llvm.arm.neon.vqabs.v2i64(<2 x i64>) #2
1544
1545 declare <4 x i32> @llvm.arm.neon.vqabs.v4i32(<4 x i32>) #2
1546
1547 declare <2 x i32> @llvm.arm.neon.vqabs.v2i32(<2 x i32>) #2
1548
1549 declare <8 x i16> @llvm.arm.neon.vqabs.v8i16(<8 x i16>) #2
1550
1551 declare <4 x i16> @llvm.arm.neon.vqabs.v4i16(<4 x i16>) #2
1552
1553 declare <16 x i8> @llvm.arm.neon.vqabs.v16i8(<16 x i8>) #2
1554
1555 declare <8 x i8> @llvm.arm.neon.vqabs.v8i8(<8 x i8>) #2
1556
1557 declare <2 x i64> @llvm.arm.neon.vpadalu.v2i64.v4i32(<2 x i64>, <4 x i32>) #2
1558
1559 declare <4 x i32> @llvm.arm.neon.vpadalu.v4i32.v8i16(<4 x i32>, <8 x i16>) #2
1560
1561 declare <8 x i16> @llvm.arm.neon.vpadalu.v8i16.v16i8(<8 x i16>, <16 x i8>) #2
1562
1563 declare <2 x i64> @llvm.arm.neon.vpadals.v2i64.v4i32(<2 x i64>, <4 x i32>) #2
1564
1565 declare <4 x i32> @llvm.arm.neon.vpadals.v4i32.v8i16(<4 x i32>, <8 x i16>) #2
1566
1567 declare <8 x i16> @llvm.arm.neon.vpadals.v8i16.v16i8(<8 x i16>, <16 x i8>) #2
1568
1569 declare <1 x i64> @llvm.arm.neon.vpadalu.v1i64.v2i32(<1 x i64>, <2 x i32>) #2
1570
1571 declare <2 x i32> @llvm.arm.neon.vpadalu.v2i32.v4i16(<2 x i32>, <4 x i16>) #2
1572
1573 declare <4 x i16> @llvm.arm.neon.vpadalu.v4i16.v8i8(<4 x i16>, <8 x i8>) #2
1574
1575 declare <1 x i64> @llvm.arm.neon.vpadals.v1i64.v2i32(<1 x i64>, <2 x i32>) #2
1576
1577 declare <2 x i32> @llvm.arm.neon.vpadals.v2i32.v4i16(<2 x i32>, <4 x i16>) #2
1578
1579 declare <4 x i16> @llvm.arm.neon.vpadals.v4i16.v8i8(<4 x i16>, <8 x i8>) #2
1580
1581 declare <2 x i64> @llvm.arm.neon.vpaddlu.v2i64.v4i32(<4 x i32>) #2
1582
1583 declare <4 x i32> @llvm.arm.neon.vpaddlu.v4i32.v8i16(<8 x i16>) #2
1584
1585 declare <8 x i16> @llvm.arm.neon.vpaddlu.v8i16.v16i8(<16 x i8>) #2
1586
1587 declare <2 x i64> @llvm.arm.neon.vpaddls.v2i64.v4i32(<4 x i32>) #2
1588
1589 declare <4 x i32> @llvm.arm.neon.vpaddls.v4i32.v8i16(<8 x i16>) #2
1590
1591 declare <8 x i16> @llvm.arm.neon.vpaddls.v8i16.v16i8(<16 x i8>) #2
1592
1593 declare <1 x i64> @llvm.arm.neon.vpaddlu.v1i64.v2i32(<2 x i32>) #2
1594
1595 declare <2 x i32> @llvm.arm.neon.vpaddlu.v2i32.v4i16(<4 x i16>) #2
1596
1597 declare <4 x i16> @llvm.arm.neon.vpaddlu.v4i16.v8i8(<8 x i8>) #2
1598
1599 declare <1 x i64> @llvm.arm.neon.vpaddls.v1i64.v2i32(<2 x i32>) #2
1600
1601 declare <2 x i32> @llvm.arm.neon.vpaddls.v2i32.v4i16(<4 x i16>) #2
1602
1603 declare <4 x i16> @llvm.arm.neon.vpaddls.v4i16.v8i8(<8 x i8>) #2
1604
1605 declare <4 x float> @llvm.arm.neon.vcvthf2fp(<4 x i16>) #2
1606
1607 declare <4 x i16> @llvm.arm.neon.vcvtfp2hf(<4 x float>) #2
1608
1609
1610 define <1 x i64> @test_vcvt_s64_f64(<1 x double> %a) {
1611 ; CHECK-LABEL: test_vcvt_s64_f64
1612 ; CHECK: fcvtzs d{{[0-9]+}}, d{{[0-9]+}}
1613   %1 = fptosi <1 x double> %a to <1 x i64>
1614   ret <1 x i64> %1
1615 }
1616
1617 define <1 x i64> @test_vcvt_u64_f64(<1 x double> %a) {
1618 ; CHECK-LABEL: test_vcvt_u64_f64
1619 ; CHECK: fcvtzu d{{[0-9]+}}, d{{[0-9]+}}
1620   %1 = fptoui <1 x double> %a to <1 x i64>
1621   ret <1 x i64> %1
1622 }
1623
1624 define <1 x i64> @test_vcvtn_s64_f64(<1 x double> %a) {
1625 ; CHECK-LABEL: test_vcvtn_s64_f64
1626 ; CHECK: fcvtns d{{[0-9]+}}, d{{[0-9]+}}
1627   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtns.v1i64.v1f64(<1 x double> %a)
1628   ret <1 x i64> %1
1629 }
1630
1631 define <1 x i64> @test_vcvtn_u64_f64(<1 x double> %a) {
1632 ; CHECK-LABEL: test_vcvtn_u64_f64
1633 ; CHECK: fcvtnu d{{[0-9]+}}, d{{[0-9]+}}
1634   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtnu.v1i64.v1f64(<1 x double> %a)
1635   ret <1 x i64> %1
1636 }
1637
1638 define <1 x i64> @test_vcvtp_s64_f64(<1 x double> %a) {
1639 ; CHECK-LABEL: test_vcvtp_s64_f64
1640 ; CHECK: fcvtps d{{[0-9]+}}, d{{[0-9]+}}
1641   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtps.v1i64.v1f64(<1 x double> %a)
1642   ret <1 x i64> %1
1643 }
1644
1645 define <1 x i64> @test_vcvtp_u64_f64(<1 x double> %a) {
1646 ; CHECK-LABEL: test_vcvtp_u64_f64
1647 ; CHECK: fcvtpu d{{[0-9]+}}, d{{[0-9]+}}
1648   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtpu.v1i64.v1f64(<1 x double> %a)
1649   ret <1 x i64> %1
1650 }
1651
1652 define <1 x i64> @test_vcvtm_s64_f64(<1 x double> %a) {
1653 ; CHECK-LABEL: test_vcvtm_s64_f64
1654 ; CHECK: fcvtms d{{[0-9]+}}, d{{[0-9]+}}
1655   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtms.v1i64.v1f64(<1 x double> %a)
1656   ret <1 x i64> %1
1657 }
1658
1659 define <1 x i64> @test_vcvtm_u64_f64(<1 x double> %a) {
1660 ; CHECK-LABEL: test_vcvtm_u64_f64
1661 ; CHECK: fcvtmu d{{[0-9]+}}, d{{[0-9]+}}
1662   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtmu.v1i64.v1f64(<1 x double> %a)
1663   ret <1 x i64> %1
1664 }
1665
1666 define <1 x i64> @test_vcvta_s64_f64(<1 x double> %a) {
1667 ; CHECK-LABEL: test_vcvta_s64_f64
1668 ; CHECK: fcvtas d{{[0-9]+}}, d{{[0-9]+}}
1669   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtas.v1i64.v1f64(<1 x double> %a)
1670   ret <1 x i64> %1
1671 }
1672
1673 define <1 x i64> @test_vcvta_u64_f64(<1 x double> %a) {
1674 ; CHECK-LABEL: test_vcvta_u64_f64
1675 ; CHECK: fcvtau d{{[0-9]+}}, d{{[0-9]+}}
1676   %1 = tail call <1 x i64> @llvm.aarch64.neon.fcvtau.v1i64.v1f64(<1 x double> %a)
1677   ret <1 x i64> %1
1678 }
1679
1680 define <1 x double> @test_vcvt_f64_s64(<1 x i64> %a) {
1681 ; CHECK-LABEL: test_vcvt_f64_s64
1682 ; CHECK: scvtf d{{[0-9]+}}, d{{[0-9]+}}
1683   %1 = sitofp <1 x i64> %a to <1 x double>
1684   ret <1 x double> %1
1685 }
1686
1687 define <1 x double> @test_vcvt_f64_u64(<1 x i64> %a) {
1688 ; CHECK-LABEL: test_vcvt_f64_u64
1689 ; CHECK: ucvtf d{{[0-9]+}}, d{{[0-9]+}}
1690   %1 = uitofp <1 x i64> %a to <1 x double>
1691   ret <1 x double> %1
1692 }
1693
1694 declare <1 x i64> @llvm.aarch64.neon.fcvtau.v1i64.v1f64(<1 x double>)
1695 declare <1 x i64> @llvm.aarch64.neon.fcvtas.v1i64.v1f64(<1 x double>)
1696 declare <1 x i64> @llvm.aarch64.neon.fcvtmu.v1i64.v1f64(<1 x double>)
1697 declare <1 x i64> @llvm.aarch64.neon.fcvtms.v1i64.v1f64(<1 x double>)
1698 declare <1 x i64> @llvm.aarch64.neon.fcvtpu.v1i64.v1f64(<1 x double>)
1699 declare <1 x i64> @llvm.aarch64.neon.fcvtps.v1i64.v1f64(<1 x double>)
1700 declare <1 x i64> @llvm.aarch64.neon.fcvtnu.v1i64.v1f64(<1 x double>)
1701 declare <1 x i64> @llvm.aarch64.neon.fcvtns.v1i64.v1f64(<1 x double>)
1702
1703 define <1 x double> @test_vrndn_f64(<1 x double> %a) {
1704 ; CHECK-LABEL: test_vrndn_f64
1705 ; CHECK: frintn d{{[0-9]+}}, d{{[0-9]+}}
1706   %1 = tail call <1 x double> @llvm.aarch64.neon.frintn.v1f64(<1 x double> %a)
1707   ret <1 x double> %1
1708 }
1709
1710 define <1 x double> @test_vrnda_f64(<1 x double> %a) {
1711 ; CHECK-LABEL: test_vrnda_f64
1712 ; CHECK: frinta d{{[0-9]+}}, d{{[0-9]+}}
1713   %1 = tail call <1 x double> @llvm.round.v1f64(<1 x double> %a)
1714   ret <1 x double> %1
1715 }
1716
1717 define <1 x double> @test_vrndp_f64(<1 x double> %a) {
1718 ; CHECK-LABEL: test_vrndp_f64
1719 ; CHECK: frintp d{{[0-9]+}}, d{{[0-9]+}}
1720   %1 = tail call <1 x double> @llvm.ceil.v1f64(<1 x double> %a)
1721   ret <1 x double> %1
1722 }
1723
1724 define <1 x double> @test_vrndm_f64(<1 x double> %a) {
1725 ; CHECK-LABEL: test_vrndm_f64
1726 ; CHECK: frintm d{{[0-9]+}}, d{{[0-9]+}}
1727   %1 = tail call <1 x double> @llvm.floor.v1f64(<1 x double> %a)
1728   ret <1 x double> %1
1729 }
1730
1731 define <1 x double> @test_vrndx_f64(<1 x double> %a) {
1732 ; CHECK-LABEL: test_vrndx_f64
1733 ; CHECK: frintx d{{[0-9]+}}, d{{[0-9]+}}
1734   %1 = tail call <1 x double> @llvm.rint.v1f64(<1 x double> %a)
1735   ret <1 x double> %1
1736 }
1737
1738 define <1 x double> @test_vrnd_f64(<1 x double> %a) {
1739 ; CHECK-LABEL: test_vrnd_f64
1740 ; CHECK: frintz d{{[0-9]+}}, d{{[0-9]+}}
1741   %1 = tail call <1 x double> @llvm.trunc.v1f64(<1 x double> %a)
1742   ret <1 x double> %1
1743 }
1744
1745 define <1 x double> @test_vrndi_f64(<1 x double> %a) {
1746 ; CHECK-LABEL: test_vrndi_f64
1747 ; CHECK: frinti d{{[0-9]+}}, d{{[0-9]+}}
1748   %1 = tail call <1 x double> @llvm.nearbyint.v1f64(<1 x double> %a)
1749   ret <1 x double> %1
1750 }
1751
1752 declare <1 x double> @llvm.nearbyint.v1f64(<1 x double>)
1753 declare <1 x double> @llvm.trunc.v1f64(<1 x double>)
1754 declare <1 x double> @llvm.rint.v1f64(<1 x double>)
1755 declare <1 x double> @llvm.floor.v1f64(<1 x double>)
1756 declare <1 x double> @llvm.ceil.v1f64(<1 x double>)
1757 declare <1 x double> @llvm.round.v1f64(<1 x double>)
1758 declare <1 x double> @llvm.aarch64.neon.frintn.v1f64(<1 x double>)
1759
1760 define <1 x double> @test_vrsqrte_f64(<1 x double> %a) {
1761 ; CHECK-LABEL: test_vrsqrte_f64
1762 ; CHECK: frsqrte d{{[0-9]+}}, d{{[0-9]+}}
1763   %1 = tail call <1 x double> @llvm.arm.neon.vrsqrte.v1f64(<1 x double> %a)
1764   ret <1 x double> %1
1765 }
1766
1767 define <1 x double> @test_vrecpe_f64(<1 x double> %a) {
1768 ; CHECK-LABEL: test_vrecpe_f64
1769 ; CHECK: frecpe d{{[0-9]+}}, d{{[0-9]+}}
1770   %1 = tail call <1 x double> @llvm.arm.neon.vrecpe.v1f64(<1 x double> %a)
1771   ret <1 x double> %1
1772 }
1773
1774 define <1 x double> @test_vsqrt_f64(<1 x double> %a) {
1775 ; CHECK-LABEL: test_vsqrt_f64
1776 ; CHECK: fsqrt d{{[0-9]+}}, d{{[0-9]+}}
1777   %1 = tail call <1 x double> @llvm.sqrt.v1f64(<1 x double> %a)
1778   ret <1 x double> %1
1779 }
1780
1781 define <1 x double> @test_vrecps_f64(<1 x double> %a, <1 x double> %b) {
1782 ; CHECK-LABEL: test_vrecps_f64
1783 ; CHECK: frecps d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1784   %1 = tail call <1 x double> @llvm.arm.neon.vrecps.v1f64(<1 x double> %a, <1 x double> %b)
1785   ret <1 x double> %1
1786 }
1787
1788 define <1 x double> @test_vrsqrts_f64(<1 x double> %a, <1 x double> %b) {
1789 ; CHECK-LABEL: test_vrsqrts_f64
1790 ; CHECK: frsqrts d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}
1791   %1 = tail call <1 x double> @llvm.arm.neon.vrsqrts.v1f64(<1 x double> %a, <1 x double> %b)
1792   ret <1 x double> %1
1793 }
1794
1795 declare <1 x double> @llvm.arm.neon.vrsqrts.v1f64(<1 x double>, <1 x double>)
1796 declare <1 x double> @llvm.arm.neon.vrecps.v1f64(<1 x double>, <1 x double>)
1797 declare <1 x double> @llvm.sqrt.v1f64(<1 x double>)
1798 declare <1 x double> @llvm.arm.neon.vrecpe.v1f64(<1 x double>)
1799 declare <1 x double> @llvm.arm.neon.vrsqrte.v1f64(<1 x double>)