lib/Target/ARM/ARMInstrNEON.td

   1 //===- ARMInstrNEON.td - NEON support for ARM -----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the ARM NEON instruction set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // NEON-specific DAG Nodes.
  16 //===----------------------------------------------------------------------===//
  17
  18 def SDTARMVCMP    : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisSameAs<1, 2>]>;
  19
  20 def NEONvceq      : SDNode<"ARMISD::VCEQ", SDTARMVCMP>;
  21 def NEONvcge      : SDNode<"ARMISD::VCGE", SDTARMVCMP>;
  22 def NEONvcgeu     : SDNode<"ARMISD::VCGEU", SDTARMVCMP>;
  23 def NEONvcgt      : SDNode<"ARMISD::VCGT", SDTARMVCMP>;
  24 def NEONvcgtu     : SDNode<"ARMISD::VCGTU", SDTARMVCMP>;
  25 def NEONvtst      : SDNode<"ARMISD::VTST", SDTARMVCMP>;
  26
  27 // Types for vector shift by immediates.  The "SHX" version is for long and
  28 // narrow operations where the source and destination vectors have different
  29 // types.  The "SHINS" version is for shift and insert operations.
  30 def SDTARMVSH     : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisSameAs<0, 1>,
  31                                          SDTCisVT<2, i32>]>;
  32 def SDTARMVSHX    : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisInt<1>,
  33                                          SDTCisVT<2, i32>]>;
  34 def SDTARMVSHINS  : SDTypeProfile<1, 3, [SDTCisInt<0>, SDTCisSameAs<0, 1>,
  35                                          SDTCisSameAs<0, 2>, SDTCisVT<3, i32>]>;
  36
  37 def NEONvshl      : SDNode<"ARMISD::VSHL", SDTARMVSH>;
  38 def NEONvshrs     : SDNode<"ARMISD::VSHRs", SDTARMVSH>;
  39 def NEONvshru     : SDNode<"ARMISD::VSHRu", SDTARMVSH>;
  40 def NEONvshlls    : SDNode<"ARMISD::VSHLLs", SDTARMVSHX>;
  41 def NEONvshllu    : SDNode<"ARMISD::VSHLLu", SDTARMVSHX>;
  42 def NEONvshlli    : SDNode<"ARMISD::VSHLLi", SDTARMVSHX>;
  43 def NEONvshrn     : SDNode<"ARMISD::VSHRN", SDTARMVSHX>;
  44
  45 def NEONvrshrs    : SDNode<"ARMISD::VRSHRs", SDTARMVSH>;
  46 def NEONvrshru    : SDNode<"ARMISD::VRSHRu", SDTARMVSH>;
  47 def NEONvrshrn    : SDNode<"ARMISD::VRSHRN", SDTARMVSHX>;
  48
  49 def NEONvqshls    : SDNode<"ARMISD::VQSHLs", SDTARMVSH>;
  50 def NEONvqshlu    : SDNode<"ARMISD::VQSHLu", SDTARMVSH>;
  51 def NEONvqshlsu   : SDNode<"ARMISD::VQSHLsu", SDTARMVSH>;
  52 def NEONvqshrns   : SDNode<"ARMISD::VQSHRNs", SDTARMVSHX>;
  53 def NEONvqshrnu   : SDNode<"ARMISD::VQSHRNu", SDTARMVSHX>;
  54 def NEONvqshrnsu  : SDNode<"ARMISD::VQSHRNsu", SDTARMVSHX>;
  55
  56 def NEONvqrshrns  : SDNode<"ARMISD::VQRSHRNs", SDTARMVSHX>;
  57 def NEONvqrshrnu  : SDNode<"ARMISD::VQRSHRNu", SDTARMVSHX>;
  58 def NEONvqrshrnsu : SDNode<"ARMISD::VQRSHRNsu", SDTARMVSHX>;
  59
  60 def NEONvsli      : SDNode<"ARMISD::VSLI", SDTARMVSHINS>;
  61 def NEONvsri      : SDNode<"ARMISD::VSRI", SDTARMVSHINS>;
  62
  63 def SDTARMVGETLN  : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisInt<1>,
  64                                          SDTCisVT<2, i32>]>;
  65 def NEONvgetlaneu : SDNode<"ARMISD::VGETLANEu", SDTARMVGETLN>;
  66 def NEONvgetlanes : SDNode<"ARMISD::VGETLANEs", SDTARMVGETLN>;
  67
  68 def NEONvdup      : SDNode<"ARMISD::VDUP", SDTypeProfile<1, 1, [SDTCisVec<0>]>>;
  69
  70 // VDUPLANE can produce a quad-register result from a double-register source,
  71 // so the result is not constrained to match the source.
  72 def NEONvduplane  : SDNode<"ARMISD::VDUPLANE",
  73                            SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>,
  74                                                 SDTCisVT<2, i32>]>>;
  75
  76 def SDTARMVEXT    : SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0, 1>,
  77                                          SDTCisSameAs<0, 2>, SDTCisVT<3, i32>]>;
  78 def NEONvext      : SDNode<"ARMISD::VEXT", SDTARMVEXT>;
  79
  80 def SDTARMVSHUF   : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisSameAs<0, 1>]>;
  81 def NEONvrev64    : SDNode<"ARMISD::VREV64", SDTARMVSHUF>;
  82 def NEONvrev32    : SDNode<"ARMISD::VREV32", SDTARMVSHUF>;
  83 def NEONvrev16    : SDNode<"ARMISD::VREV16", SDTARMVSHUF>;
  84
  85 def SDTARMVSHUF2  : SDTypeProfile<2, 2, [SDTCisVec<0>, SDTCisSameAs<0, 1>,
  86                                          SDTCisSameAs<0, 2>,
  87                                          SDTCisSameAs<0, 3>]>;
  88 def NEONzip       : SDNode<"ARMISD::VZIP", SDTARMVSHUF2>;
  89 def NEONuzp       : SDNode<"ARMISD::VUZP", SDTARMVSHUF2>;
  90 def NEONtrn       : SDNode<"ARMISD::VTRN", SDTARMVSHUF2>;
  91
  92 def SDTARMFMAX    : SDTypeProfile<1, 2, [SDTCisVT<0, f32>, SDTCisSameAs<0, 1>,
  93                                          SDTCisSameAs<0, 2>]>;
  94 def NEONfmax      : SDNode<"ARMISD::FMAX", SDTARMFMAX>;
  95 def NEONfmin      : SDNode<"ARMISD::FMIN", SDTARMFMAX>;
  96
  97 //===----------------------------------------------------------------------===//
  98 // NEON operand definitions
  99 //===----------------------------------------------------------------------===//
 100
 101 def h8imm  : Operand<i8> {
 102   let PrintMethod = "printHex8ImmOperand";
 103 }
 104 def h16imm : Operand<i16> {
 105   let PrintMethod = "printHex16ImmOperand";
 106 }
 107 def h32imm : Operand<i32> {
 108   let PrintMethod = "printHex32ImmOperand";
 109 }
 110 def h64imm : Operand<i64> {
 111   let PrintMethod = "printHex64ImmOperand";
 112 }
 113
 114 //===----------------------------------------------------------------------===//
 115 // NEON load / store instructions
 116 //===----------------------------------------------------------------------===//
 117
 118 // Use vldmia to load a Q register as a D register pair.
 119 def VLDRQ : NI4<(outs QPR:$dst), (ins addrmode4:$addr), IIC_fpLoadm,
 120                 "vldmia", "$addr, ${dst:dregpair}",
 121                 [(set QPR:$dst, (v2f64 (load addrmode4:$addr)))]> {
 122   let Inst{27-25} = 0b110;
 123   let Inst{24}    = 0; // P bit
 124   let Inst{23}    = 1; // U bit
 125   let Inst{20}    = 1;
 126   let Inst{11-8}  = 0b1011;
 127 }
 128
 129 // Use vstmia to store a Q register as a D register pair.
 130 def VSTRQ : NI4<(outs), (ins QPR:$src, addrmode4:$addr), IIC_fpStorem,
 131                 "vstmia", "$addr, ${src:dregpair}",
 132                 [(store (v2f64 QPR:$src), addrmode4:$addr)]> {
 133   let Inst{27-25} = 0b110;
 134   let Inst{24}    = 0; // P bit
 135   let Inst{23}    = 1; // U bit
 136   let Inst{20}    = 0;
 137   let Inst{11-8}  = 0b1011;
 138 }
 139
 140 //   VLD1     : Vector Load (multiple single elements)
 141 class VLD1D<bits<4> op7_4, string Dt, ValueType Ty>
 142   : NLdSt<0,0b10,0b0111,op7_4, (outs DPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
 143           "vld1", Dt, "\\{$dst\\}, $addr", "",
 144           [(set DPR:$dst, (Ty (int_arm_neon_vld1 addrmode6:$addr)))]>;
 145 class VLD1Q<bits<4> op7_4, string Dt, ValueType Ty>
 146   : NLdSt<0,0b10,0b1010,op7_4, (outs QPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
 147           "vld1", Dt, "${dst:dregpair}, $addr", "",
 148           [(set QPR:$dst, (Ty (int_arm_neon_vld1 addrmode6:$addr)))]>;
 149
 150 def  VLD1d8   : VLD1D<0b0000, "8",  v8i8>;
 151 def  VLD1d16  : VLD1D<0b0100, "16", v4i16>;
 152 def  VLD1d32  : VLD1D<0b1000, "32", v2i32>;
 153 def  VLD1df   : VLD1D<0b1000, "32", v2f32>;
 154 def  VLD1d64  : VLD1D<0b1100, "64", v1i64>;
 155
 156 def  VLD1q8   : VLD1Q<0b0000, "8",  v16i8>;
 157 def  VLD1q16  : VLD1Q<0b0100, "16", v8i16>;
 158 def  VLD1q32  : VLD1Q<0b1000, "32", v4i32>;
 159 def  VLD1qf   : VLD1Q<0b1000, "32", v4f32>;
 160 def  VLD1q64  : VLD1Q<0b1100, "64", v2i64>;
 161
 162 let mayLoad = 1 in {
 163
 164 // ...with address register writeback:
 165 class VLD1DWB<bits<4> op7_4, string Dt>
 166   : NLdSt<0,0b10,0b0111,op7_4, (outs DPR:$dst, GPR:$wb),
 167           (ins addrmode6:$addr), IIC_VLD1,
 168           "vld1", Dt, "\\{$dst\\}, $addr",
 169           "$addr.addr = $wb", []>;
 170 class VLD1QWB<bits<4> op7_4, string Dt>
 171   : NLdSt<0,0b10,0b1010,op7_4, (outs QPR:$dst, GPR:$wb),
 172           (ins addrmode6:$addr), IIC_VLD1,
 173           "vld1", Dt, "${dst:dregpair}, $addr",
 174           "$addr.addr = $wb", []>;
 175
 176 def VLD1d8_UPD  : VLD1DWB<0b0000, "8">;
 177 def VLD1d16_UPD : VLD1DWB<0b0100, "16">;
 178 def VLD1d32_UPD : VLD1DWB<0b1000, "32">;
 179 def VLD1d64_UPD : VLD1DWB<0b1100, "64">;
 180
 181 def VLD1q8_UPD  : VLD1QWB<0b0000, "8">;
 182 def VLD1q16_UPD : VLD1QWB<0b0100, "16">;
 183 def VLD1q32_UPD : VLD1QWB<0b1000, "32">;
 184 def VLD1q64_UPD : VLD1QWB<0b1100, "64">;
 185 } // mayLoad = 1
 186
 187 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
 188
 189 // These (dreg triple/quadruple) are for disassembly only.
 190 class VLD1D3<bits<4> op7_4, string Dt>
 191   : NLdSt<0,0b10,0b0110,op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
 192           (ins addrmode6:$addr), IIC_VLD1, "vld1", Dt,
 193           "\\{$dst1, $dst2, $dst3\\}, $addr", "",
 194           [/* For disassembly only; pattern left blank */]>;
 195 class VLD1D4<bits<4> op7_4, string Dt>
 196   : NLdSt<0,0b10,0b0010,op7_4,(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
 197           (ins addrmode6:$addr), IIC_VLD1, "vld1", Dt,
 198           "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr", "",
 199           [/* For disassembly only; pattern left blank */]>;
 200
 201 def  VLD1d8T  : VLD1D3<0b0000, "8">;
 202 def  VLD1d16T : VLD1D3<0b0100, "16">;
 203 def  VLD1d32T : VLD1D3<0b1000, "32">;
 204 //   VLD1d64T : implemented as VLD3d64
 205
 206 def  VLD1d8Q  : VLD1D4<0b0000, "8">;
 207 def  VLD1d16Q : VLD1D4<0b0100, "16">;
 208 def  VLD1d32Q : VLD1D4<0b1000, "32">;
 209 //   VLD1d64Q : implemented as VLD4d64
 210
 211 // ...with address register writeback:
 212 class VLD1D3WB<bits<4> op7_4, string Dt>
 213   : NLdSt<0,0b10,0b0110,op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
 214           (ins addrmode6:$addr), IIC_VLD1, "vld1", Dt,
 215           "\\{$dst1, $dst2, $dst3\\}, $addr", "$addr.addr = $wb",
 216           [/* For disassembly only; pattern left blank */]>;
 217 class VLD1D4WB<bits<4> op7_4, string Dt>
 218   : NLdSt<0,0b10,0b0010,op7_4,
 219           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4, GPR:$wb),
 220           (ins addrmode6:$addr), IIC_VLD1, "vld1", Dt,
 221           "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr", "$addr.addr = $wb",
 222           [/* For disassembly only; pattern left blank */]>;
 223
 224 def VLD1d8T_UPD  : VLD1D3WB<0b0000, "8">;
 225 def VLD1d16T_UPD : VLD1D3WB<0b0100, "16">;
 226 def VLD1d32T_UPD : VLD1D3WB<0b1000, "32">;
 227 //  VLD1d64T_UPD : implemented as VLD3d64_UPD
 228
 229 def VLD1d8Q_UPD  : VLD1D4WB<0b0000, "8">;
 230 def VLD1d16Q_UPD : VLD1D4WB<0b0100, "16">;
 231 def VLD1d32Q_UPD : VLD1D4WB<0b1000, "32">;
 232 //  VLD1d64Q_UPD : implemented as VLD4d64_UPD
 233
 234 //   VLD2     : Vector Load (multiple 2-element structures)
 235 class VLD2D<bits<4> op11_8, bits<4> op7_4, string Dt>
 236   : NLdSt<0, 0b10, op11_8, op7_4, (outs DPR:$dst1, DPR:$dst2),
 237           (ins addrmode6:$addr), IIC_VLD2,
 238           "vld2", Dt, "\\{$dst1, $dst2\\}, $addr", "", []>;
 239 class VLD2Q<bits<4> op7_4, string Dt>
 240   : NLdSt<0, 0b10, 0b0011, op7_4,
 241           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
 242           (ins addrmode6:$addr), IIC_VLD2,
 243           "vld2", Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr", "", []>;
 244
 245 def  VLD2d8   : VLD2D<0b1000, 0b0000, "8">;
 246 def  VLD2d16  : VLD2D<0b1000, 0b0100, "16">;
 247 def  VLD2d32  : VLD2D<0b1000, 0b1000, "32">;
 248 def  VLD2d64  : NLdSt<0,0b10,0b1010,0b1100, (outs DPR:$dst1, DPR:$dst2),
 249                       (ins addrmode6:$addr), IIC_VLD1,
 250                       "vld1", "64", "\\{$dst1, $dst2\\}, $addr", "", []>;
 251
 252 def  VLD2q8   : VLD2Q<0b0000, "8">;
 253 def  VLD2q16  : VLD2Q<0b0100, "16">;
 254 def  VLD2q32  : VLD2Q<0b1000, "32">;
 255
 256 // ...with address register writeback:
 257 class VLD2DWB<bits<4> op11_8, bits<4> op7_4, string Dt>
 258   : NLdSt<0, 0b10, op11_8, op7_4, (outs DPR:$dst1, DPR:$dst2, GPR:$wb),
 259           (ins addrmode6:$addr), IIC_VLD2,
 260           "vld2", Dt, "\\{$dst1, $dst2\\}, $addr",
 261           "$addr.addr = $wb", []>;
 262 class VLD2QWB<bits<4> op7_4, string Dt>
 263   : NLdSt<0, 0b10, 0b0011, op7_4,
 264           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4, GPR:$wb),
 265           (ins addrmode6:$addr), IIC_VLD2,
 266           "vld2", Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
 267           "$addr.addr = $wb", []>;
 268
 269 def VLD2d8_UPD  : VLD2DWB<0b1000, 0b0000, "8">;
 270 def VLD2d16_UPD : VLD2DWB<0b1000, 0b0100, "16">;
 271 def VLD2d32_UPD : VLD2DWB<0b1000, 0b1000, "32">;
 272 def VLD2d64_UPD : NLdSt<0,0b10,0b1010,0b1100,
 273                         (outs DPR:$dst1, DPR:$dst2, GPR:$wb),
 274                         (ins addrmode6:$addr), IIC_VLD1,
 275                         "vld1", "64", "\\{$dst1, $dst2\\}, $addr",
 276                         "$addr.addr = $wb", []>;
 277
 278 def VLD2q8_UPD  : VLD2QWB<0b0000, "8">;
 279 def VLD2q16_UPD : VLD2QWB<0b0100, "16">;
 280 def VLD2q32_UPD : VLD2QWB<0b1000, "32">;
 281
 282 // ...with double-spaced registers (for disassembly only):
 283 def VLD2b8      : VLD2D<0b1001, 0b0000, "8">;
 284 def VLD2b16     : VLD2D<0b1001, 0b0100, "16">;
 285 def VLD2b32     : VLD2D<0b1001, 0b1000, "32">;
 286 def VLD2b8_UPD  : VLD2DWB<0b1001, 0b0000, "8">;
 287 def VLD2b16_UPD : VLD2DWB<0b1001, 0b0100, "16">;
 288 def VLD2b32_UPD : VLD2DWB<0b1001, 0b1000, "32">;
 289
 290 //   VLD3     : Vector Load (multiple 3-element structures)
 291 class VLD3D<bits<4> op11_8, bits<4> op7_4, string Dt>
 292   : NLdSt<0, 0b10, op11_8, op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
 293           (ins addrmode6:$addr), IIC_VLD3,
 294           "vld3", Dt, "\\{$dst1, $dst2, $dst3\\}, $addr", "", []>;
 295
 296 def  VLD3d8   : VLD3D<0b0100, 0b0000, "8">;
 297 def  VLD3d16  : VLD3D<0b0100, 0b0100, "16">;
 298 def  VLD3d32  : VLD3D<0b0100, 0b1000, "32">;
 299 def  VLD3d64  : NLdSt<0,0b10,0b0110,0b1100,
 300                       (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
 301                       (ins addrmode6:$addr), IIC_VLD1,
 302                       "vld1", "64", "\\{$dst1, $dst2, $dst3\\}, $addr", "", []>;
 303
 304 // ...with address register writeback:
 305 class VLD3DWB<bits<4> op11_8, bits<4> op7_4, string Dt>
 306   : NLdSt<0, 0b10, op11_8, op7_4,
 307           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
 308           (ins addrmode6:$addr), IIC_VLD3,
 309           "vld3", Dt, "\\{$dst1, $dst2, $dst3\\}, $addr",
 310           "$addr.addr = $wb", []>;
 311
 312 def VLD3d8_UPD  : VLD3DWB<0b0100, 0b0000, "8">;
 313 def VLD3d16_UPD : VLD3DWB<0b0100, 0b0100, "16">;
 314 def VLD3d32_UPD : VLD3DWB<0b0100, 0b1000, "32">;
 315 def VLD3d64_UPD : NLdSt<0,0b10,0b0110,0b1100,
 316                         (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
 317                         (ins addrmode6:$addr), IIC_VLD1,
 318                         "vld1", "64", "\\{$dst1, $dst2, $dst3\\}, $addr",
 319                         "$addr.addr = $wb", []>;
 320
 321 // ...with double-spaced registers (non-updating versions for disassembly only):
 322 def VLD3q8      : VLD3D<0b0101, 0b0000, "8">;
 323 def VLD3q16     : VLD3D<0b0101, 0b0100, "16">;
 324 def VLD3q32     : VLD3D<0b0101, 0b1000, "32">;
 325 def VLD3q8_UPD  : VLD3DWB<0b0101, 0b0000, "8">;
 326 def VLD3q16_UPD : VLD3DWB<0b0101, 0b0100, "16">;
 327 def VLD3q32_UPD : VLD3DWB<0b0101, 0b1000, "32">;
 328
 329 // ...alternate versions to be allocated odd register numbers:
 330 def VLD3q8odd_UPD  : VLD3DWB<0b0101, 0b0000, "8">;
 331 def VLD3q16odd_UPD : VLD3DWB<0b0101, 0b0100, "16">;
 332 def VLD3q32odd_UPD : VLD3DWB<0b0101, 0b1000, "32">;
 333
 334 //   VLD4     : Vector Load (multiple 4-element structures)
 335 class VLD4D<bits<4> op11_8, bits<4> op7_4, string Dt>
 336   : NLdSt<0, 0b10, op11_8, op7_4,
 337           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
 338           (ins addrmode6:$addr), IIC_VLD4,
 339           "vld4", Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr", "", []>;
 340
 341 def  VLD4d8   : VLD4D<0b0000, 0b0000, "8">;
 342 def  VLD4d16  : VLD4D<0b0000, 0b0100, "16">;
 343 def  VLD4d32  : VLD4D<0b0000, 0b1000, "32">;
 344 def  VLD4d64  : NLdSt<0,0b10,0b0010,0b1100,
 345                       (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
 346                       (ins addrmode6:$addr), IIC_VLD1,
 347                       "vld1", "64", "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
 348                       "", []>;
 349
 350 // ...with address register writeback:
 351 class VLD4DWB<bits<4> op11_8, bits<4> op7_4, string Dt>
 352   : NLdSt<0, 0b10, op11_8, op7_4,
 353           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4, GPR:$wb),
 354           (ins addrmode6:$addr), IIC_VLD4,
 355           "vld4", Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
 356           "$addr.addr = $wb", []>;
 357
 358 def VLD4d8_UPD  : VLD4DWB<0b0000, 0b0000, "8">;
 359 def VLD4d16_UPD : VLD4DWB<0b0000, 0b0100, "16">;
 360 def VLD4d32_UPD : VLD4DWB<0b0000, 0b1000, "32">;
 361 def VLD4d64_UPD : NLdSt<0,0b10,0b0010,0b1100,
 362                         (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4,
 363                          GPR:$wb),
 364                         (ins addrmode6:$addr), IIC_VLD1,
 365                         "vld1", "64",
 366                         "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
 367                         "$addr.addr = $wb", []>;
 368
 369 // ...with double-spaced registers (non-updating versions for disassembly only):
 370 def VLD4q8      : VLD4D<0b0001, 0b0000, "8">;
 371 def VLD4q16     : VLD4D<0b0001, 0b0100, "16">;
 372 def VLD4q32     : VLD4D<0b0001, 0b1000, "32">;
 373 def VLD4q8_UPD  : VLD4DWB<0b0001, 0b0000, "8">;
 374 def VLD4q16_UPD : VLD4DWB<0b0001, 0b0100, "16">;
 375 def VLD4q32_UPD : VLD4DWB<0b0001, 0b1000, "32">;
 376
 377 // ...alternate versions to be allocated odd register numbers:
 378 def VLD4q8odd_UPD  : VLD4DWB<0b0001, 0b0000, "8">;
 379 def VLD4q16odd_UPD : VLD4DWB<0b0001, 0b0100, "16">;
 380 def VLD4q32odd_UPD : VLD4DWB<0b0001, 0b1000, "32">;
 381
 382 //   VLD1LN   : Vector Load (single element to one lane)
 383 //   FIXME: Not yet implemented.
 384
 385 //   VLD2LN   : Vector Load (single 2-element structure to one lane)
 386 class VLD2LN<bits<4> op11_8, string Dt>
 387   : NLdSt<1, 0b10, op11_8, {?,?,?,?}, (outs DPR:$dst1, DPR:$dst2),
 388           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
 389           IIC_VLD2, "vld2", Dt, "\\{$dst1[$lane], $dst2[$lane]\\}, $addr",
 390           "$src1 = $dst1, $src2 = $dst2", []>;
 391
 392 def VLD2LNd8  : VLD2LN<0b0001, "8">;
 393 def VLD2LNd16 : VLD2LN<0b0101, "16"> { let Inst{5} = 0; }
 394 def VLD2LNd32 : VLD2LN<0b1001, "32"> { let Inst{6} = 0; }
 395
 396 // ...with double-spaced registers:
 397 def VLD2LNq16 : VLD2LN<0b0101, "16"> { let Inst{5} = 1; }
 398 def VLD2LNq32 : VLD2LN<0b1001, "32"> { let Inst{6} = 1; }
 399
 400 // ...alternate versions to be allocated odd register numbers:
 401 def VLD2LNq16odd : VLD2LN<0b0101, "16"> { let Inst{5} = 1; }
 402 def VLD2LNq32odd : VLD2LN<0b1001, "32"> { let Inst{6} = 1; }
 403
 404 // ...with address register writeback:
 405 class VLD2LNWB<bits<4> op11_8, string Dt>
 406   : NLdSt<1, 0b10, op11_8, {?,?,?,?}, (outs DPR:$dst1, DPR:$dst2, GPR:$wb),
 407           (ins addrmode6:$addr,
 408            DPR:$src1, DPR:$src2, nohash_imm:$lane), IIC_VLD2, "vld2", Dt,
 409           "\\{$dst1[$lane], $dst2[$lane]\\}, $addr",
 410           "$src1 = $dst1, $src2 = $dst2, $addr.addr = $wb", []>;
 411
 412 def VLD2LNd8_UPD  : VLD2LNWB<0b0001, "8">;
 413 def VLD2LNd16_UPD : VLD2LNWB<0b0101, "16"> { let Inst{5} = 0; }
 414 def VLD2LNd32_UPD : VLD2LNWB<0b1001, "32"> { let Inst{6} = 0; }
 415
 416 def VLD2LNq16_UPD : VLD2LNWB<0b0101, "16"> { let Inst{5} = 1; }
 417 def VLD2LNq32_UPD : VLD2LNWB<0b1001, "32"> { let Inst{6} = 1; }
 418
 419 //   VLD3LN   : Vector Load (single 3-element structure to one lane)
 420 class VLD3LN<bits<4> op11_8, string Dt>
 421   : NLdSt<1, 0b10, op11_8, {?,?,?,?}, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
 422           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
 423           nohash_imm:$lane), IIC_VLD3, "vld3", Dt,
 424           "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane]\\}, $addr",
 425           "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3", []>;
 426
 427 def VLD3LNd8  : VLD3LN<0b0010, "8"> { let Inst{4} = 0; }
 428 def VLD3LNd16 : VLD3LN<0b0110, "16"> { let Inst{5-4} = 0b00; }
 429 def VLD3LNd32 : VLD3LN<0b1010, "32"> { let Inst{6-4} = 0b000; }
 430
 431 // ...with double-spaced registers:
 432 def VLD3LNq16 : VLD3LN<0b0110, "16"> { let Inst{5-4} = 0b10; }
 433 def VLD3LNq32 : VLD3LN<0b1010, "32"> { let Inst{6-4} = 0b100; }
 434
 435 // ...alternate versions to be allocated odd register numbers:
 436 def VLD3LNq16odd : VLD3LN<0b0110, "16"> { let Inst{5-4} = 0b10; }
 437 def VLD3LNq32odd : VLD3LN<0b1010, "32"> { let Inst{6-4} = 0b100; }
 438
 439 // ...with address register writeback:
 440 class VLD3LNWB<bits<4> op11_8, string Dt>
 441   : NLdSt<1, 0b10, op11_8, {?,?,?,?},
 442           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
 443           (ins addrmode6:$addr,
 444            DPR:$src1, DPR:$src2, DPR:$src3, nohash_imm:$lane),
 445           IIC_VLD3, "vld3", Dt,
 446           "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane]\\}, $addr",
 447           "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3, $addr.addr = $wb",
 448           []>;
 449
 450 def VLD3LNd8_UPD  : VLD3LNWB<0b0010, "8"> { let Inst{4} = 0; }
 451 def VLD3LNd16_UPD : VLD3LNWB<0b0110, "16"> { let Inst{5-4} = 0b00; }
 452 def VLD3LNd32_UPD : VLD3LNWB<0b1010, "32"> { let Inst{6-4} = 0b000; }
 453
 454 def VLD3LNq16_UPD : VLD3LNWB<0b0110, "16"> { let Inst{5-4} = 0b10; }
 455 def VLD3LNq32_UPD : VLD3LNWB<0b1010, "32"> { let Inst{6-4} = 0b100; }
 456
 457 //   VLD4LN   : Vector Load (single 4-element structure to one lane)
 458 class VLD4LN<bits<4> op11_8, string Dt>
 459   : NLdSt<1, 0b10, op11_8, {?,?,?,?},
 460           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
 461           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4,
 462           nohash_imm:$lane), IIC_VLD4, "vld4", Dt,
 463           "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane], $dst4[$lane]\\}, $addr",
 464           "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3, $src4 = $dst4", []>;
 465
 466 def VLD4LNd8  : VLD4LN<0b0011, "8">;
 467 def VLD4LNd16 : VLD4LN<0b0111, "16"> { let Inst{5} = 0; }
 468 def VLD4LNd32 : VLD4LN<0b1011, "32"> { let Inst{6} = 0; }
 469
 470 // ...with double-spaced registers:
 471 def VLD4LNq16 : VLD4LN<0b0111, "16"> { let Inst{5} = 1; }
 472 def VLD4LNq32 : VLD4LN<0b1011, "32"> { let Inst{6} = 1; }
 473
 474 // ...alternate versions to be allocated odd register numbers:
 475 def VLD4LNq16odd : VLD4LN<0b0111, "16"> { let Inst{5} = 1; }
 476 def VLD4LNq32odd : VLD4LN<0b1011, "32"> { let Inst{6} = 1; }
 477
 478 // ...with address register writeback:
 479 class VLD4LNWB<bits<4> op11_8, string Dt>
 480   : NLdSt<1, 0b10, op11_8, {?,?,?,?},
 481           (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4, GPR:$wb),
 482           (ins addrmode6:$addr,
 483            DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4, nohash_imm:$lane),
 484           IIC_VLD4, "vld4", Dt,
 485 "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane], $dst4[$lane]\\}, $addr",
 486 "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3, $src4 = $dst4, $addr.addr = $wb",
 487           []>;
 488
 489 def VLD4LNd8_UPD  : VLD4LNWB<0b0011, "8">;
 490 def VLD4LNd16_UPD : VLD4LNWB<0b0111, "16"> { let Inst{5} = 0; }
 491 def VLD4LNd32_UPD : VLD4LNWB<0b1011, "32"> { let Inst{6} = 0; }
 492
 493 def VLD4LNq16_UPD : VLD4LNWB<0b0111, "16"> { let Inst{5} = 1; }
 494 def VLD4LNq32_UPD : VLD4LNWB<0b1011, "32"> { let Inst{6} = 1; }
 495
 496 //   VLD1DUP  : Vector Load (single element to all lanes)
 497 //   VLD2DUP  : Vector Load (single 2-element structure to all lanes)
 498 //   VLD3DUP  : Vector Load (single 3-element structure to all lanes)
 499 //   VLD4DUP  : Vector Load (single 4-element structure to all lanes)
 500 //   FIXME: Not yet implemented.
 501 } // mayLoad = 1, hasExtraDefRegAllocReq = 1
 502
 503 //   VST1     : Vector Store (multiple single elements)
 504 class VST1D<bits<4> op7_4, string Dt, ValueType Ty>
 505   : NLdSt<0,0b00,0b0111,op7_4, (outs), (ins addrmode6:$addr, DPR:$src), IIC_VST,
 506           "vst1", Dt, "\\{$src\\}, $addr", "",
 507           [(int_arm_neon_vst1 addrmode6:$addr, (Ty DPR:$src))]>;
 508 class VST1Q<bits<4> op7_4, string Dt, ValueType Ty>
 509   : NLdSt<0,0b00,0b1010,op7_4, (outs), (ins addrmode6:$addr, QPR:$src), IIC_VST,
 510           "vst1", Dt, "${src:dregpair}, $addr", "",
 511           [(int_arm_neon_vst1 addrmode6:$addr, (Ty QPR:$src))]>;
 512
 513 let hasExtraSrcRegAllocReq = 1 in {
 514 def  VST1d8   : VST1D<0b0000, "8",  v8i8>;
 515 def  VST1d16  : VST1D<0b0100, "16", v4i16>;
 516 def  VST1d32  : VST1D<0b1000, "32", v2i32>;
 517 def  VST1df   : VST1D<0b1000, "32", v2f32>;
 518 def  VST1d64  : VST1D<0b1100, "64", v1i64>;
 519
 520 def  VST1q8   : VST1Q<0b0000, "8",  v16i8>;
 521 def  VST1q16  : VST1Q<0b0100, "16", v8i16>;
 522 def  VST1q32  : VST1Q<0b1000, "32", v4i32>;
 523 def  VST1qf   : VST1Q<0b1000, "32", v4f32>;
 524 def  VST1q64  : VST1Q<0b1100, "64", v2i64>;
 525 } // hasExtraSrcRegAllocReq
 526
 527 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
 528
 529 // ...with address register writeback:
 530 class VST1DWB<bits<4> op7_4, string Dt>
 531   : NLdSt<0, 0b00, 0b0111, op7_4, (outs GPR:$wb),
 532           (ins addrmode6:$addr, DPR:$src), IIC_VST,
 533           "vst1", Dt, "\\{$src\\}, $addr", "$addr.addr = $wb", []>;
 534 class VST1QWB<bits<4> op7_4, string Dt>
 535   : NLdSt<0, 0b00, 0b1010, op7_4, (outs GPR:$wb),
 536           (ins addrmode6:$addr, QPR:$src), IIC_VST,
 537           "vst1", Dt, "${src:dregpair}, $addr", "$addr.addr = $wb", []>;
 538
 539 def VST1d8_UPD  : VST1DWB<0b0000, "8">;
 540 def VST1d16_UPD : VST1DWB<0b0100, "16">;
 541 def VST1d32_UPD : VST1DWB<0b1000, "32">;
 542 def VST1d64_UPD : VST1DWB<0b1100, "64">;
 543
 544 def VST1q8_UPD  : VST1QWB<0b0000, "8">;
 545 def VST1q16_UPD : VST1QWB<0b0100, "16">;
 546 def VST1q32_UPD : VST1QWB<0b1000, "32">;
 547 def VST1q64_UPD : VST1QWB<0b1100, "64">;
 548
 549 // These (dreg triple/quadruple) are for disassembly only.
 550 class VST1D3<bits<4> op7_4, string Dt>
 551   : NLdSt<0, 0b00, 0b0110, op7_4, (outs),
 552           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3),
 553           IIC_VST, "vst1", Dt, "\\{$src1, $src2, $src3\\}, $addr", "",
 554           [/* For disassembly only; pattern left blank */]>;
 555 class VST1D4<bits<4> op7_4, string Dt>
 556   : NLdSt<0, 0b00, 0b0010, op7_4, (outs),
 557           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
 558           IIC_VST, "vst1", Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr", "",
 559           [/* For disassembly only; pattern left blank */]>;
 560
 561 def  VST1d8T  : VST1D3<0b0000, "8">;
 562 def  VST1d16T : VST1D3<0b0100, "16">;
 563 def  VST1d32T : VST1D3<0b1000, "32">;
 564 //   VST1d64T : implemented as VST3d64
 565
 566 def  VST1d8Q  : VST1D4<0b0000, "8">;
 567 def  VST1d16Q : VST1D4<0b0100, "16">;
 568 def  VST1d32Q : VST1D4<0b1000, "32">;
 569 //   VST1d64Q : implemented as VST4d64
 570
 571 // ...with address register writeback:
 572 class VST1D3WB<bits<4> op7_4, string Dt>
 573   : NLdSt<0, 0b00, 0b0110, op7_4, (outs GPR:$wb),
 574           (ins addrmode6:$addr,
 575            DPR:$src1, DPR:$src2, DPR:$src3),
 576           IIC_VST, "vst1", Dt, "\\{$src1, $src2, $src3\\}, $addr",
 577           "$addr.addr = $wb",
 578           [/* For disassembly only; pattern left blank */]>;
 579 class VST1D4WB<bits<4> op7_4, string Dt>
 580   : NLdSt<0, 0b00, 0b0010, op7_4, (outs GPR:$wb),
 581           (ins addrmode6:$addr,
 582            DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
 583           IIC_VST, "vst1", Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
 584           "$addr.addr = $wb",
 585           [/* For disassembly only; pattern left blank */]>;
 586
 587 def VST1d8T_UPD  : VST1D3WB<0b0000, "8">;
 588 def VST1d16T_UPD : VST1D3WB<0b0100, "16">;
 589 def VST1d32T_UPD : VST1D3WB<0b1000, "32">;
 590 //  VST1d64T_UPD : implemented as VST3d64_UPD
 591
 592 def VST1d8Q_UPD  : VST1D4WB<0b0000, "8">;
 593 def VST1d16Q_UPD : VST1D4WB<0b0100, "16">;
 594 def VST1d32Q_UPD : VST1D4WB<0b1000, "32">;
 595 //  VST1d64Q_UPD : implemented as VST4d64_UPD
 596
 597 //   VST2     : Vector Store (multiple 2-element structures)
 598 class VST2D<bits<4> op11_8, bits<4> op7_4, string Dt>
 599   : NLdSt<0, 0b00, op11_8, op7_4, (outs),
 600           (ins addrmode6:$addr, DPR:$src1, DPR:$src2),
 601           IIC_VST, "vst2", Dt, "\\{$src1, $src2\\}, $addr", "", []>;
 602 class VST2Q<bits<4> op7_4, string Dt>
 603   : NLdSt<0, 0b00, 0b0011, op7_4, (outs),
 604           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
 605           IIC_VST, "vst2", Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
 606           "", []>;
 607
 608 def  VST2d8   : VST2D<0b1000, 0b0000, "8">;
 609 def  VST2d16  : VST2D<0b1000, 0b0100, "16">;
 610 def  VST2d32  : VST2D<0b1000, 0b1000, "32">;
 611 def  VST2d64  : NLdSt<0,0b00,0b1010,0b1100, (outs),
 612                       (ins addrmode6:$addr, DPR:$src1, DPR:$src2), IIC_VST,
 613                       "vst1", "64", "\\{$src1, $src2\\}, $addr", "", []>;
 614
 615 def  VST2q8   : VST2Q<0b0000, "8">;
 616 def  VST2q16  : VST2Q<0b0100, "16">;
 617 def  VST2q32  : VST2Q<0b1000, "32">;
 618
 619 // ...with double-spaced registers (for disassembly only):
 620 def VST2b8      : VST2D<0b1001, 0b0000, "8">;
 621 def VST2b16     : VST2D<0b1001, 0b0100, "16">;
 622 def VST2b32     : VST2D<0b1001, 0b1000, "32">;
 623
 624 //   VST3     : Vector Store (multiple 3-element structures)
 625 class VST3D<bits<4> op11_8, bits<4> op7_4, string Dt>
 626   : NLdSt<0, 0b00, op11_8, op7_4, (outs),
 627           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3), IIC_VST,
 628           "vst3", Dt, "\\{$src1, $src2, $src3\\}, $addr", "", []>;
 629 class VST3WB<bits<4> op7_4, string Dt>
 630   : NLdSt<0,0b00,0b0101,op7_4, (outs GPR:$wb),
 631           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3), IIC_VST,
 632           "vst3", Dt, "\\{$src1, $src2, $src3\\}, $addr",
 633           "$addr.addr = $wb", []>;
 634
 635 def  VST3d8   : VST3D<0b0100, 0b0000, "8">;
 636 def  VST3d16  : VST3D<0b0100, 0b0100, "16">;
 637 def  VST3d32  : VST3D<0b0100, 0b1000, "32">;
 638 def  VST3d64  : NLdSt<0,0b00,0b0110,0b1100, (outs),
 639                       (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3),
 640                       IIC_VST,
 641                       "vst1", "64", "\\{$src1, $src2, $src3\\}, $addr", "", []>;
 642
 643 // ...with double-spaced registers:
 644 def VST3q8      : VST3D<0b0101, 0b0000, "8">;
 645 def VST3q16     : VST3D<0b0101, 0b0100, "16">;
 646 def VST3q32     : VST3D<0b0101, 0b1000, "32">;
 647
 648 // vst3 to double-spaced even registers.
 649 def VST3q8_UPD  : VST3WB<0b0000, "8">;
 650 def VST3q16_UPD : VST3WB<0b0100, "16">;
 651 def VST3q32_UPD : VST3WB<0b1000, "32">;
 652
 653 // vst3 to double-spaced odd registers.
 654 def VST3q8odd_UPD  : VST3WB<0b0000, "8">;
 655 def VST3q16odd_UPD : VST3WB<0b0100, "16">;
 656 def VST3q32odd_UPD : VST3WB<0b1000, "32">;
 657
 658 //   VST4     : Vector Store (multiple 4-element structures)
 659 class VST4D<bits<4> op11_8, bits<4> op7_4, string Dt>
 660   : NLdSt<0, 0b00, op11_8, op7_4, (outs),
 661           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
 662           IIC_VST, "vst4", Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
 663           "", []>;
 664 class VST4WB<bits<4> op7_4, string Dt>
 665   : NLdSt<0,0b00,0b0001,op7_4, (outs GPR:$wb),
 666           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
 667           IIC_VST, "vst4", Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
 668           "$addr.addr = $wb", []>;
 669
 670 def  VST4d8   : VST4D<0b0000, 0b0000, "8">;
 671 def  VST4d16  : VST4D<0b0000, 0b0100, "16">;
 672 def  VST4d32  : VST4D<0b0000, 0b1000, "32">;
 673 def  VST4d64  : NLdSt<0,0b00,0b0010,0b1100, (outs),
 674                       (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
 675                        DPR:$src4), IIC_VST,
 676                       "vst1", "64", "\\{$src1, $src2, $src3, $src4\\}, $addr",
 677                       "", []>;
 678
 679 // ...with double-spaced registers:
 680 def VST4q8      : VST4D<0b0001, 0b0000, "8">;
 681 def VST4q16     : VST4D<0b0001, 0b0100, "16">;
 682 def VST4q32     : VST4D<0b0001, 0b1000, "32">;
 683
 684 // vst4 to double-spaced even registers.
 685 def VST4q8_UPD  : VST4WB<0b0000, "8">;
 686 def VST4q16_UPD : VST4WB<0b0100, "16">;
 687 def VST4q32_UPD : VST4WB<0b1000, "32">;
 688
 689 // vst4 to double-spaced odd registers.
 690 def VST4q8odd_UPD  : VST4WB<0b0000, "8">;
 691 def VST4q16odd_UPD : VST4WB<0b0100, "16">;
 692 def VST4q32odd_UPD : VST4WB<0b1000, "32">;
 693
 694 //   VST1LN   : Vector Store (single element from one lane)
 695 //   FIXME: Not yet implemented.
 696
 697 //   VST2LN   : Vector Store (single 2-element structure from one lane)
 698 class VST2LN<bits<4> op11_8, string Dt>
 699   : NLdSt<1, 0b00, op11_8, {?,?,?,?}, (outs),
 700           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
 701           IIC_VST, "vst2", Dt, "\\{$src1[$lane], $src2[$lane]\\}, $addr",
 702           "", []>;
 703
 704 def VST2LNd8  : VST2LN<0b0001, "8">;
 705 def VST2LNd16 : VST2LN<0b0101, "16"> { let Inst{5} = 0; }
 706 def VST2LNd32 : VST2LN<0b1001, "32"> { let Inst{6} = 0; }
 707
 708 // ...with double-spaced registers:
 709 def VST2LNq16 : VST2LN<0b0101, "16"> { let Inst{5} = 1; }
 710 def VST2LNq32 : VST2LN<0b1001, "32"> { let Inst{6} = 1; }
 711
 712 // ...alternate versions to be allocated odd register numbers:
 713 def VST2LNq16odd : VST2LN<0b0101, "16"> { let Inst{5} = 1; }
 714 def VST2LNq32odd : VST2LN<0b1001, "32"> { let Inst{6} = 1; }
 715
 716 //   VST3LN   : Vector Store (single 3-element structure from one lane)
 717 class VST3LN<bits<4> op11_8, string Dt>
 718   : NLdSt<1, 0b00, op11_8, {?,?,?,?}, (outs),
 719           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
 720            nohash_imm:$lane), IIC_VST, "vst3", Dt,
 721           "\\{$src1[$lane], $src2[$lane], $src3[$lane]\\}, $addr", "", []>;
 722
 723 def VST3LNd8  : VST3LN<0b0010, "8"> { let Inst{4} = 0; }
 724 def VST3LNd16 : VST3LN<0b0110, "16"> { let Inst{5-4} = 0b00; }
 725 def VST3LNd32 : VST3LN<0b1010, "32"> { let Inst{6-4} = 0b000; }
 726
 727 // ...with double-spaced registers:
 728 def VST3LNq16 : VST3LN<0b0110, "16"> { let Inst{5-4} = 0b10; }
 729 def VST3LNq32 : VST3LN<0b1010, "32"> { let Inst{6-4} = 0b100; }
 730
 731 // ...alternate versions to be allocated odd register numbers:
 732 def VST3LNq16odd : VST3LN<0b0110, "16"> { let Inst{5-4} = 0b10; }
 733 def VST3LNq32odd : VST3LN<0b1010, "32"> { let Inst{6-4} = 0b100; }
 734
 735 //   VST4LN   : Vector Store (single 4-element structure from one lane)
 736 class VST4LN<bits<4> op11_8, string Dt>
 737   : NLdSt<1, 0b00, op11_8, {?,?,?,?}, (outs),
 738           (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4,
 739            nohash_imm:$lane), IIC_VST, "vst4", Dt,
 740           "\\{$src1[$lane], $src2[$lane], $src3[$lane], $src4[$lane]\\}, $addr",
 741           "", []>;
 742
 743 def VST4LNd8  : VST4LN<0b0011, "8">;
 744 def VST4LNd16 : VST4LN<0b0111, "16"> { let Inst{5} = 0; }
 745 def VST4LNd32 : VST4LN<0b1011, "32"> { let Inst{6} = 0; }
 746
 747 // ...with double-spaced registers:
 748 def VST4LNq16 : VST4LN<0b0111, "16"> { let Inst{5} = 1; }
 749 def VST4LNq32 : VST4LN<0b1011, "32"> { let Inst{6} = 1; }
 750
 751 // ...alternate versions to be allocated odd register numbers:
 752 def VST4LNq16odd : VST4LN<0b0111, "16"> { let Inst{5} = 1; }
 753 def VST4LNq32odd : VST4LN<0b1011, "32"> { let Inst{6} = 1; }
 754
 755 } // mayStore = 1, hasExtraSrcRegAllocReq = 1
 756
 757
 758 //===----------------------------------------------------------------------===//
 759 // NEON pattern fragments
 760 //===----------------------------------------------------------------------===//
 761
 762 // Extract D sub-registers of Q registers.
 763 // (arm_dsubreg_0 is 5; arm_dsubreg_1 is 6)
 764 def DSubReg_i8_reg  : SDNodeXForm<imm, [{
 765   return CurDAG->getTargetConstant(5 + N->getZExtValue() / 8, MVT::i32);
 766 }]>;
 767 def DSubReg_i16_reg : SDNodeXForm<imm, [{
 768   return CurDAG->getTargetConstant(5 + N->getZExtValue() / 4, MVT::i32);
 769 }]>;
 770 def DSubReg_i32_reg : SDNodeXForm<imm, [{
 771   return CurDAG->getTargetConstant(5 + N->getZExtValue() / 2, MVT::i32);
 772 }]>;
 773 def DSubReg_f64_reg : SDNodeXForm<imm, [{
 774   return CurDAG->getTargetConstant(5 + N->getZExtValue(), MVT::i32);
 775 }]>;
 776 def DSubReg_f64_other_reg : SDNodeXForm<imm, [{
 777   return CurDAG->getTargetConstant(5 + (1 - N->getZExtValue()), MVT::i32);
 778 }]>;
 779
 780 // Extract S sub-registers of Q/D registers.
 781 // (arm_ssubreg_0 is 1; arm_ssubreg_1 is 2; etc.)
 782 def SSubReg_f32_reg : SDNodeXForm<imm, [{
 783   return CurDAG->getTargetConstant(1 + N->getZExtValue(), MVT::i32);
 784 }]>;
 785
 786 // Translate lane numbers from Q registers to D subregs.
 787 def SubReg_i8_lane  : SDNodeXForm<imm, [{
 788   return CurDAG->getTargetConstant(N->getZExtValue() & 7, MVT::i32);
 789 }]>;
 790 def SubReg_i16_lane : SDNodeXForm<imm, [{
 791   return CurDAG->getTargetConstant(N->getZExtValue() & 3, MVT::i32);
 792 }]>;
 793 def SubReg_i32_lane : SDNodeXForm<imm, [{
 794   return CurDAG->getTargetConstant(N->getZExtValue() & 1, MVT::i32);
 795 }]>;
 796
 797 //===----------------------------------------------------------------------===//
 798 // Instruction Classes
 799 //===----------------------------------------------------------------------===//
 800
 801 // Basic 2-register operations: single-, double- and quad-register.
 802 class N2VS<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 803            bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
 804            string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
 805   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
 806         (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src),
 807         IIC_VUNAD, OpcodeStr, Dt, "$dst, $src", "", []>;
 808 class N2VD<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 809            bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
 810            string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
 811   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
 812         (ins DPR:$src), IIC_VUNAD, OpcodeStr, Dt, "$dst, $src", "",
 813         [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src))))]>;
 814 class N2VQ<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 815            bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
 816            string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
 817   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
 818         (ins QPR:$src), IIC_VUNAQ, OpcodeStr, Dt, "$dst, $src", "",
 819         [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src))))]>;
 820
 821 // Basic 2-register intrinsics, both double- and quad-register.
 822 class N2VDInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 823               bits<2> op17_16, bits<5> op11_7, bit op4,
 824               InstrItinClass itin, string OpcodeStr, string Dt,
 825               ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
 826   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
 827         (ins DPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
 828         [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
 829 class N2VQInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 830               bits<2> op17_16, bits<5> op11_7, bit op4,
 831               InstrItinClass itin, string OpcodeStr, string Dt,
 832               ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
 833   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
 834         (ins QPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
 835         [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
 836
 837 // Narrow 2-register intrinsics.
 838 class N2VNInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 839               bits<2> op17_16, bits<5> op11_7, bit op6, bit op4,
 840               InstrItinClass itin, string OpcodeStr, string Dt,
 841               ValueType TyD, ValueType TyQ, Intrinsic IntOp>
 842   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, op6, op4, (outs DPR:$dst),
 843         (ins QPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
 844         [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src))))]>;
 845
 846 // Long 2-register intrinsics (currently only used for VMOVL).
 847 class N2VLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
 848               bits<2> op17_16, bits<5> op11_7, bit op6, bit op4,
 849               InstrItinClass itin, string OpcodeStr, string Dt,
 850               ValueType TyQ, ValueType TyD, Intrinsic IntOp>
 851   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, op6, op4, (outs QPR:$dst),
 852         (ins DPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
 853         [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src))))]>;
 854
 855 // 2-register shuffles (VTRN/VZIP/VUZP), both double- and quad-register.
 856 class N2VDShuffle<bits<2> op19_18, bits<5> op11_7, string OpcodeStr, string Dt>
 857   : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 0, 0, (outs DPR:$dst1, DPR:$dst2),
 858         (ins DPR:$src1, DPR:$src2), IIC_VPERMD,
 859         OpcodeStr, Dt, "$dst1, $dst2",
 860         "$src1 = $dst1, $src2 = $dst2", []>;
 861 class N2VQShuffle<bits<2> op19_18, bits<5> op11_7,
 862                   InstrItinClass itin, string OpcodeStr, string Dt>
 863   : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 1, 0, (outs QPR:$dst1, QPR:$dst2),
 864         (ins QPR:$src1, QPR:$src2), itin, OpcodeStr, Dt, "$dst1, $dst2",
 865         "$src1 = $dst1, $src2 = $dst2", []>;
 866
 867 // Basic 3-register operations: single-, double- and quad-register.
 868 class N3VS<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 869            string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
 870            SDNode OpNode, bit Commutable>
 871   : N3V<op24, op23, op21_20, op11_8, 0, op4,
 872         (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
 873         OpcodeStr, Dt, "$dst, $src1, $src2", "", []> {
 874   let isCommutable = Commutable;
 875 }
 876
 877 class N3VD<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 878            InstrItinClass itin, string OpcodeStr, string Dt,
 879            ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
 880   : N3V<op24, op23, op21_20, op11_8, 0, op4,
 881         (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
 882         OpcodeStr, Dt, "$dst, $src1, $src2", "",
 883         [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
 884   let isCommutable = Commutable;
 885 }
 886 // Same as N3VD but no data type.
 887 class N3VDX<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 888            InstrItinClass itin, string OpcodeStr,
 889            ValueType ResTy, ValueType OpTy,
 890            SDNode OpNode, bit Commutable>
 891   : N3VX<op24, op23, op21_20, op11_8, 0, op4,
 892          (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
 893          OpcodeStr, "$dst, $src1, $src2", "",
 894          [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src1), (OpTy DPR:$src2))))]>{
 895   let isCommutable = Commutable;
 896 }
 897 class N3VDSL<bits<2> op21_20, bits<4> op11_8,
 898              InstrItinClass itin, string OpcodeStr, string Dt,
 899              ValueType Ty, SDNode ShOp>
 900   : N3V<0, 1, op21_20, op11_8, 1, 0,
 901         (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
 902         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 903         [(set (Ty DPR:$dst),
 904               (Ty (ShOp (Ty DPR:$src1),
 905                         (Ty (NEONvduplane (Ty DPR_VFP2:$src2), imm:$lane)))))]>{
 906   let isCommutable = 0;
 907 }
 908 class N3VDSL16<bits<2> op21_20, bits<4> op11_8,
 909                string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
 910   : N3V<0, 1, op21_20, op11_8, 1, 0,
 911         (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
 912         IIC_VMULi16D, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 913         [(set (Ty DPR:$dst),
 914               (Ty (ShOp (Ty DPR:$src1),
 915                         (Ty (NEONvduplane (Ty DPR_8:$src2), imm:$lane)))))]> {
 916   let isCommutable = 0;
 917 }
 918
 919 class N3VQ<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 920            InstrItinClass itin, string OpcodeStr, string Dt,
 921            ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
 922   : N3V<op24, op23, op21_20, op11_8, 1, op4,
 923         (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
 924         OpcodeStr, Dt, "$dst, $src1, $src2", "",
 925         [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
 926   let isCommutable = Commutable;
 927 }
 928 class N3VQX<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 929            InstrItinClass itin, string OpcodeStr,
 930            ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
 931   : N3VX<op24, op23, op21_20, op11_8, 1, op4,
 932          (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
 933          OpcodeStr, "$dst, $src1, $src2", "",
 934          [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src1), (OpTy QPR:$src2))))]>{
 935   let isCommutable = Commutable;
 936 }
 937 class N3VQSL<bits<2> op21_20, bits<4> op11_8,
 938              InstrItinClass itin, string OpcodeStr, string Dt,
 939              ValueType ResTy, ValueType OpTy, SDNode ShOp>
 940   : N3V<1, 1, op21_20, op11_8, 1, 0,
 941         (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
 942         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 943         [(set (ResTy QPR:$dst),
 944               (ResTy (ShOp (ResTy QPR:$src1),
 945                            (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
 946                                                 imm:$lane)))))]> {
 947   let isCommutable = 0;
 948 }
 949 class N3VQSL16<bits<2> op21_20, bits<4> op11_8, string OpcodeStr, string Dt,
 950                ValueType ResTy, ValueType OpTy, SDNode ShOp>
 951   : N3V<1, 1, op21_20, op11_8, 1, 0,
 952         (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
 953         IIC_VMULi16Q, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 954         [(set (ResTy QPR:$dst),
 955               (ResTy (ShOp (ResTy QPR:$src1),
 956                            (ResTy (NEONvduplane (OpTy DPR_8:$src2),
 957                                                 imm:$lane)))))]> {
 958   let isCommutable = 0;
 959 }
 960
 961 // Basic 3-register intrinsics, both double- and quad-register.
 962 class N3VDInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 963               InstrItinClass itin, string OpcodeStr, string Dt,
 964               ValueType ResTy, ValueType OpTy, Intrinsic IntOp, bit Commutable>
 965   : N3V<op24, op23, op21_20, op11_8, 0, op4,
 966         (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
 967         OpcodeStr, Dt, "$dst, $src1, $src2", "",
 968         [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
 969   let isCommutable = Commutable;
 970 }
 971 class N3VDIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
 972                 string OpcodeStr, string Dt, ValueType Ty, Intrinsic IntOp>
 973   : N3V<0, 1, op21_20, op11_8, 1, 0,
 974         (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
 975         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 976         [(set (Ty DPR:$dst),
 977               (Ty (IntOp (Ty DPR:$src1),
 978                          (Ty (NEONvduplane (Ty DPR_VFP2:$src2),
 979                                            imm:$lane)))))]> {
 980   let isCommutable = 0;
 981 }
 982 class N3VDIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
 983                   string OpcodeStr, string Dt, ValueType Ty, Intrinsic IntOp>
 984   : N3V<0, 1, op21_20, op11_8, 1, 0,
 985         (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
 986         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
 987         [(set (Ty DPR:$dst),
 988               (Ty (IntOp (Ty DPR:$src1),
 989                          (Ty (NEONvduplane (Ty DPR_8:$src2),
 990                                            imm:$lane)))))]> {
 991   let isCommutable = 0;
 992 }
 993
 994 class N3VQInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
 995               InstrItinClass itin, string OpcodeStr, string Dt,
 996               ValueType ResTy, ValueType OpTy, Intrinsic IntOp, bit Commutable>
 997   : N3V<op24, op23, op21_20, op11_8, 1, op4,
 998         (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
 999         OpcodeStr, Dt, "$dst, $src1, $src2", "",
1000         [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
1001   let isCommutable = Commutable;
1002 }
1003 class N3VQIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1004                 string OpcodeStr, string Dt,
1005                 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1006   : N3V<1, 1, op21_20, op11_8, 1, 0,
1007         (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
1008         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1009         [(set (ResTy QPR:$dst),
1010               (ResTy (IntOp (ResTy QPR:$src1),
1011                             (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
1012                                                  imm:$lane)))))]> {
1013   let isCommutable = 0;
1014 }
1015 class N3VQIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1016                   string OpcodeStr, string Dt,
1017                   ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1018   : N3V<1, 1, op21_20, op11_8, 1, 0,
1019         (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
1020         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1021         [(set (ResTy QPR:$dst),
1022               (ResTy (IntOp (ResTy QPR:$src1),
1023                             (ResTy (NEONvduplane (OpTy DPR_8:$src2),
1024                                                  imm:$lane)))))]> {
1025   let isCommutable = 0;
1026 }
1027
1028 // Multiply-Add/Sub operations: single-, double- and quad-register.
1029 class N3VSMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1030                 InstrItinClass itin, string OpcodeStr, string Dt,
1031                 ValueType Ty, SDNode MulOp, SDNode OpNode>
1032   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1033         (outs DPR_VFP2:$dst),
1034         (ins DPR_VFP2:$src1, DPR_VFP2:$src2, DPR_VFP2:$src3), itin,
1035         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst", []>;
1036
1037 class N3VDMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1038                 InstrItinClass itin, string OpcodeStr, string Dt,
1039                 ValueType Ty, SDNode MulOp, SDNode OpNode>
1040   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1041         (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
1042         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1043         [(set DPR:$dst, (Ty (OpNode DPR:$src1,
1044                              (Ty (MulOp DPR:$src2, DPR:$src3)))))]>;
1045 class N3VDMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1046                   string OpcodeStr, string Dt,
1047                   ValueType Ty, SDNode MulOp, SDNode ShOp>
1048   : N3V<0, 1, op21_20, op11_8, 1, 0,
1049         (outs DPR:$dst),
1050         (ins DPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
1051         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1052         [(set (Ty DPR:$dst),
1053               (Ty (ShOp (Ty DPR:$src1),
1054                         (Ty (MulOp DPR:$src2,
1055                                    (Ty (NEONvduplane (Ty DPR_VFP2:$src3),
1056                                                      imm:$lane)))))))]>;
1057 class N3VDMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1058                     string OpcodeStr, string Dt,
1059                     ValueType Ty, SDNode MulOp, SDNode ShOp>
1060   : N3V<0, 1, op21_20, op11_8, 1, 0,
1061         (outs DPR:$dst),
1062         (ins DPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1063         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1064         [(set (Ty DPR:$dst),
1065               (Ty (ShOp (Ty DPR:$src1),
1066                         (Ty (MulOp DPR:$src2,
1067                                    (Ty (NEONvduplane (Ty DPR_8:$src3),
1068                                                      imm:$lane)))))))]>;
1069
1070 class N3VQMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1071                 InstrItinClass itin, string OpcodeStr, string Dt, ValueType Ty,
1072                 SDNode MulOp, SDNode OpNode>
1073   : N3V<op24, op23, op21_20, op11_8, 1, op4,
1074         (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
1075         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1076         [(set QPR:$dst, (Ty (OpNode QPR:$src1,
1077                              (Ty (MulOp QPR:$src2, QPR:$src3)))))]>;
1078 class N3VQMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1079                   string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1080                   SDNode MulOp, SDNode ShOp>
1081   : N3V<1, 1, op21_20, op11_8, 1, 0,
1082         (outs QPR:$dst),
1083         (ins QPR:$src1, QPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
1084         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1085         [(set (ResTy QPR:$dst),
1086               (ResTy (ShOp (ResTy QPR:$src1),
1087                            (ResTy (MulOp QPR:$src2,
1088                                    (ResTy (NEONvduplane (OpTy DPR_VFP2:$src3),
1089                                                         imm:$lane)))))))]>;
1090 class N3VQMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1091                     string OpcodeStr, string Dt,
1092                     ValueType ResTy, ValueType OpTy,
1093                     SDNode MulOp, SDNode ShOp>
1094   : N3V<1, 1, op21_20, op11_8, 1, 0,
1095         (outs QPR:$dst),
1096         (ins QPR:$src1, QPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1097         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1098         [(set (ResTy QPR:$dst),
1099               (ResTy (ShOp (ResTy QPR:$src1),
1100                            (ResTy (MulOp QPR:$src2,
1101                                    (ResTy (NEONvduplane (OpTy DPR_8:$src3),
1102                                                         imm:$lane)))))))]>;
1103
1104 // Neon 3-argument intrinsics, both double- and quad-register.
1105 // The destination register is also used as the first source operand register.
1106 class N3VDInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1107                InstrItinClass itin, string OpcodeStr, string Dt,
1108                ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1109   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1110         (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
1111         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1112         [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1),
1113                                       (OpTy DPR:$src2), (OpTy DPR:$src3))))]>;
1114 class N3VQInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1115                InstrItinClass itin, string OpcodeStr, string Dt,
1116                ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1117   : N3V<op24, op23, op21_20, op11_8, 1, op4,
1118         (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
1119         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1120         [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1),
1121                                       (OpTy QPR:$src2), (OpTy QPR:$src3))))]>;
1122
1123 // Neon Long 3-argument intrinsic.  The destination register is
1124 // a quad-register and is also used as the first source operand register.
1125 class N3VLInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1126                InstrItinClass itin, string OpcodeStr, string Dt,
1127                ValueType TyQ, ValueType TyD, Intrinsic IntOp>
1128   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1129         (outs QPR:$dst), (ins QPR:$src1, DPR:$src2, DPR:$src3), itin,
1130         OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1131         [(set QPR:$dst,
1132           (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2), (TyD DPR:$src3))))]>;
1133 class N3VLInt3SL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1134                  string OpcodeStr, string Dt,
1135                  ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1136   : N3V<op24, 1, op21_20, op11_8, 1, 0,
1137         (outs QPR:$dst),
1138         (ins QPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
1139         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1140         [(set (ResTy QPR:$dst),
1141               (ResTy (IntOp (ResTy QPR:$src1),
1142                             (OpTy DPR:$src2),
1143                             (OpTy (NEONvduplane (OpTy DPR_VFP2:$src3),
1144                                                 imm:$lane)))))]>;
1145 class N3VLInt3SL16<bit op24, bits<2> op21_20, bits<4> op11_8,
1146                    InstrItinClass itin, string OpcodeStr, string Dt,
1147                    ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1148   : N3V<op24, 1, op21_20, op11_8, 1, 0,
1149         (outs QPR:$dst),
1150         (ins QPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1151         OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1152         [(set (ResTy QPR:$dst),
1153               (ResTy (IntOp (ResTy QPR:$src1),
1154                             (OpTy DPR:$src2),
1155                             (OpTy (NEONvduplane (OpTy DPR_8:$src3),
1156                                                 imm:$lane)))))]>;
1157
1158 // Narrowing 3-register intrinsics.
1159 class N3VNInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1160               string OpcodeStr, string Dt, ValueType TyD, ValueType TyQ,
1161               Intrinsic IntOp, bit Commutable>
1162   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1163         (outs DPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VBINi4D,
1164         OpcodeStr, Dt, "$dst, $src1, $src2", "",
1165         [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src1), (TyQ QPR:$src2))))]> {
1166   let isCommutable = Commutable;
1167 }
1168
1169 // Long 3-register intrinsics.
1170 class N3VLInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1171               InstrItinClass itin, string OpcodeStr, string Dt,
1172               ValueType TyQ, ValueType TyD, Intrinsic IntOp, bit Commutable>
1173   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1174         (outs QPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
1175         OpcodeStr, Dt, "$dst, $src1, $src2", "",
1176         [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src1), (TyD DPR:$src2))))]> {
1177   let isCommutable = Commutable;
1178 }
1179 class N3VLIntSL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1180                 string OpcodeStr, string Dt,
1181                 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1182   : N3V<op24, 1, op21_20, op11_8, 1, 0,
1183         (outs QPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
1184         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1185         [(set (ResTy QPR:$dst),
1186               (ResTy (IntOp (OpTy DPR:$src1),
1187                             (OpTy (NEONvduplane (OpTy DPR_VFP2:$src2),
1188                                                 imm:$lane)))))]>;
1189 class N3VLIntSL16<bit op24, bits<2> op21_20, bits<4> op11_8,
1190                   InstrItinClass itin, string OpcodeStr, string Dt,
1191                   ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1192   : N3V<op24, 1, op21_20, op11_8, 1, 0,
1193         (outs QPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
1194         itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1195         [(set (ResTy QPR:$dst),
1196               (ResTy (IntOp (OpTy DPR:$src1),
1197                             (OpTy (NEONvduplane (OpTy DPR_8:$src2),
1198                                                 imm:$lane)))))]>;
1199
1200 // Wide 3-register intrinsics.
1201 class N3VWInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1202               string OpcodeStr, string Dt, ValueType TyQ, ValueType TyD,
1203               Intrinsic IntOp, bit Commutable>
1204   : N3V<op24, op23, op21_20, op11_8, 0, op4,
1205         (outs QPR:$dst), (ins QPR:$src1, DPR:$src2), IIC_VSUBiD,
1206         OpcodeStr, Dt, "$dst, $src1, $src2", "",
1207         [(set QPR:$dst, (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2))))]> {
1208   let isCommutable = Commutable;
1209 }
1210
1211 // Pairwise long 2-register intrinsics, both double- and quad-register.
1212 class N2VDPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1213                 bits<2> op17_16, bits<5> op11_7, bit op4,
1214                 string OpcodeStr, string Dt,
1215                 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1216   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
1217         (ins DPR:$src), IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
1218         [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
1219 class N2VQPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1220                 bits<2> op17_16, bits<5> op11_7, bit op4,
1221                 string OpcodeStr, string Dt,
1222                 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1223   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
1224         (ins QPR:$src), IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
1225         [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
1226
1227 // Pairwise long 2-register accumulate intrinsics,
1228 // both double- and quad-register.
1229 // The destination register is also used as the first source operand register.
1230 class N2VDPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1231                  bits<2> op17_16, bits<5> op11_7, bit op4,
1232                  string OpcodeStr, string Dt,
1233                  ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1234   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
1235         (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), IIC_VPALiD,
1236         OpcodeStr, Dt, "$dst, $src2", "$src1 = $dst",
1237         [(set DPR:$dst, (ResTy (IntOp (ResTy DPR:$src1), (OpTy DPR:$src2))))]>;
1238 class N2VQPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1239                  bits<2> op17_16, bits<5> op11_7, bit op4,
1240                  string OpcodeStr, string Dt,
1241                  ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1242   : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4,
1243         (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VPALiQ,
1244         OpcodeStr, Dt, "$dst, $src2", "$src1 = $dst",
1245         [(set QPR:$dst, (ResTy (IntOp (ResTy QPR:$src1), (OpTy QPR:$src2))))]>;
1246
1247 // Shift by immediate,
1248 // both double- and quad-register.
1249 class N2VDSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1250              InstrItinClass itin, string OpcodeStr, string Dt,
1251              ValueType Ty, SDNode OpNode>
1252   : N2VImm<op24, op23, op11_8, op7, 0, op4,
1253            (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), itin,
1254            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1255            [(set DPR:$dst, (Ty (OpNode (Ty DPR:$src), (i32 imm:$SIMM))))]>;
1256 class N2VQSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1257              InstrItinClass itin, string OpcodeStr, string Dt,
1258              ValueType Ty, SDNode OpNode>
1259   : N2VImm<op24, op23, op11_8, op7, 1, op4,
1260            (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
1261            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1262            [(set QPR:$dst, (Ty (OpNode (Ty QPR:$src), (i32 imm:$SIMM))))]>;
1263
1264 // Long shift by immediate.
1265 class N2VLSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6, bit op4,
1266              string OpcodeStr, string Dt,
1267              ValueType ResTy, ValueType OpTy, SDNode OpNode>
1268   : N2VImm<op24, op23, op11_8, op7, op6, op4,
1269            (outs QPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VSHLiD,
1270            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1271            [(set QPR:$dst, (ResTy (OpNode (OpTy DPR:$src),
1272                                           (i32 imm:$SIMM))))]>;
1273
1274 // Narrow shift by immediate.
1275 class N2VNSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6, bit op4,
1276              InstrItinClass itin, string OpcodeStr, string Dt,
1277              ValueType ResTy, ValueType OpTy, SDNode OpNode>
1278   : N2VImm<op24, op23, op11_8, op7, op6, op4,
1279            (outs DPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
1280            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1281            [(set DPR:$dst, (ResTy (OpNode (OpTy QPR:$src),
1282                                           (i32 imm:$SIMM))))]>;
1283
1284 // Shift right by immediate and accumulate,
1285 // both double- and quad-register.
1286 class N2VDShAdd<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1287                 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1288   : N2VImm<op24, op23, op11_8, op7, 0, op4, (outs DPR:$dst),
1289            (ins DPR:$src1, DPR:$src2, i32imm:$SIMM), IIC_VPALiD,
1290            OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1291            [(set DPR:$dst, (Ty (add DPR:$src1,
1292                                 (Ty (ShOp DPR:$src2, (i32 imm:$SIMM))))))]>;
1293 class N2VQShAdd<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1294                 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1295   : N2VImm<op24, op23, op11_8, op7, 1, op4, (outs QPR:$dst),
1296            (ins QPR:$src1, QPR:$src2, i32imm:$SIMM), IIC_VPALiD,
1297            OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1298            [(set QPR:$dst, (Ty (add QPR:$src1,
1299                                 (Ty (ShOp QPR:$src2, (i32 imm:$SIMM))))))]>;
1300
1301 // Shift by immediate and insert,
1302 // both double- and quad-register.
1303 class N2VDShIns<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1304                 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1305   : N2VImm<op24, op23, op11_8, op7, 0, op4, (outs DPR:$dst),
1306            (ins DPR:$src1, DPR:$src2, i32imm:$SIMM), IIC_VSHLiD,
1307            OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1308            [(set DPR:$dst, (Ty (ShOp DPR:$src1, DPR:$src2, (i32 imm:$SIMM))))]>;
1309 class N2VQShIns<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1310                 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1311   : N2VImm<op24, op23, op11_8, op7, 1, op4, (outs QPR:$dst),
1312            (ins QPR:$src1, QPR:$src2, i32imm:$SIMM), IIC_VSHLiQ,
1313            OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1314            [(set QPR:$dst, (Ty (ShOp QPR:$src1, QPR:$src2, (i32 imm:$SIMM))))]>;
1315
1316 // Convert, with fractional bits immediate,
1317 // both double- and quad-register.
1318 class N2VCvtD<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1319               string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1320               Intrinsic IntOp>
1321   : N2VImm<op24, op23, op11_8, op7, 0, op4,
1322            (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VUNAD,
1323            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1324            [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src), (i32 imm:$SIMM))))]>;
1325 class N2VCvtQ<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1326               string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1327               Intrinsic IntOp>
1328   : N2VImm<op24, op23, op11_8, op7, 1, op4,
1329            (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), IIC_VUNAQ,
1330            OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1331            [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src), (i32 imm:$SIMM))))]>;
1332
1333 //===----------------------------------------------------------------------===//
1334 // Multiclasses
1335 //===----------------------------------------------------------------------===//
1336
1337 // Abbreviations used in multiclass suffixes:
1338 //   Q = quarter int (8 bit) elements
1339 //   H = half int (16 bit) elements
1340 //   S = single int (32 bit) elements
1341 //   D = double int (64 bit) elements
1342
1343 // Neon 2-register vector operations -- for disassembly only.
1344
1345 // First with only element sizes of 8, 16 and 32 bits:
1346 multiclass N2V_QHS_cmp<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1347                        bits<5> op11_7, bit op4, string opc, string Dt,
1348                        string asm> {
1349   // 64-bit vector types.
1350   def v8i8  : N2V<op24_23, op21_20, 0b00, op17_16, op11_7, 0, op4,
1351                   (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1352                   opc, !strconcat(Dt, "8"), asm, "", []>;
1353   def v4i16 : N2V<op24_23, op21_20, 0b01, op17_16, op11_7, 0, op4,
1354                   (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1355                   opc, !strconcat(Dt, "16"), asm, "", []>;
1356   def v2i32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 0, op4,
1357                   (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1358                   opc, !strconcat(Dt, "32"), asm, "", []>;
1359   def v2f32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 0, op4,
1360                   (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1361                   opc, "f32", asm, "", []> {
1362     let Inst{10} = 1; // overwrite F = 1
1363   }
1364
1365   // 128-bit vector types.
1366   def v16i8 : N2V<op24_23, op21_20, 0b00, op17_16, op11_7, 1, op4,
1367                   (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1368                   opc, !strconcat(Dt, "8"), asm, "", []>;
1369   def v8i16 : N2V<op24_23, op21_20, 0b01, op17_16, op11_7, 1, op4,
1370                   (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1371                   opc, !strconcat(Dt, "16"), asm, "", []>;
1372   def v4i32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 1, op4,
1373                   (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1374                   opc, !strconcat(Dt, "32"), asm, "", []>;
1375   def v4f32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 1, op4,
1376                   (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1377                   opc, "f32", asm, "", []> {
1378     let Inst{10} = 1; // overwrite F = 1
1379   }
1380 }
1381
1382 // Neon 3-register vector operations.
1383
1384 // First with only element sizes of 8, 16 and 32 bits:
1385 multiclass N3V_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1386                    InstrItinClass itinD16, InstrItinClass itinD32,
1387                    InstrItinClass itinQ16, InstrItinClass itinQ32,
1388                    string OpcodeStr, string Dt,
1389                    SDNode OpNode, bit Commutable = 0> {
1390   // 64-bit vector types.
1391   def v8i8  : N3VD<op24, op23, 0b00, op11_8, op4, itinD16,
1392                    OpcodeStr, !strconcat(Dt, "8"),
1393                    v8i8, v8i8, OpNode, Commutable>;
1394   def v4i16 : N3VD<op24, op23, 0b01, op11_8, op4, itinD16,
1395                    OpcodeStr, !strconcat(Dt, "16"),
1396                    v4i16, v4i16, OpNode, Commutable>;
1397   def v2i32 : N3VD<op24, op23, 0b10, op11_8, op4, itinD32,
1398                    OpcodeStr, !strconcat(Dt, "32"),
1399                    v2i32, v2i32, OpNode, Commutable>;
1400
1401   // 128-bit vector types.
1402   def v16i8 : N3VQ<op24, op23, 0b00, op11_8, op4, itinQ16,
1403                    OpcodeStr, !strconcat(Dt, "8"),
1404                    v16i8, v16i8, OpNode, Commutable>;
1405   def v8i16 : N3VQ<op24, op23, 0b01, op11_8, op4, itinQ16,
1406                    OpcodeStr, !strconcat(Dt, "16"),
1407                    v8i16, v8i16, OpNode, Commutable>;
1408   def v4i32 : N3VQ<op24, op23, 0b10, op11_8, op4, itinQ32,
1409                    OpcodeStr, !strconcat(Dt, "32"),
1410                    v4i32, v4i32, OpNode, Commutable>;
1411 }
1412
1413 multiclass N3VSL_HS<bits<4> op11_8, string OpcodeStr, string Dt, SDNode ShOp> {
1414   def v4i16 : N3VDSL16<0b01, op11_8, OpcodeStr, !strconcat(Dt, "16"),
1415                        v4i16, ShOp>;
1416   def v2i32 : N3VDSL<0b10, op11_8, IIC_VMULi32D, OpcodeStr, !strconcat(Dt,"32"),
1417                      v2i32, ShOp>;
1418   def v8i16 : N3VQSL16<0b01, op11_8, OpcodeStr, !strconcat(Dt, "16"),
1419                        v8i16, v4i16, ShOp>;
1420   def v4i32 : N3VQSL<0b10, op11_8, IIC_VMULi32Q, OpcodeStr, !strconcat(Dt,"32"),
1421                      v4i32, v2i32, ShOp>;
1422 }
1423
1424 // ....then also with element size 64 bits:
1425 multiclass N3V_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1426                     InstrItinClass itinD, InstrItinClass itinQ,
1427                     string OpcodeStr, string Dt,
1428                     SDNode OpNode, bit Commutable = 0>
1429   : N3V_QHS<op24, op23, op11_8, op4, itinD, itinD, itinQ, itinQ,
1430             OpcodeStr, Dt, OpNode, Commutable> {
1431   def v1i64 : N3VD<op24, op23, 0b11, op11_8, op4, itinD,
1432                    OpcodeStr, !strconcat(Dt, "64"),
1433                    v1i64, v1i64, OpNode, Commutable>;
1434   def v2i64 : N3VQ<op24, op23, 0b11, op11_8, op4, itinQ,
1435                    OpcodeStr, !strconcat(Dt, "64"),
1436                    v2i64, v2i64, OpNode, Commutable>;
1437 }
1438
1439
1440 // Neon Narrowing 2-register vector intrinsics,
1441 //   source operand element sizes of 16, 32 and 64 bits:
1442 multiclass N2VNInt_HSD<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1443                        bits<5> op11_7, bit op6, bit op4,
1444                        InstrItinClass itin, string OpcodeStr, string Dt,
1445                        Intrinsic IntOp> {
1446   def v8i8  : N2VNInt<op24_23, op21_20, 0b00, op17_16, op11_7, op6, op4,
1447                       itin, OpcodeStr, !strconcat(Dt, "16"),
1448                       v8i8, v8i16, IntOp>;
1449   def v4i16 : N2VNInt<op24_23, op21_20, 0b01, op17_16, op11_7, op6, op4,
1450                       itin, OpcodeStr, !strconcat(Dt, "32"),
1451                       v4i16, v4i32, IntOp>;
1452   def v2i32 : N2VNInt<op24_23, op21_20, 0b10, op17_16, op11_7, op6, op4,
1453                       itin, OpcodeStr, !strconcat(Dt, "64"),
1454                       v2i32, v2i64, IntOp>;
1455 }
1456
1457
1458 // Neon Lengthening 2-register vector intrinsic (currently specific to VMOVL).
1459 //   source operand element sizes of 16, 32 and 64 bits:
1460 multiclass N2VLInt_QHS<bits<2> op24_23, bits<5> op11_7, bit op6, bit op4,
1461                        string OpcodeStr, string Dt, Intrinsic IntOp> {
1462   def v8i16 : N2VLInt<op24_23, 0b00, 0b10, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1463                       OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, IntOp>;
1464   def v4i32 : N2VLInt<op24_23, 0b01, 0b00, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1465                       OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1466   def v2i64 : N2VLInt<op24_23, 0b10, 0b00, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1467                       OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1468 }
1469
1470
1471 // Neon 3-register vector intrinsics.
1472
1473 // First with only element sizes of 16 and 32 bits:
1474 multiclass N3VInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1475                      InstrItinClass itinD16, InstrItinClass itinD32,
1476                      InstrItinClass itinQ16, InstrItinClass itinQ32,
1477                      string OpcodeStr, string Dt,
1478                      Intrinsic IntOp, bit Commutable = 0> {
1479   // 64-bit vector types.
1480   def v4i16 : N3VDInt<op24, op23, 0b01, op11_8, op4, itinD16,
1481                       OpcodeStr, !strconcat(Dt, "16"),
1482                       v4i16, v4i16, IntOp, Commutable>;
1483   def v2i32 : N3VDInt<op24, op23, 0b10, op11_8, op4, itinD32,
1484                       OpcodeStr, !strconcat(Dt, "32"),
1485                       v2i32, v2i32, IntOp, Commutable>;
1486
1487   // 128-bit vector types.
1488   def v8i16 : N3VQInt<op24, op23, 0b01, op11_8, op4, itinQ16,
1489                       OpcodeStr, !strconcat(Dt, "16"),
1490                       v8i16, v8i16, IntOp, Commutable>;
1491   def v4i32 : N3VQInt<op24, op23, 0b10, op11_8, op4, itinQ32,
1492                       OpcodeStr, !strconcat(Dt, "32"),
1493                       v4i32, v4i32, IntOp, Commutable>;
1494 }
1495
1496 multiclass N3VIntSL_HS<bits<4> op11_8,
1497                        InstrItinClass itinD16, InstrItinClass itinD32,
1498                        InstrItinClass itinQ16, InstrItinClass itinQ32,
1499                        string OpcodeStr, string Dt, Intrinsic IntOp> {
1500   def v4i16 : N3VDIntSL16<0b01, op11_8, itinD16,
1501                           OpcodeStr, !strconcat(Dt, "16"), v4i16, IntOp>;
1502   def v2i32 : N3VDIntSL<0b10, op11_8, itinD32,
1503                         OpcodeStr, !strconcat(Dt, "32"), v2i32, IntOp>;
1504   def v8i16 : N3VQIntSL16<0b01, op11_8, itinQ16,
1505                           OpcodeStr, !strconcat(Dt, "16"), v8i16, v4i16, IntOp>;
1506   def v4i32 : N3VQIntSL<0b10, op11_8, itinQ32,
1507                         OpcodeStr, !strconcat(Dt, "32"), v4i32, v2i32, IntOp>;
1508 }
1509
1510 // ....then also with element size of 8 bits:
1511 multiclass N3VInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1512                       InstrItinClass itinD16, InstrItinClass itinD32,
1513                       InstrItinClass itinQ16, InstrItinClass itinQ32,
1514                       string OpcodeStr, string Dt,
1515                       Intrinsic IntOp, bit Commutable = 0>
1516   : N3VInt_HS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1517               OpcodeStr, Dt, IntOp, Commutable> {
1518   def v8i8  : N3VDInt<op24, op23, 0b00, op11_8, op4, itinD16,
1519                       OpcodeStr, !strconcat(Dt, "8"),
1520                       v8i8, v8i8, IntOp, Commutable>;
1521   def v16i8 : N3VQInt<op24, op23, 0b00, op11_8, op4, itinQ16,
1522                       OpcodeStr, !strconcat(Dt, "8"),
1523                       v16i8, v16i8, IntOp, Commutable>;
1524 }
1525
1526 // ....then also with element size of 64 bits:
1527 multiclass N3VInt_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1528                        InstrItinClass itinD16, InstrItinClass itinD32,
1529                        InstrItinClass itinQ16, InstrItinClass itinQ32,
1530                        string OpcodeStr, string Dt,
1531                        Intrinsic IntOp, bit Commutable = 0>
1532   : N3VInt_QHS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1533                OpcodeStr, Dt, IntOp, Commutable> {
1534   def v1i64 : N3VDInt<op24, op23, 0b11, op11_8, op4, itinD32,
1535                       OpcodeStr, !strconcat(Dt, "64"),
1536                       v1i64, v1i64, IntOp, Commutable>;
1537   def v2i64 : N3VQInt<op24, op23, 0b11, op11_8, op4, itinQ32,
1538                       OpcodeStr, !strconcat(Dt, "64"),
1539                       v2i64, v2i64, IntOp, Commutable>;
1540 }
1541
1542
1543 // Neon Narrowing 3-register vector intrinsics,
1544 //   source operand element sizes of 16, 32 and 64 bits:
1545 multiclass N3VNInt_HSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1546                        string OpcodeStr, string Dt,
1547                        Intrinsic IntOp, bit Commutable = 0> {
1548   def v8i8  : N3VNInt<op24, op23, 0b00, op11_8, op4,
1549                       OpcodeStr, !strconcat(Dt, "16"),
1550                       v8i8, v8i16, IntOp, Commutable>;
1551   def v4i16 : N3VNInt<op24, op23, 0b01, op11_8, op4,
1552                       OpcodeStr, !strconcat(Dt, "32"),
1553                       v4i16, v4i32, IntOp, Commutable>;
1554   def v2i32 : N3VNInt<op24, op23, 0b10, op11_8, op4,
1555                       OpcodeStr, !strconcat(Dt, "64"),
1556                       v2i32, v2i64, IntOp, Commutable>;
1557 }
1558
1559
1560 // Neon Long 3-register vector intrinsics.
1561
1562 // First with only element sizes of 16 and 32 bits:
1563 multiclass N3VLInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1564                       InstrItinClass itin, string OpcodeStr, string Dt,
1565                       Intrinsic IntOp, bit Commutable = 0> {
1566   def v4i32 : N3VLInt<op24, op23, 0b01, op11_8, op4, itin,
1567                       OpcodeStr, !strconcat(Dt, "16"),
1568                       v4i32, v4i16, IntOp, Commutable>;
1569   def v2i64 : N3VLInt<op24, op23, 0b10, op11_8, op4, itin,
1570                       OpcodeStr, !strconcat(Dt, "32"),
1571                       v2i64, v2i32, IntOp, Commutable>;
1572 }
1573
1574 multiclass N3VLIntSL_HS<bit op24, bits<4> op11_8,
1575                         InstrItinClass itin, string OpcodeStr, string Dt,
1576                         Intrinsic IntOp> {
1577   def v4i16 : N3VLIntSL16<op24, 0b01, op11_8, itin,
1578                           OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1579   def v2i32 : N3VLIntSL<op24, 0b10, op11_8, itin,
1580                         OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1581 }
1582
1583 // ....then also with element size of 8 bits:
1584 multiclass N3VLInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1585                        InstrItinClass itin, string OpcodeStr, string Dt,
1586                        Intrinsic IntOp, bit Commutable = 0>
1587   : N3VLInt_HS<op24, op23, op11_8, op4, itin, OpcodeStr, Dt,
1588                IntOp, Commutable> {
1589   def v8i16 : N3VLInt<op24, op23, 0b00, op11_8, op4, itin,
1590                       OpcodeStr, !strconcat(Dt, "8"),
1591                       v8i16, v8i8, IntOp, Commutable>;
1592 }
1593
1594
1595 // Neon Wide 3-register vector intrinsics,
1596 //   source operand element sizes of 8, 16 and 32 bits:
1597 multiclass N3VWInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1598                        string OpcodeStr, string Dt,
1599                        Intrinsic IntOp, bit Commutable = 0> {
1600   def v8i16 : N3VWInt<op24, op23, 0b00, op11_8, op4,
1601                       OpcodeStr, !strconcat(Dt, "8"),
1602                       v8i16, v8i8, IntOp, Commutable>;
1603   def v4i32 : N3VWInt<op24, op23, 0b01, op11_8, op4,
1604                       OpcodeStr, !strconcat(Dt, "16"),
1605                       v4i32, v4i16, IntOp, Commutable>;
1606   def v2i64 : N3VWInt<op24, op23, 0b10, op11_8, op4,
1607                       OpcodeStr, !strconcat(Dt, "32"),
1608                       v2i64, v2i32, IntOp, Commutable>;
1609 }
1610
1611
1612 // Neon Multiply-Op vector operations,
1613 //   element sizes of 8, 16 and 32 bits:
1614 multiclass N3VMulOp_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1615                         InstrItinClass itinD16, InstrItinClass itinD32,
1616                         InstrItinClass itinQ16, InstrItinClass itinQ32,
1617                         string OpcodeStr, string Dt, SDNode OpNode> {
1618   // 64-bit vector types.
1619   def v8i8  : N3VDMulOp<op24, op23, 0b00, op11_8, op4, itinD16,
1620                         OpcodeStr, !strconcat(Dt, "8"), v8i8, mul, OpNode>;
1621   def v4i16 : N3VDMulOp<op24, op23, 0b01, op11_8, op4, itinD16,
1622                         OpcodeStr, !strconcat(Dt, "16"), v4i16, mul, OpNode>;
1623   def v2i32 : N3VDMulOp<op24, op23, 0b10, op11_8, op4, itinD32,
1624                         OpcodeStr, !strconcat(Dt, "32"), v2i32, mul, OpNode>;
1625
1626   // 128-bit vector types.
1627   def v16i8 : N3VQMulOp<op24, op23, 0b00, op11_8, op4, itinQ16,
1628                         OpcodeStr, !strconcat(Dt, "8"), v16i8, mul, OpNode>;
1629   def v8i16 : N3VQMulOp<op24, op23, 0b01, op11_8, op4, itinQ16,
1630                         OpcodeStr, !strconcat(Dt, "16"), v8i16, mul, OpNode>;
1631   def v4i32 : N3VQMulOp<op24, op23, 0b10, op11_8, op4, itinQ32,
1632                         OpcodeStr, !strconcat(Dt, "32"), v4i32, mul, OpNode>;
1633 }
1634
1635 multiclass N3VMulOpSL_HS<bits<4> op11_8,
1636                          InstrItinClass itinD16, InstrItinClass itinD32,
1637                          InstrItinClass itinQ16, InstrItinClass itinQ32,
1638                          string OpcodeStr, string Dt, SDNode ShOp> {
1639   def v4i16 : N3VDMulOpSL16<0b01, op11_8, itinD16,
1640                             OpcodeStr, !strconcat(Dt, "16"), v4i16, mul, ShOp>;
1641   def v2i32 : N3VDMulOpSL<0b10, op11_8, itinD32,
1642                           OpcodeStr, !strconcat(Dt, "32"), v2i32, mul, ShOp>;
1643   def v8i16 : N3VQMulOpSL16<0b01, op11_8, itinQ16,
1644                             OpcodeStr, !strconcat(Dt, "16"), v8i16, v4i16,
1645                             mul, ShOp>;
1646   def v4i32 : N3VQMulOpSL<0b10, op11_8, itinQ32,
1647                           OpcodeStr, !strconcat(Dt, "32"), v4i32, v2i32,
1648                           mul, ShOp>;
1649 }
1650
1651 // Neon 3-argument intrinsics,
1652 //   element sizes of 8, 16 and 32 bits:
1653 multiclass N3VInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1654                        string OpcodeStr, string Dt, Intrinsic IntOp> {
1655   // 64-bit vector types.
1656   def v8i8  : N3VDInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16D,
1657                        OpcodeStr, !strconcat(Dt, "8"), v8i8, v8i8, IntOp>;
1658   def v4i16 : N3VDInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1659                        OpcodeStr, !strconcat(Dt, "16"), v4i16, v4i16, IntOp>;
1660   def v2i32 : N3VDInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32D,
1661                        OpcodeStr, !strconcat(Dt, "32"), v2i32, v2i32, IntOp>;
1662
1663   // 128-bit vector types.
1664   def v16i8 : N3VQInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16Q,
1665                        OpcodeStr, !strconcat(Dt, "8"), v16i8, v16i8, IntOp>;
1666   def v8i16 : N3VQInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16Q,
1667                        OpcodeStr, !strconcat(Dt, "16"), v8i16, v8i16, IntOp>;
1668   def v4i32 : N3VQInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32Q,
1669                        OpcodeStr, !strconcat(Dt, "32"), v4i32, v4i32, IntOp>;
1670 }
1671
1672
1673 // Neon Long 3-argument intrinsics.
1674
1675 // First with only element sizes of 16 and 32 bits:
1676 multiclass N3VLInt3_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1677                        string OpcodeStr, string Dt, Intrinsic IntOp> {
1678   def v4i32 : N3VLInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1679                        OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1680   def v2i64 : N3VLInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi16D,
1681                        OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1682 }
1683
1684 multiclass N3VLInt3SL_HS<bit op24, bits<4> op11_8,
1685                          string OpcodeStr, string Dt, Intrinsic IntOp> {
1686   def v4i16 : N3VLInt3SL16<op24, 0b01, op11_8, IIC_VMACi16D,
1687                            OpcodeStr, !strconcat(Dt,"16"), v4i32, v4i16, IntOp>;
1688   def v2i32 : N3VLInt3SL<op24, 0b10, op11_8, IIC_VMACi32D,
1689                          OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1690 }
1691
1692 // ....then also with element size of 8 bits:
1693 multiclass N3VLInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1694                         string OpcodeStr, string Dt, Intrinsic IntOp>
1695   : N3VLInt3_HS<op24, op23, op11_8, op4, OpcodeStr, Dt, IntOp> {
1696   def v8i16 : N3VLInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16D,
1697                        OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, IntOp>;
1698 }
1699
1700
1701 // Neon 2-register vector intrinsics,
1702 //   element sizes of 8, 16 and 32 bits:
1703 multiclass N2VInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1704                       bits<5> op11_7, bit op4,
1705                       InstrItinClass itinD, InstrItinClass itinQ,
1706                       string OpcodeStr, string Dt, Intrinsic IntOp> {
1707   // 64-bit vector types.
1708   def v8i8  : N2VDInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1709                       itinD, OpcodeStr, !strconcat(Dt, "8"), v8i8, v8i8, IntOp>;
1710   def v4i16 : N2VDInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1711                       itinD, OpcodeStr, !strconcat(Dt, "16"),v4i16,v4i16,IntOp>;
1712   def v2i32 : N2VDInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1713                       itinD, OpcodeStr, !strconcat(Dt, "32"),v2i32,v2i32,IntOp>;
1714
1715   // 128-bit vector types.
1716   def v16i8 : N2VQInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1717                       itinQ, OpcodeStr, !strconcat(Dt, "8"), v16i8,v16i8,IntOp>;
1718   def v8i16 : N2VQInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1719                       itinQ, OpcodeStr, !strconcat(Dt, "16"),v8i16,v8i16,IntOp>;
1720   def v4i32 : N2VQInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1721                       itinQ, OpcodeStr, !strconcat(Dt, "32"),v4i32,v4i32,IntOp>;
1722 }
1723
1724
1725 // Neon Pairwise long 2-register intrinsics,
1726 //   element sizes of 8, 16 and 32 bits:
1727 multiclass N2VPLInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1728                         bits<5> op11_7, bit op4,
1729                         string OpcodeStr, string Dt, Intrinsic IntOp> {
1730   // 64-bit vector types.
1731   def v8i8  : N2VDPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1732                         OpcodeStr, !strconcat(Dt, "8"), v4i16, v8i8, IntOp>;
1733   def v4i16 : N2VDPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1734                         OpcodeStr, !strconcat(Dt, "16"), v2i32, v4i16, IntOp>;
1735   def v2i32 : N2VDPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1736                         OpcodeStr, !strconcat(Dt, "32"), v1i64, v2i32, IntOp>;
1737
1738   // 128-bit vector types.
1739   def v16i8 : N2VQPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1740                         OpcodeStr, !strconcat(Dt, "8"), v8i16, v16i8, IntOp>;
1741   def v8i16 : N2VQPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1742                         OpcodeStr, !strconcat(Dt, "16"), v4i32, v8i16, IntOp>;
1743   def v4i32 : N2VQPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1744                         OpcodeStr, !strconcat(Dt, "32"), v2i64, v4i32, IntOp>;
1745 }
1746
1747
1748 // Neon Pairwise long 2-register accumulate intrinsics,
1749 //   element sizes of 8, 16 and 32 bits:
1750 multiclass N2VPLInt2_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1751                          bits<5> op11_7, bit op4,
1752                          string OpcodeStr, string Dt, Intrinsic IntOp> {
1753   // 64-bit vector types.
1754   def v8i8  : N2VDPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1755                          OpcodeStr, !strconcat(Dt, "8"), v4i16, v8i8, IntOp>;
1756   def v4i16 : N2VDPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1757                          OpcodeStr, !strconcat(Dt, "16"), v2i32, v4i16, IntOp>;
1758   def v2i32 : N2VDPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1759                          OpcodeStr, !strconcat(Dt, "32"), v1i64, v2i32, IntOp>;
1760
1761   // 128-bit vector types.
1762   def v16i8 : N2VQPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1763                          OpcodeStr, !strconcat(Dt, "8"), v8i16, v16i8, IntOp>;
1764   def v8i16 : N2VQPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1765                          OpcodeStr, !strconcat(Dt, "16"), v4i32, v8i16, IntOp>;
1766   def v4i32 : N2VQPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1767                          OpcodeStr, !strconcat(Dt, "32"), v2i64, v4i32, IntOp>;
1768 }
1769
1770
1771 // Neon 2-register vector shift by immediate,
1772 //   element sizes of 8, 16, 32 and 64 bits:
1773 multiclass N2VSh_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1774                       InstrItinClass itin, string OpcodeStr, string Dt,
1775                       SDNode OpNode> {
1776   // 64-bit vector types.
1777   def v8i8  : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1778                      OpcodeStr, !strconcat(Dt, "8"), v8i8, OpNode> {
1779     let Inst{21-19} = 0b001; // imm6 = 001xxx
1780   }
1781   def v4i16 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1782                      OpcodeStr, !strconcat(Dt, "16"), v4i16, OpNode> {
1783     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1784   }
1785   def v2i32 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1786                      OpcodeStr, !strconcat(Dt, "32"), v2i32, OpNode> {
1787     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1788   }
1789   def v1i64 : N2VDSh<op24, op23, op11_8, 1, op4, itin,
1790                      OpcodeStr, !strconcat(Dt, "64"), v1i64, OpNode>;
1791                              // imm6 = xxxxxx
1792
1793   // 128-bit vector types.
1794   def v16i8 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1795                      OpcodeStr, !strconcat(Dt, "8"), v16i8, OpNode> {
1796     let Inst{21-19} = 0b001; // imm6 = 001xxx
1797   }
1798   def v8i16 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1799                      OpcodeStr, !strconcat(Dt, "16"), v8i16, OpNode> {
1800     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1801   }
1802   def v4i32 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1803                      OpcodeStr, !strconcat(Dt, "32"), v4i32, OpNode> {
1804     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1805   }
1806   def v2i64 : N2VQSh<op24, op23, op11_8, 1, op4, itin,
1807                      OpcodeStr, !strconcat(Dt, "64"), v2i64, OpNode>;
1808                              // imm6 = xxxxxx
1809 }
1810
1811
1812 // Neon Shift-Accumulate vector operations,
1813 //   element sizes of 8, 16, 32 and 64 bits:
1814 multiclass N2VShAdd_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1815                          string OpcodeStr, string Dt, SDNode ShOp> {
1816   // 64-bit vector types.
1817   def v8i8  : N2VDShAdd<op24, op23, op11_8, 0, op4,
1818                         OpcodeStr, !strconcat(Dt, "8"), v8i8, ShOp> {
1819     let Inst{21-19} = 0b001; // imm6 = 001xxx
1820   }
1821   def v4i16 : N2VDShAdd<op24, op23, op11_8, 0, op4,
1822                         OpcodeStr, !strconcat(Dt, "16"), v4i16, ShOp> {
1823     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1824   }
1825   def v2i32 : N2VDShAdd<op24, op23, op11_8, 0, op4,
1826                         OpcodeStr, !strconcat(Dt, "32"), v2i32, ShOp> {
1827     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1828   }
1829   def v1i64 : N2VDShAdd<op24, op23, op11_8, 1, op4,
1830                         OpcodeStr, !strconcat(Dt, "64"), v1i64, ShOp>;
1831                              // imm6 = xxxxxx
1832
1833   // 128-bit vector types.
1834   def v16i8 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1835                         OpcodeStr, !strconcat(Dt, "8"), v16i8, ShOp> {
1836     let Inst{21-19} = 0b001; // imm6 = 001xxx
1837   }
1838   def v8i16 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1839                         OpcodeStr, !strconcat(Dt, "16"), v8i16, ShOp> {
1840     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1841   }
1842   def v4i32 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1843                         OpcodeStr, !strconcat(Dt, "32"), v4i32, ShOp> {
1844     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1845   }
1846   def v2i64 : N2VQShAdd<op24, op23, op11_8, 1, op4,
1847                         OpcodeStr, !strconcat(Dt, "64"), v2i64, ShOp>;
1848                              // imm6 = xxxxxx
1849 }
1850
1851
1852 // Neon Shift-Insert vector operations,
1853 //   element sizes of 8, 16, 32 and 64 bits:
1854 multiclass N2VShIns_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1855                          string OpcodeStr, SDNode ShOp> {
1856   // 64-bit vector types.
1857   def v8i8  : N2VDShIns<op24, op23, op11_8, 0, op4,
1858                         OpcodeStr, "8", v8i8, ShOp> {
1859     let Inst{21-19} = 0b001; // imm6 = 001xxx
1860   }
1861   def v4i16 : N2VDShIns<op24, op23, op11_8, 0, op4,
1862                         OpcodeStr, "16", v4i16, ShOp> {
1863     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1864   }
1865   def v2i32 : N2VDShIns<op24, op23, op11_8, 0, op4,
1866                         OpcodeStr, "32", v2i32, ShOp> {
1867     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1868   }
1869   def v1i64 : N2VDShIns<op24, op23, op11_8, 1, op4,
1870                         OpcodeStr, "64", v1i64, ShOp>;
1871                              // imm6 = xxxxxx
1872
1873   // 128-bit vector types.
1874   def v16i8 : N2VQShIns<op24, op23, op11_8, 0, op4,
1875                         OpcodeStr, "8", v16i8, ShOp> {
1876     let Inst{21-19} = 0b001; // imm6 = 001xxx
1877   }
1878   def v8i16 : N2VQShIns<op24, op23, op11_8, 0, op4,
1879                         OpcodeStr, "16", v8i16, ShOp> {
1880     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1881   }
1882   def v4i32 : N2VQShIns<op24, op23, op11_8, 0, op4,
1883                         OpcodeStr, "32", v4i32, ShOp> {
1884     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1885   }
1886   def v2i64 : N2VQShIns<op24, op23, op11_8, 1, op4,
1887                         OpcodeStr, "64", v2i64, ShOp>;
1888                              // imm6 = xxxxxx
1889 }
1890
1891 // Neon Shift Long operations,
1892 //   element sizes of 8, 16, 32 bits:
1893 multiclass N2VLSh_QHS<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6,
1894                       bit op4, string OpcodeStr, string Dt, SDNode OpNode> {
1895   def v8i16 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
1896                  OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, OpNode> {
1897     let Inst{21-19} = 0b001; // imm6 = 001xxx
1898   }
1899   def v4i32 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
1900                   OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, OpNode> {
1901     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1902   }
1903   def v2i64 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
1904                   OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, OpNode> {
1905     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1906   }
1907 }
1908
1909 // Neon Shift Narrow operations,
1910 //   element sizes of 16, 32, 64 bits:
1911 multiclass N2VNSh_HSD<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6,
1912                       bit op4, InstrItinClass itin, string OpcodeStr, string Dt,
1913                       SDNode OpNode> {
1914   def v8i8 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
1915                     OpcodeStr, !strconcat(Dt, "16"), v8i8, v8i16, OpNode> {
1916     let Inst{21-19} = 0b001; // imm6 = 001xxx
1917   }
1918   def v4i16 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
1919                      OpcodeStr, !strconcat(Dt, "32"), v4i16, v4i32, OpNode> {
1920     let Inst{21-20} = 0b01;  // imm6 = 01xxxx
1921   }
1922   def v2i32 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
1923                      OpcodeStr, !strconcat(Dt, "64"), v2i32, v2i64, OpNode> {
1924     let Inst{21} = 0b1;      // imm6 = 1xxxxx
1925   }
1926 }
1927
1928 //===----------------------------------------------------------------------===//
1929 // Instruction Definitions.
1930 //===----------------------------------------------------------------------===//
1931
1932 // Vector Add Operations.
1933
1934 //   VADD     : Vector Add (integer and floating-point)
1935 defm VADD     : N3V_QHSD<0, 0, 0b1000, 0, IIC_VBINiD, IIC_VBINiQ, "vadd", "i",
1936                          add, 1>;
1937 def  VADDfd   : N3VD<0, 0, 0b00, 0b1101, 0, IIC_VBIND, "vadd", "f32",
1938                      v2f32, v2f32, fadd, 1>;
1939 def  VADDfq   : N3VQ<0, 0, 0b00, 0b1101, 0, IIC_VBINQ, "vadd", "f32",
1940                      v4f32, v4f32, fadd, 1>;
1941 //   VADDL    : Vector Add Long (Q = D + D)
1942 defm VADDLs   : N3VLInt_QHS<0,1,0b0000,0, IIC_VSHLiD, "vaddl", "s",
1943                             int_arm_neon_vaddls, 1>;
1944 defm VADDLu   : N3VLInt_QHS<1,1,0b0000,0, IIC_VSHLiD, "vaddl", "u",
1945                             int_arm_neon_vaddlu, 1>;
1946 //   VADDW    : Vector Add Wide (Q = Q + D)
1947 defm VADDWs   : N3VWInt_QHS<0,1,0b0001,0, "vaddw", "s", int_arm_neon_vaddws, 0>;
1948 defm VADDWu   : N3VWInt_QHS<1,1,0b0001,0, "vaddw", "u", int_arm_neon_vaddwu, 0>;
1949 //   VHADD    : Vector Halving Add
1950 defm VHADDs   : N3VInt_QHS<0,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1951                            IIC_VBINi4Q, "vhadd", "s", int_arm_neon_vhadds, 1>;
1952 defm VHADDu   : N3VInt_QHS<1,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1953                            IIC_VBINi4Q, "vhadd", "u", int_arm_neon_vhaddu, 1>;
1954 //   VRHADD   : Vector Rounding Halving Add
1955 defm VRHADDs  : N3VInt_QHS<0,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1956                            IIC_VBINi4Q, "vrhadd", "s", int_arm_neon_vrhadds, 1>;
1957 defm VRHADDu  : N3VInt_QHS<1,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1958                            IIC_VBINi4Q, "vrhadd", "u", int_arm_neon_vrhaddu, 1>;
1959 //   VQADD    : Vector Saturating Add
1960 defm VQADDs   : N3VInt_QHSD<0,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1961                             IIC_VBINi4Q, "vqadd", "s", int_arm_neon_vqadds, 1>;
1962 defm VQADDu   : N3VInt_QHSD<1,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1963                             IIC_VBINi4Q, "vqadd", "u", int_arm_neon_vqaddu, 1>;
1964 //   VADDHN   : Vector Add and Narrow Returning High Half (D = Q + Q)
1965 defm VADDHN   : N3VNInt_HSD<0,1,0b0100,0, "vaddhn", "i",
1966                             int_arm_neon_vaddhn, 1>;
1967 //   VRADDHN  : Vector Rounding Add and Narrow Returning High Half (D = Q + Q)
1968 defm VRADDHN  : N3VNInt_HSD<1,1,0b0100,0, "vraddhn", "i",
1969                             int_arm_neon_vraddhn, 1>;
1970
1971 // Vector Multiply Operations.
1972
1973 //   VMUL     : Vector Multiply (integer, polynomial and floating-point)
1974 defm VMUL     : N3V_QHS<0, 0, 0b1001, 1, IIC_VMULi16D, IIC_VMULi32D,
1975                         IIC_VMULi16Q, IIC_VMULi32Q, "vmul", "i", mul, 1>;
1976 def  VMULpd   : N3VDInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16D, "vmul", "p8",
1977                         v8i8, v8i8, int_arm_neon_vmulp, 1>;
1978 def  VMULpq   : N3VQInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16Q, "vmul", "p8",
1979                         v16i8, v16i8, int_arm_neon_vmulp, 1>;
1980 def  VMULfd   : N3VD<1, 0, 0b00, 0b1101, 1, IIC_VBIND, "vmul", "f32",
1981                      v2f32, v2f32, fmul, 1>;
1982 def  VMULfq   : N3VQ<1, 0, 0b00, 0b1101, 1, IIC_VBINQ, "vmul", "f32",
1983                      v4f32, v4f32, fmul, 1>;
1984 defm VMULsl   : N3VSL_HS<0b1000, "vmul", "i", mul>;
1985 def  VMULslfd : N3VDSL<0b10, 0b1001, IIC_VBIND, "vmul", "f32", v2f32, fmul>;
1986 def  VMULslfq : N3VQSL<0b10, 0b1001, IIC_VBINQ, "vmul", "f32", v4f32,
1987                        v2f32, fmul>;
1988
1989 def : Pat<(v8i16 (mul (v8i16 QPR:$src1),
1990                       (v8i16 (NEONvduplane (v8i16 QPR:$src2), imm:$lane)))),
1991           (v8i16 (VMULslv8i16 (v8i16 QPR:$src1),
1992                               (v4i16 (EXTRACT_SUBREG QPR:$src2,
1993                                       (DSubReg_i16_reg imm:$lane))),
1994                               (SubReg_i16_lane imm:$lane)))>;
1995 def : Pat<(v4i32 (mul (v4i32 QPR:$src1),
1996                       (v4i32 (NEONvduplane (v4i32 QPR:$src2), imm:$lane)))),
1997           (v4i32 (VMULslv4i32 (v4i32 QPR:$src1),
1998                               (v2i32 (EXTRACT_SUBREG QPR:$src2,
1999                                       (DSubReg_i32_reg imm:$lane))),
2000                               (SubReg_i32_lane imm:$lane)))>;
2001 def : Pat<(v4f32 (fmul (v4f32 QPR:$src1),
2002                        (v4f32 (NEONvduplane (v4f32 QPR:$src2), imm:$lane)))),
2003           (v4f32 (VMULslfq (v4f32 QPR:$src1),
2004                            (v2f32 (EXTRACT_SUBREG QPR:$src2,
2005                                    (DSubReg_i32_reg imm:$lane))),
2006                            (SubReg_i32_lane imm:$lane)))>;
2007
2008 //   VQDMULH  : Vector Saturating Doubling Multiply Returning High Half
2009 defm VQDMULH  : N3VInt_HS<0, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
2010                           IIC_VMULi16Q, IIC_VMULi32Q,
2011                           "vqdmulh", "s", int_arm_neon_vqdmulh, 1>;
2012 defm VQDMULHsl: N3VIntSL_HS<0b1100, IIC_VMULi16D, IIC_VMULi32D,
2013                             IIC_VMULi16Q, IIC_VMULi32Q,
2014                             "vqdmulh", "s",  int_arm_neon_vqdmulh>;
2015 def : Pat<(v8i16 (int_arm_neon_vqdmulh (v8i16 QPR:$src1),
2016                                        (v8i16 (NEONvduplane (v8i16 QPR:$src2),
2017                                                             imm:$lane)))),
2018           (v8i16 (VQDMULHslv8i16 (v8i16 QPR:$src1),
2019                                  (v4i16 (EXTRACT_SUBREG QPR:$src2,
2020                                          (DSubReg_i16_reg imm:$lane))),
2021                                  (SubReg_i16_lane imm:$lane)))>;
2022 def : Pat<(v4i32 (int_arm_neon_vqdmulh (v4i32 QPR:$src1),
2023                                        (v4i32 (NEONvduplane (v4i32 QPR:$src2),
2024                                                             imm:$lane)))),
2025           (v4i32 (VQDMULHslv4i32 (v4i32 QPR:$src1),
2026                                  (v2i32 (EXTRACT_SUBREG QPR:$src2,
2027                                          (DSubReg_i32_reg imm:$lane))),
2028                                  (SubReg_i32_lane imm:$lane)))>;
2029
2030 //   VQRDMULH : Vector Rounding Saturating Doubling Multiply Returning High Half
2031 defm VQRDMULH   : N3VInt_HS<1, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
2032                             IIC_VMULi16Q, IIC_VMULi32Q,
2033                             "vqrdmulh", "s", int_arm_neon_vqrdmulh, 1>;
2034 defm VQRDMULHsl : N3VIntSL_HS<0b1101, IIC_VMULi16D, IIC_VMULi32D,
2035                               IIC_VMULi16Q, IIC_VMULi32Q,
2036                               "vqrdmulh", "s",  int_arm_neon_vqrdmulh>;
2037 def : Pat<(v8i16 (int_arm_neon_vqrdmulh (v8i16 QPR:$src1),
2038                                         (v8i16 (NEONvduplane (v8i16 QPR:$src2),
2039                                                              imm:$lane)))),
2040           (v8i16 (VQRDMULHslv8i16 (v8i16 QPR:$src1),
2041                                   (v4i16 (EXTRACT_SUBREG QPR:$src2,
2042                                           (DSubReg_i16_reg imm:$lane))),
2043                                   (SubReg_i16_lane imm:$lane)))>;
2044 def : Pat<(v4i32 (int_arm_neon_vqrdmulh (v4i32 QPR:$src1),
2045                                         (v4i32 (NEONvduplane (v4i32 QPR:$src2),
2046                                                              imm:$lane)))),
2047           (v4i32 (VQRDMULHslv4i32 (v4i32 QPR:$src1),
2048                                   (v2i32 (EXTRACT_SUBREG QPR:$src2,
2049                                           (DSubReg_i32_reg imm:$lane))),
2050                                   (SubReg_i32_lane imm:$lane)))>;
2051
2052 //   VMULL    : Vector Multiply Long (integer and polynomial) (Q = D * D)
2053 defm VMULLs   : N3VLInt_QHS<0,1,0b1100,0, IIC_VMULi16D, "vmull", "s",
2054                             int_arm_neon_vmulls, 1>;
2055 defm VMULLu   : N3VLInt_QHS<1,1,0b1100,0, IIC_VMULi16D, "vmull", "u",
2056                             int_arm_neon_vmullu, 1>;
2057 def  VMULLp   : N3VLInt<0, 1, 0b00, 0b1110, 0, IIC_VMULi16D, "vmull", "p8",
2058                         v8i16, v8i8, int_arm_neon_vmullp, 1>;
2059 defm VMULLsls : N3VLIntSL_HS<0, 0b1010, IIC_VMULi16D, "vmull", "s",
2060                              int_arm_neon_vmulls>;
2061 defm VMULLslu : N3VLIntSL_HS<1, 0b1010, IIC_VMULi16D, "vmull", "u",
2062                              int_arm_neon_vmullu>;
2063
2064 //   VQDMULL  : Vector Saturating Doubling Multiply Long (Q = D * D)
2065 defm VQDMULL  : N3VLInt_HS<0,1,0b1101,0, IIC_VMULi16D, "vqdmull", "s",
2066                            int_arm_neon_vqdmull, 1>;
2067 defm VQDMULLsl: N3VLIntSL_HS<0, 0b1011, IIC_VMULi16D, "vqdmull", "s",
2068                              int_arm_neon_vqdmull>;
2069
2070 // Vector Multiply-Accumulate and Multiply-Subtract Operations.
2071
2072 //   VMLA     : Vector Multiply Accumulate (integer and floating-point)
2073 defm VMLA     : N3VMulOp_QHS<0, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
2074                              IIC_VMACi16Q, IIC_VMACi32Q, "vmla", "i", add>;
2075 def  VMLAfd   : N3VDMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACD, "vmla", "f32",
2076                           v2f32, fmul, fadd>;
2077 def  VMLAfq   : N3VQMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACQ, "vmla", "f32",
2078                           v4f32, fmul, fadd>;
2079 defm VMLAsl   : N3VMulOpSL_HS<0b0000, IIC_VMACi16D, IIC_VMACi32D,
2080                               IIC_VMACi16Q, IIC_VMACi32Q, "vmla", "i", add>;
2081 def  VMLAslfd : N3VDMulOpSL<0b10, 0b0001, IIC_VMACD, "vmla", "f32",
2082                             v2f32, fmul, fadd>;
2083 def  VMLAslfq : N3VQMulOpSL<0b10, 0b0001, IIC_VMACQ, "vmla", "f32",
2084                             v4f32, v2f32, fmul, fadd>;
2085
2086 def : Pat<(v8i16 (add (v8i16 QPR:$src1),
2087                   (mul (v8i16 QPR:$src2),
2088                        (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
2089           (v8i16 (VMLAslv8i16 (v8i16 QPR:$src1), (v8i16 QPR:$src2),
2090                               (v4i16 (EXTRACT_SUBREG QPR:$src3,
2091                                       (DSubReg_i16_reg imm:$lane))),
2092                               (SubReg_i16_lane imm:$lane)))>;
2093
2094 def : Pat<(v4i32 (add (v4i32 QPR:$src1),
2095                   (mul (v4i32 QPR:$src2),
2096                        (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
2097           (v4i32 (VMLAslv4i32 (v4i32 QPR:$src1), (v4i32 QPR:$src2),
2098                               (v2i32 (EXTRACT_SUBREG QPR:$src3,
2099                                       (DSubReg_i32_reg imm:$lane))),
2100                               (SubReg_i32_lane imm:$lane)))>;
2101
2102 def : Pat<(v4f32 (fadd (v4f32 QPR:$src1),
2103                   (fmul (v4f32 QPR:$src2),
2104                         (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
2105           (v4f32 (VMLAslfq (v4f32 QPR:$src1),
2106                            (v4f32 QPR:$src2),
2107                            (v2f32 (EXTRACT_SUBREG QPR:$src3,
2108                                    (DSubReg_i32_reg imm:$lane))),
2109                            (SubReg_i32_lane imm:$lane)))>;
2110
2111 //   VMLAL    : Vector Multiply Accumulate Long (Q += D * D)
2112 defm VMLALs   : N3VLInt3_QHS<0,1,0b1000,0, "vmlal", "s", int_arm_neon_vmlals>;
2113 defm VMLALu   : N3VLInt3_QHS<1,1,0b1000,0, "vmlal", "u", int_arm_neon_vmlalu>;
2114
2115 defm VMLALsls : N3VLInt3SL_HS<0, 0b0010, "vmlal", "s", int_arm_neon_vmlals>;
2116 defm VMLALslu : N3VLInt3SL_HS<1, 0b0010, "vmlal", "u", int_arm_neon_vmlalu>;
2117
2118 //   VQDMLAL  : Vector Saturating Doubling Multiply Accumulate Long (Q += D * D)
2119 defm VQDMLAL  : N3VLInt3_HS<0, 1, 0b1001, 0, "vqdmlal", "s",
2120                             int_arm_neon_vqdmlal>;
2121 defm VQDMLALsl: N3VLInt3SL_HS<0, 0b0011, "vqdmlal", "s", int_arm_neon_vqdmlal>;
2122
2123 //   VMLS     : Vector Multiply Subtract (integer and floating-point)
2124 defm VMLS     : N3VMulOp_QHS<1, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
2125                              IIC_VMACi16Q, IIC_VMACi32Q, "vmls", "i", sub>;
2126 def  VMLSfd   : N3VDMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACD, "vmls", "f32",
2127                           v2f32, fmul, fsub>;
2128 def  VMLSfq   : N3VQMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACQ, "vmls", "f32",
2129                           v4f32, fmul, fsub>;
2130 defm VMLSsl   : N3VMulOpSL_HS<0b0100, IIC_VMACi16D, IIC_VMACi32D,
2131                               IIC_VMACi16Q, IIC_VMACi32Q, "vmls", "i", sub>;
2132 def  VMLSslfd : N3VDMulOpSL<0b10, 0b0101, IIC_VMACD, "vmls", "f32",
2133                             v2f32, fmul, fsub>;
2134 def  VMLSslfq : N3VQMulOpSL<0b10, 0b0101, IIC_VMACQ, "vmls", "f32",
2135                             v4f32, v2f32, fmul, fsub>;
2136
2137 def : Pat<(v8i16 (sub (v8i16 QPR:$src1),
2138                   (mul (v8i16 QPR:$src2),
2139                        (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
2140           (v8i16 (VMLSslv8i16 (v8i16 QPR:$src1), (v8i16 QPR:$src2),
2141                               (v4i16 (EXTRACT_SUBREG QPR:$src3,
2142                                       (DSubReg_i16_reg imm:$lane))),
2143                               (SubReg_i16_lane imm:$lane)))>;
2144
2145 def : Pat<(v4i32 (sub (v4i32 QPR:$src1),
2146                   (mul (v4i32 QPR:$src2),
2147                      (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
2148           (v4i32 (VMLSslv4i32 (v4i32 QPR:$src1), (v4i32 QPR:$src2),
2149                               (v2i32 (EXTRACT_SUBREG QPR:$src3,
2150                                       (DSubReg_i32_reg imm:$lane))),
2151                               (SubReg_i32_lane imm:$lane)))>;
2152
2153 def : Pat<(v4f32 (fsub (v4f32 QPR:$src1),
2154                   (fmul (v4f32 QPR:$src2),
2155                         (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
2156           (v4f32 (VMLSslfq (v4f32 QPR:$src1), (v4f32 QPR:$src2),
2157                            (v2f32 (EXTRACT_SUBREG QPR:$src3,
2158                                    (DSubReg_i32_reg imm:$lane))),
2159                            (SubReg_i32_lane imm:$lane)))>;
2160
2161 //   VMLSL    : Vector Multiply Subtract Long (Q -= D * D)
2162 defm VMLSLs   : N3VLInt3_QHS<0,1,0b1010,0, "vmlsl", "s", int_arm_neon_vmlsls>;
2163 defm VMLSLu   : N3VLInt3_QHS<1,1,0b1010,0, "vmlsl", "u", int_arm_neon_vmlslu>;
2164
2165 defm VMLSLsls : N3VLInt3SL_HS<0, 0b0110, "vmlsl", "s", int_arm_neon_vmlsls>;
2166 defm VMLSLslu : N3VLInt3SL_HS<1, 0b0110, "vmlsl", "u", int_arm_neon_vmlslu>;
2167
2168 //   VQDMLSL  : Vector Saturating Doubling Multiply Subtract Long (Q -= D * D)
2169 defm VQDMLSL  : N3VLInt3_HS<0, 1, 0b1011, 0, "vqdmlsl", "s",
2170                             int_arm_neon_vqdmlsl>;
2171 defm VQDMLSLsl: N3VLInt3SL_HS<0, 0b111, "vqdmlsl", "s", int_arm_neon_vqdmlsl>;
2172
2173 // Vector Subtract Operations.
2174
2175 //   VSUB     : Vector Subtract (integer and floating-point)
2176 defm VSUB     : N3V_QHSD<1, 0, 0b1000, 0, IIC_VSUBiD, IIC_VSUBiQ,
2177                          "vsub", "i", sub, 0>;
2178 def  VSUBfd   : N3VD<0, 0, 0b10, 0b1101, 0, IIC_VBIND, "vsub", "f32",
2179                      v2f32, v2f32, fsub, 0>;
2180 def  VSUBfq   : N3VQ<0, 0, 0b10, 0b1101, 0, IIC_VBINQ, "vsub", "f32",
2181                      v4f32, v4f32, fsub, 0>;
2182 //   VSUBL    : Vector Subtract Long (Q = D - D)
2183 defm VSUBLs   : N3VLInt_QHS<0,1,0b0010,0, IIC_VSHLiD, "vsubl", "s",
2184                             int_arm_neon_vsubls, 1>;
2185 defm VSUBLu   : N3VLInt_QHS<1,1,0b0010,0, IIC_VSHLiD, "vsubl", "u",
2186                             int_arm_neon_vsublu, 1>;
2187 //   VSUBW    : Vector Subtract Wide (Q = Q - D)
2188 defm VSUBWs   : N3VWInt_QHS<0,1,0b0011,0, "vsubw", "s", int_arm_neon_vsubws, 0>;
2189 defm VSUBWu   : N3VWInt_QHS<1,1,0b0011,0, "vsubw", "u", int_arm_neon_vsubwu, 0>;
2190 //   VHSUB    : Vector Halving Subtract
2191 defm VHSUBs   : N3VInt_QHS<0, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D,
2192                            IIC_VBINi4Q, IIC_VBINi4Q,
2193                            "vhsub", "s", int_arm_neon_vhsubs, 0>;
2194 defm VHSUBu   : N3VInt_QHS<1, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D,
2195                            IIC_VBINi4Q, IIC_VBINi4Q,
2196                            "vhsub", "u", int_arm_neon_vhsubu, 0>;
2197 //   VQSUB    : Vector Saturing Subtract
2198 defm VQSUBs   : N3VInt_QHSD<0, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D,
2199                             IIC_VBINi4Q, IIC_VBINi4Q,
2200                             "vqsub", "s", int_arm_neon_vqsubs, 0>;
2201 defm VQSUBu   : N3VInt_QHSD<1, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D,
2202                             IIC_VBINi4Q, IIC_VBINi4Q,
2203                             "vqsub", "u", int_arm_neon_vqsubu, 0>;
2204 //   VSUBHN   : Vector Subtract and Narrow Returning High Half (D = Q - Q)
2205 defm VSUBHN   : N3VNInt_HSD<0,1,0b0110,0, "vsubhn", "i",
2206                             int_arm_neon_vsubhn, 0>;
2207 //   VRSUBHN  : Vector Rounding Subtract and Narrow Returning High Half (D=Q-Q)
2208 defm VRSUBHN  : N3VNInt_HSD<1,1,0b0110,0, "vrsubhn", "i",
2209                             int_arm_neon_vrsubhn, 0>;
2210
2211 // Vector Comparisons.
2212
2213 //   VCEQ     : Vector Compare Equal
2214 defm VCEQ     : N3V_QHS<1, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2215                         IIC_VBINi4Q, "vceq", "i", NEONvceq, 1>;
2216 def  VCEQfd   : N3VD<0,0,0b00,0b1110,0, IIC_VBIND, "vceq", "f32", v2i32, v2f32,
2217                      NEONvceq, 1>;
2218 def  VCEQfq   : N3VQ<0,0,0b00,0b1110,0, IIC_VBINQ, "vceq", "f32", v4i32, v4f32,
2219                      NEONvceq, 1>;
2220 // For disassembly only.
2221 defm VCEQz    : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00010, 0, "vceq", "i",
2222                            "$dst, $src, #0">;
2223
2224 //   VCGE     : Vector Compare Greater Than or Equal
2225 defm VCGEs    : N3V_QHS<0, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2226                         IIC_VBINi4Q, "vcge", "s", NEONvcge, 0>;
2227 defm VCGEu    : N3V_QHS<1, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2228                         IIC_VBINi4Q, "vcge", "u", NEONvcgeu, 0>;
2229 def  VCGEfd   : N3VD<1,0,0b00,0b1110,0, IIC_VBIND, "vcge", "f32",
2230                      v2i32, v2f32, NEONvcge, 0>;
2231 def  VCGEfq   : N3VQ<1,0,0b00,0b1110,0, IIC_VBINQ, "vcge", "f32", v4i32, v4f32,
2232                      NEONvcge, 0>;
2233 // For disassembly only.
2234 defm VCGEz    : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00001, 0, "vcge", "s",
2235                             "$dst, $src, #0">;
2236 // For disassembly only.
2237 defm VCLEz    : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00011, 0, "vcle", "s",
2238                             "$dst, $src, #0">;
2239
2240 //   VCGT     : Vector Compare Greater Than
2241 defm VCGTs    : N3V_QHS<0, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2242                         IIC_VBINi4Q, "vcgt", "s", NEONvcgt, 0>;
2243 defm VCGTu    : N3V_QHS<1, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2244                         IIC_VBINi4Q, "vcgt", "u", NEONvcgtu, 0>;
2245 def  VCGTfd   : N3VD<1,0,0b10,0b1110,0, IIC_VBIND, "vcgt", "f32", v2i32, v2f32,
2246                      NEONvcgt, 0>;
2247 def  VCGTfq   : N3VQ<1,0,0b10,0b1110,0, IIC_VBINQ, "vcgt", "f32", v4i32, v4f32,
2248                      NEONvcgt, 0>;
2249 // For disassembly only.
2250 defm VCGTz    : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00000, 0, "vcgt", "s",
2251                             "$dst, $src, #0">;
2252 // For disassembly only.
2253 defm VCLTz    : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00100, 0, "vclt", "s",
2254                             "$dst, $src, #0">;
2255
2256 //   VACGE    : Vector Absolute Compare Greater Than or Equal (aka VCAGE)
2257 def  VACGEd   : N3VDInt<1, 0, 0b00, 0b1110, 1, IIC_VBIND, "vacge", "f32",
2258                         v2i32, v2f32, int_arm_neon_vacged, 0>;
2259 def  VACGEq   : N3VQInt<1, 0, 0b00, 0b1110, 1, IIC_VBINQ, "vacge", "f32",
2260                         v4i32, v4f32, int_arm_neon_vacgeq, 0>;
2261 //   VACGT    : Vector Absolute Compare Greater Than (aka VCAGT)
2262 def  VACGTd   : N3VDInt<1, 0, 0b10, 0b1110, 1, IIC_VBIND, "vacgt", "f32",
2263                         v2i32, v2f32, int_arm_neon_vacgtd, 0>;
2264 def  VACGTq   : N3VQInt<1, 0, 0b10, 0b1110, 1, IIC_VBINQ, "vacgt", "f32",
2265                         v4i32, v4f32, int_arm_neon_vacgtq, 0>;
2266 //   VTST     : Vector Test Bits
2267 defm VTST     : N3V_QHS<0, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2268                         IIC_VBINi4Q, "vtst", "", NEONvtst, 1>;
2269
2270 // Vector Bitwise Operations.
2271
2272 //   VAND     : Vector Bitwise AND
2273 def  VANDd    : N3VDX<0, 0, 0b00, 0b0001, 1, IIC_VBINiD, "vand",
2274                       v2i32, v2i32, and, 1>;
2275 def  VANDq    : N3VQX<0, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "vand",
2276                       v4i32, v4i32, and, 1>;
2277
2278 //   VEOR     : Vector Bitwise Exclusive OR
2279 def  VEORd    : N3VDX<1, 0, 0b00, 0b0001, 1, IIC_VBINiD, "veor",
2280                       v2i32, v2i32, xor, 1>;
2281 def  VEORq    : N3VQX<1, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "veor",
2282                       v4i32, v4i32, xor, 1>;
2283
2284 //   VORR     : Vector Bitwise OR
2285 def  VORRd    : N3VDX<0, 0, 0b10, 0b0001, 1, IIC_VBINiD, "vorr",
2286                       v2i32, v2i32, or, 1>;
2287 def  VORRq    : N3VQX<0, 0, 0b10, 0b0001, 1, IIC_VBINiQ, "vorr",
2288                       v4i32, v4i32, or, 1>;
2289
2290 //   VBIC     : Vector Bitwise Bit Clear (AND NOT)
2291 def  VBICd    : N3VX<0, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
2292                     (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
2293                     "vbic", "$dst, $src1, $src2", "",
2294                     [(set DPR:$dst, (v2i32 (and DPR:$src1,
2295                                                 (vnot_conv DPR:$src2))))]>;
2296 def  VBICq    : N3VX<0, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
2297                     (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
2298                     "vbic", "$dst, $src1, $src2", "",
2299                     [(set QPR:$dst, (v4i32 (and QPR:$src1,
2300                                                 (vnot_conv QPR:$src2))))]>;
2301
2302 //   VORN     : Vector Bitwise OR NOT
2303 def  VORNd    : N3VX<0, 0, 0b11, 0b0001, 0, 1, (outs DPR:$dst),
2304                     (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
2305                     "vorn", "$dst, $src1, $src2", "",
2306                     [(set DPR:$dst, (v2i32 (or DPR:$src1,
2307                                                (vnot_conv DPR:$src2))))]>;
2308 def  VORNq    : N3VX<0, 0, 0b11, 0b0001, 1, 1, (outs QPR:$dst),
2309                     (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
2310                     "vorn", "$dst, $src1, $src2", "",
2311                     [(set QPR:$dst, (v4i32 (or QPR:$src1,
2312                                                (vnot_conv QPR:$src2))))]>;
2313
2314 //   VMVN     : Vector Bitwise NOT
2315 def  VMVNd    : N2VX<0b11, 0b11, 0b00, 0b00, 0b01011, 0, 0,
2316                     (outs DPR:$dst), (ins DPR:$src), IIC_VSHLiD,
2317                     "vmvn", "$dst, $src", "",
2318                     [(set DPR:$dst, (v2i32 (vnot DPR:$src)))]>;
2319 def  VMVNq    : N2VX<0b11, 0b11, 0b00, 0b00, 0b01011, 1, 0,
2320                     (outs QPR:$dst), (ins QPR:$src), IIC_VSHLiD,
2321                     "vmvn", "$dst, $src", "",
2322                     [(set QPR:$dst, (v4i32 (vnot QPR:$src)))]>;
2323 def : Pat<(v2i32 (vnot_conv DPR:$src)), (VMVNd DPR:$src)>;
2324 def : Pat<(v4i32 (vnot_conv QPR:$src)), (VMVNq QPR:$src)>;
2325
2326 //   VBSL     : Vector Bitwise Select
2327 def  VBSLd    : N3VX<1, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
2328                     (ins DPR:$src1, DPR:$src2, DPR:$src3), IIC_VCNTiD,
2329                     "vbsl", "$dst, $src2, $src3", "$src1 = $dst",
2330                     [(set DPR:$dst,
2331                       (v2i32 (or (and DPR:$src2, DPR:$src1),
2332                                  (and DPR:$src3, (vnot_conv DPR:$src1)))))]>;
2333 def  VBSLq    : N3VX<1, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
2334                     (ins QPR:$src1, QPR:$src2, QPR:$src3), IIC_VCNTiQ,
2335                     "vbsl", "$dst, $src2, $src3", "$src1 = $dst",
2336                     [(set QPR:$dst,
2337                       (v4i32 (or (and QPR:$src2, QPR:$src1),
2338                                  (and QPR:$src3, (vnot_conv QPR:$src1)))))]>;
2339
2340 //   VBIF     : Vector Bitwise Insert if False
2341 //              like VBSL but with: "vbif $dst, $src3, $src1", "$src2 = $dst",
2342 def  VBIFd    : N3VX<1, 0, 0b11, 0b0001, 0, 1,
2343                      (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3),
2344                      IIC_VBINiD, "vbif", "$dst, $src2, $src3", "$src1 = $dst",
2345                      [/* For disassembly only; pattern left blank */]>;
2346 def  VBIFq    : N3VX<1, 0, 0b11, 0b0001, 1, 1,
2347                      (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3),
2348                      IIC_VBINiQ, "vbif", "$dst, $src2, $src3", "$src1 = $dst",
2349                      [/* For disassembly only; pattern left blank */]>;
2350
2351 //   VBIT     : Vector Bitwise Insert if True
2352 //              like VBSL but with: "vbit $dst, $src2, $src1", "$src3 = $dst",
2353 def  VBITd    : N3VX<1, 0, 0b10, 0b0001, 0, 1,
2354                      (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3),
2355                      IIC_VBINiD, "vbit", "$dst, $src2, $src3", "$src1 = $dst",
2356                      [/* For disassembly only; pattern left blank */]>;
2357 def  VBITq    : N3VX<1, 0, 0b10, 0b0001, 1, 1,
2358                      (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3),
2359                      IIC_VBINiQ, "vbit", "$dst, $src2, $src3", "$src1 = $dst",
2360                      [/* For disassembly only; pattern left blank */]>;
2361
2362 // VBIT/VBIF are not yet implemented.  The TwoAddress pass will not go looking
2363 // for equivalent operations with different register constraints; it just
2364 // inserts copies.
2365
2366 // Vector Absolute Differences.
2367
2368 //   VABD     : Vector Absolute Difference
2369 defm VABDs    : N3VInt_QHS<0, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D,
2370                            IIC_VBINi4Q, IIC_VBINi4Q,
2371                            "vabd", "s", int_arm_neon_vabds, 0>;
2372 defm VABDu    : N3VInt_QHS<1, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D,
2373                            IIC_VBINi4Q, IIC_VBINi4Q,
2374                            "vabd", "u", int_arm_neon_vabdu, 0>;
2375 def  VABDfd   : N3VDInt<1, 0, 0b10, 0b1101, 0, IIC_VBIND,
2376                         "vabd", "f32", v2f32, v2f32, int_arm_neon_vabds, 0>;
2377 def  VABDfq   : N3VQInt<1, 0, 0b10, 0b1101, 0, IIC_VBINQ,
2378                         "vabd", "f32", v4f32, v4f32, int_arm_neon_vabds, 0>;
2379
2380 //   VABDL    : Vector Absolute Difference Long (Q = | D - D |)
2381 defm VABDLs   : N3VLInt_QHS<0,1,0b0111,0, IIC_VBINi4Q,
2382                             "vabdl", "s", int_arm_neon_vabdls, 0>;
2383 defm VABDLu   : N3VLInt_QHS<1,1,0b0111,0, IIC_VBINi4Q,
2384                              "vabdl", "u", int_arm_neon_vabdlu, 0>;
2385
2386 //   VABA     : Vector Absolute Difference and Accumulate
2387 defm VABAs    : N3VInt3_QHS<0,0,0b0111,1, "vaba", "s", int_arm_neon_vabas>;
2388 defm VABAu    : N3VInt3_QHS<1,0,0b0111,1, "vaba", "u", int_arm_neon_vabau>;
2389
2390 //   VABAL    : Vector Absolute Difference and Accumulate Long (Q += | D - D |)
2391 defm VABALs   : N3VLInt3_QHS<0,1,0b0101,0, "vabal", "s", int_arm_neon_vabals>;
2392 defm VABALu   : N3VLInt3_QHS<1,1,0b0101,0, "vabal", "u", int_arm_neon_vabalu>;
2393
2394 // Vector Maximum and Minimum.
2395
2396 //   VMAX     : Vector Maximum
2397 defm VMAXs    : N3VInt_QHS<0,0,0b0110,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2398                            IIC_VBINi4Q, "vmax", "s", int_arm_neon_vmaxs, 1>;
2399 defm VMAXu    : N3VInt_QHS<1,0,0b0110,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2400                            IIC_VBINi4Q, "vmax", "u", int_arm_neon_vmaxu, 1>;
2401 def  VMAXfd   : N3VDInt<0, 0, 0b00, 0b1111, 0, IIC_VBIND, "vmax", "f32",
2402                         v2f32, v2f32, int_arm_neon_vmaxs, 1>;
2403 def  VMAXfq   : N3VQInt<0, 0, 0b00, 0b1111, 0, IIC_VBINQ, "vmax", "f32",
2404                         v4f32, v4f32, int_arm_neon_vmaxs, 1>;
2405
2406 //   VMIN     : Vector Minimum
2407 defm VMINs    : N3VInt_QHS<0,0,0b0110,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2408                            IIC_VBINi4Q, "vmin", "s", int_arm_neon_vmins, 1>;
2409 defm VMINu    : N3VInt_QHS<1,0,0b0110,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2410                            IIC_VBINi4Q, "vmin", "u", int_arm_neon_vminu, 1>;
2411 def  VMINfd   : N3VDInt<0, 0, 0b10, 0b1111, 0, IIC_VBIND, "vmin", "f32",
2412                         v2f32, v2f32, int_arm_neon_vmins, 1>;
2413 def  VMINfq   : N3VQInt<0, 0, 0b10, 0b1111, 0, IIC_VBINQ, "vmin", "f32",
2414                         v4f32, v4f32, int_arm_neon_vmins, 1>;
2415
2416 // Vector Pairwise Operations.
2417
2418 //   VPADD    : Vector Pairwise Add
2419 def  VPADDi8  : N3VDInt<0, 0, 0b00, 0b1011, 1, IIC_VBINiD, "vpadd", "i8",
2420                         v8i8, v8i8, int_arm_neon_vpadd, 0>;
2421 def  VPADDi16 : N3VDInt<0, 0, 0b01, 0b1011, 1, IIC_VBINiD, "vpadd", "i16",
2422                         v4i16, v4i16, int_arm_neon_vpadd, 0>;
2423 def  VPADDi32 : N3VDInt<0, 0, 0b10, 0b1011, 1, IIC_VBINiD, "vpadd", "i32",
2424                         v2i32, v2i32, int_arm_neon_vpadd, 0>;
2425 def  VPADDf   : N3VDInt<1, 0, 0b00, 0b1101, 0, IIC_VBIND, "vpadd", "f32",
2426                         v2f32, v2f32, int_arm_neon_vpadd, 0>;
2427
2428 //   VPADDL   : Vector Pairwise Add Long
2429 defm VPADDLs  : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00100, 0, "vpaddl", "s",
2430                              int_arm_neon_vpaddls>;
2431 defm VPADDLu  : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00101, 0, "vpaddl", "u",
2432                              int_arm_neon_vpaddlu>;
2433
2434 //   VPADAL   : Vector Pairwise Add and Accumulate Long
2435 defm VPADALs  : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b01100, 0, "vpadal", "s",
2436                               int_arm_neon_vpadals>;
2437 defm VPADALu  : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b01101, 0, "vpadal", "u",
2438                               int_arm_neon_vpadalu>;
2439
2440 //   VPMAX    : Vector Pairwise Maximum
2441 def  VPMAXs8  : N3VDInt<0, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax", "s8",
2442                         v8i8, v8i8, int_arm_neon_vpmaxs, 0>;
2443 def  VPMAXs16 : N3VDInt<0, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax", "s16",
2444                         v4i16, v4i16, int_arm_neon_vpmaxs, 0>;
2445 def  VPMAXs32 : N3VDInt<0, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax", "s32",
2446                         v2i32, v2i32, int_arm_neon_vpmaxs, 0>;
2447 def  VPMAXu8  : N3VDInt<1, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax", "u8",
2448                         v8i8, v8i8, int_arm_neon_vpmaxu, 0>;
2449 def  VPMAXu16 : N3VDInt<1, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax", "u16",
2450                         v4i16, v4i16, int_arm_neon_vpmaxu, 0>;
2451 def  VPMAXu32 : N3VDInt<1, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax", "u32",
2452                         v2i32, v2i32, int_arm_neon_vpmaxu, 0>;
2453 def  VPMAXf   : N3VDInt<1, 0, 0b00, 0b1111, 0, IIC_VBINi4D, "vpmax", "f32",
2454                         v2f32, v2f32, int_arm_neon_vpmaxs, 0>;
2455
2456 //   VPMIN    : Vector Pairwise Minimum
2457 def  VPMINs8  : N3VDInt<0, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin", "s8",
2458                         v8i8, v8i8, int_arm_neon_vpmins, 0>;
2459 def  VPMINs16 : N3VDInt<0, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin", "s16",
2460                         v4i16, v4i16, int_arm_neon_vpmins, 0>;
2461 def  VPMINs32 : N3VDInt<0, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin", "s32",
2462                         v2i32, v2i32, int_arm_neon_vpmins, 0>;
2463 def  VPMINu8  : N3VDInt<1, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin", "u8",
2464                         v8i8, v8i8, int_arm_neon_vpminu, 0>;
2465 def  VPMINu16 : N3VDInt<1, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin", "u16",
2466                         v4i16, v4i16, int_arm_neon_vpminu, 0>;
2467 def  VPMINu32 : N3VDInt<1, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin", "u32",
2468                         v2i32, v2i32, int_arm_neon_vpminu, 0>;
2469 def  VPMINf   : N3VDInt<1, 0, 0b10, 0b1111, 0, IIC_VBINi4D, "vpmin", "f32",
2470                         v2f32, v2f32, int_arm_neon_vpmins, 0>;
2471
2472 // Vector Reciprocal and Reciprocal Square Root Estimate and Step.
2473
2474 //   VRECPE   : Vector Reciprocal Estimate
2475 def  VRECPEd  : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
2476                         IIC_VUNAD, "vrecpe", "u32",
2477                         v2i32, v2i32, int_arm_neon_vrecpe>;
2478 def  VRECPEq  : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
2479                         IIC_VUNAQ, "vrecpe", "u32",
2480                         v4i32, v4i32, int_arm_neon_vrecpe>;
2481 def  VRECPEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
2482                         IIC_VUNAD, "vrecpe", "f32",
2483                         v2f32, v2f32, int_arm_neon_vrecpe>;
2484 def  VRECPEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
2485                         IIC_VUNAQ, "vrecpe", "f32",
2486                         v4f32, v4f32, int_arm_neon_vrecpe>;
2487
2488 //   VRECPS   : Vector Reciprocal Step
2489 def  VRECPSfd : N3VDInt<0, 0, 0b00, 0b1111, 1,
2490                         IIC_VRECSD, "vrecps", "f32",
2491                         v2f32, v2f32, int_arm_neon_vrecps, 1>;
2492 def  VRECPSfq : N3VQInt<0, 0, 0b00, 0b1111, 1,
2493                         IIC_VRECSQ, "vrecps", "f32",
2494                         v4f32, v4f32, int_arm_neon_vrecps, 1>;
2495
2496 //   VRSQRTE  : Vector Reciprocal Square Root Estimate
2497 def  VRSQRTEd  : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
2498                          IIC_VUNAD, "vrsqrte", "u32",
2499                          v2i32, v2i32, int_arm_neon_vrsqrte>;
2500 def  VRSQRTEq  : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
2501                          IIC_VUNAQ, "vrsqrte", "u32",
2502                          v4i32, v4i32, int_arm_neon_vrsqrte>;
2503 def  VRSQRTEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
2504                          IIC_VUNAD, "vrsqrte", "f32",
2505                          v2f32, v2f32, int_arm_neon_vrsqrte>;
2506 def  VRSQRTEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
2507                          IIC_VUNAQ, "vrsqrte", "f32",
2508                          v4f32, v4f32, int_arm_neon_vrsqrte>;
2509
2510 //   VRSQRTS  : Vector Reciprocal Square Root Step
2511 def VRSQRTSfd : N3VDInt<0, 0, 0b10, 0b1111, 1,
2512                         IIC_VRECSD, "vrsqrts", "f32",
2513                         v2f32, v2f32, int_arm_neon_vrsqrts, 1>;
2514 def VRSQRTSfq : N3VQInt<0, 0, 0b10, 0b1111, 1,
2515                         IIC_VRECSQ, "vrsqrts", "f32",
2516                         v4f32, v4f32, int_arm_neon_vrsqrts, 1>;
2517
2518 // Vector Shifts.
2519
2520 //   VSHL     : Vector Shift
2521 defm VSHLs    : N3VInt_QHSD<0, 0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
2522                             IIC_VSHLiQ, "vshl", "s", int_arm_neon_vshifts, 0>;
2523 defm VSHLu    : N3VInt_QHSD<1, 0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
2524                             IIC_VSHLiQ, "vshl", "u", int_arm_neon_vshiftu, 0>;
2525 //   VSHL     : Vector Shift Left (Immediate)
2526 defm VSHLi    : N2VSh_QHSD<0, 1, 0b0101, 1, IIC_VSHLiD, "vshl", "i", NEONvshl>;
2527 //   VSHR     : Vector Shift Right (Immediate)
2528 defm VSHRs    : N2VSh_QHSD<0, 1, 0b0000, 1, IIC_VSHLiD, "vshr", "s", NEONvshrs>;
2529 defm VSHRu    : N2VSh_QHSD<1, 1, 0b0000, 1, IIC_VSHLiD, "vshr", "u", NEONvshru>;
2530
2531 //   VSHLL    : Vector Shift Left Long
2532 defm VSHLLs   : N2VLSh_QHS<0, 1, 0b1010, 0, 0, 1, "vshll", "s", NEONvshlls>;
2533 defm VSHLLu   : N2VLSh_QHS<1, 1, 0b1010, 0, 0, 1, "vshll", "u", NEONvshllu>;
2534
2535 //   VSHLL    : Vector Shift Left Long (with maximum shift count)
2536 class N2VLShMax<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
2537                 bit op6, bit op4, string OpcodeStr, string Dt, ValueType ResTy,
2538                 ValueType OpTy, SDNode OpNode>
2539   : N2VLSh<op24, op23, op11_8, op7, op6, op4, OpcodeStr, Dt,
2540            ResTy, OpTy, OpNode> {
2541   let Inst{21-16} = op21_16;
2542 }
2543 def  VSHLLi8  : N2VLShMax<1, 1, 0b110010, 0b0011, 0, 0, 0, "vshll", "i8",
2544                           v8i16, v8i8, NEONvshlli>;
2545 def  VSHLLi16 : N2VLShMax<1, 1, 0b110110, 0b0011, 0, 0, 0, "vshll", "i16",
2546                           v4i32, v4i16, NEONvshlli>;
2547 def  VSHLLi32 : N2VLShMax<1, 1, 0b111010, 0b0011, 0, 0, 0, "vshll", "i32",
2548                           v2i64, v2i32, NEONvshlli>;
2549
2550 //   VSHRN    : Vector Shift Right and Narrow
2551 defm VSHRN    : N2VNSh_HSD<0,1,0b1000,0,0,1, IIC_VSHLiD, "vshrn", "i",
2552                            NEONvshrn>;
2553
2554 //   VRSHL    : Vector Rounding Shift
2555 defm VRSHLs   : N3VInt_QHSD<0,0,0b0101,0, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2556                             IIC_VSHLi4Q, "vrshl", "s", int_arm_neon_vrshifts,0>;
2557 defm VRSHLu   : N3VInt_QHSD<1,0,0b0101,0, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2558                             IIC_VSHLi4Q, "vrshl", "u", int_arm_neon_vrshiftu,0>;
2559 //   VRSHR    : Vector Rounding Shift Right
2560 defm VRSHRs   : N2VSh_QHSD<0,1,0b0010,1, IIC_VSHLi4D, "vrshr", "s", NEONvrshrs>;
2561 defm VRSHRu   : N2VSh_QHSD<1,1,0b0010,1, IIC_VSHLi4D, "vrshr", "u", NEONvrshru>;
2562
2563 //   VRSHRN   : Vector Rounding Shift Right and Narrow
2564 defm VRSHRN   : N2VNSh_HSD<0, 1, 0b1000, 0, 1, 1, IIC_VSHLi4D, "vrshrn", "i",
2565                            NEONvrshrn>;
2566
2567 //   VQSHL    : Vector Saturating Shift
2568 defm VQSHLs   : N3VInt_QHSD<0,0,0b0100,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2569                             IIC_VSHLi4Q, "vqshl", "s", int_arm_neon_vqshifts,0>;
2570 defm VQSHLu   : N3VInt_QHSD<1,0,0b0100,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2571                             IIC_VSHLi4Q, "vqshl", "u", int_arm_neon_vqshiftu,0>;
2572 //   VQSHL    : Vector Saturating Shift Left (Immediate)
2573 defm VQSHLsi  : N2VSh_QHSD<0,1,0b0111,1, IIC_VSHLi4D, "vqshl", "s", NEONvqshls>;
2574 defm VQSHLui  : N2VSh_QHSD<1,1,0b0111,1, IIC_VSHLi4D, "vqshl", "u", NEONvqshlu>;
2575 //   VQSHLU   : Vector Saturating Shift Left (Immediate, Unsigned)
2576 defm VQSHLsu  : N2VSh_QHSD<1,1,0b0110,1, IIC_VSHLi4D, "vqshlu","s",NEONvqshlsu>;
2577
2578 //   VQSHRN   : Vector Saturating Shift Right and Narrow
2579 defm VQSHRNs  : N2VNSh_HSD<0, 1, 0b1001, 0, 0, 1, IIC_VSHLi4D, "vqshrn", "s",
2580                            NEONvqshrns>;
2581 defm VQSHRNu  : N2VNSh_HSD<1, 1, 0b1001, 0, 0, 1, IIC_VSHLi4D, "vqshrn", "u",
2582                            NEONvqshrnu>;
2583
2584 //   VQSHRUN  : Vector Saturating Shift Right and Narrow (Unsigned)
2585 defm VQSHRUN  : N2VNSh_HSD<1, 1, 0b1000, 0, 0, 1, IIC_VSHLi4D, "vqshrun", "s",
2586                            NEONvqshrnsu>;
2587
2588 //   VQRSHL   : Vector Saturating Rounding Shift
2589 defm VQRSHLs  : N3VInt_QHSD<0,0,0b0101,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2590                             IIC_VSHLi4Q, "vqrshl", "s",
2591                             int_arm_neon_vqrshifts, 0>;
2592 defm VQRSHLu  : N3VInt_QHSD<1,0,0b0101,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2593                             IIC_VSHLi4Q, "vqrshl", "u",
2594                             int_arm_neon_vqrshiftu, 0>;
2595
2596 //   VQRSHRN  : Vector Saturating Rounding Shift Right and Narrow
2597 defm VQRSHRNs : N2VNSh_HSD<0, 1, 0b1001, 0, 1, 1, IIC_VSHLi4D, "vqrshrn", "s",
2598                            NEONvqrshrns>;
2599 defm VQRSHRNu : N2VNSh_HSD<1, 1, 0b1001, 0, 1, 1, IIC_VSHLi4D, "vqrshrn", "u",
2600                            NEONvqrshrnu>;
2601
2602 //   VQRSHRUN : Vector Saturating Rounding Shift Right and Narrow (Unsigned)
2603 defm VQRSHRUN : N2VNSh_HSD<1, 1, 0b1000, 0, 1, 1, IIC_VSHLi4D, "vqrshrun", "s",
2604                            NEONvqrshrnsu>;
2605
2606 //   VSRA     : Vector Shift Right and Accumulate
2607 defm VSRAs    : N2VShAdd_QHSD<0, 1, 0b0001, 1, "vsra", "s", NEONvshrs>;
2608 defm VSRAu    : N2VShAdd_QHSD<1, 1, 0b0001, 1, "vsra", "u", NEONvshru>;
2609 //   VRSRA    : Vector Rounding Shift Right and Accumulate
2610 defm VRSRAs   : N2VShAdd_QHSD<0, 1, 0b0011, 1, "vrsra", "s", NEONvrshrs>;
2611 defm VRSRAu   : N2VShAdd_QHSD<1, 1, 0b0011, 1, "vrsra", "u", NEONvrshru>;
2612
2613 //   VSLI     : Vector Shift Left and Insert
2614 defm VSLI     : N2VShIns_QHSD<1, 1, 0b0101, 1, "vsli", NEONvsli>;
2615 //   VSRI     : Vector Shift Right and Insert
2616 defm VSRI     : N2VShIns_QHSD<1, 1, 0b0100, 1, "vsri", NEONvsri>;
2617
2618 // Vector Absolute and Saturating Absolute.
2619
2620 //   VABS     : Vector Absolute Value
2621 defm VABS     : N2VInt_QHS<0b11, 0b11, 0b01, 0b00110, 0,
2622                            IIC_VUNAiD, IIC_VUNAiQ, "vabs", "s",
2623                            int_arm_neon_vabs>;
2624 def  VABSfd   : N2VDInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2625                         IIC_VUNAD, "vabs", "f32",
2626                         v2f32, v2f32, int_arm_neon_vabs>;
2627 def  VABSfq   : N2VQInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2628                         IIC_VUNAQ, "vabs", "f32",
2629                         v4f32, v4f32, int_arm_neon_vabs>;
2630
2631 //   VQABS    : Vector Saturating Absolute Value
2632 defm VQABS    : N2VInt_QHS<0b11, 0b11, 0b00, 0b01110, 0,
2633                            IIC_VQUNAiD, IIC_VQUNAiQ, "vqabs", "s",
2634                            int_arm_neon_vqabs>;
2635
2636 // Vector Negate.
2637
2638 def vneg      : PatFrag<(ops node:$in), (sub immAllZerosV, node:$in)>;
2639 def vneg_conv : PatFrag<(ops node:$in), (sub immAllZerosV_bc, node:$in)>;
2640
2641 class VNEGD<bits<2> size, string OpcodeStr, string Dt, ValueType Ty>
2642   : N2V<0b11, 0b11, size, 0b01, 0b00111, 0, 0, (outs DPR:$dst), (ins DPR:$src),
2643         IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
2644         [(set DPR:$dst, (Ty (vneg DPR:$src)))]>;
2645 class VNEGQ<bits<2> size, string OpcodeStr, string Dt, ValueType Ty>
2646   : N2V<0b11, 0b11, size, 0b01, 0b00111, 1, 0, (outs QPR:$dst), (ins QPR:$src),
2647         IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
2648         [(set QPR:$dst, (Ty (vneg QPR:$src)))]>;
2649
2650 //   VNEG     : Vector Negate
2651 def  VNEGs8d  : VNEGD<0b00, "vneg", "s8", v8i8>;
2652 def  VNEGs16d : VNEGD<0b01, "vneg", "s16", v4i16>;
2653 def  VNEGs32d : VNEGD<0b10, "vneg", "s32", v2i32>;
2654 def  VNEGs8q  : VNEGQ<0b00, "vneg", "s8", v16i8>;
2655 def  VNEGs16q : VNEGQ<0b01, "vneg", "s16", v8i16>;
2656 def  VNEGs32q : VNEGQ<0b10, "vneg", "s32", v4i32>;
2657
2658 //   VNEG     : Vector Negate (floating-point)
2659 def  VNEGfd   : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
2660                     (outs DPR:$dst), (ins DPR:$src), IIC_VUNAD,
2661                     "vneg", "f32", "$dst, $src", "",
2662                     [(set DPR:$dst, (v2f32 (fneg DPR:$src)))]>;
2663 def  VNEGf32q : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 1, 0,
2664                     (outs QPR:$dst), (ins QPR:$src), IIC_VUNAQ,
2665                     "vneg", "f32", "$dst, $src", "",
2666                     [(set QPR:$dst, (v4f32 (fneg QPR:$src)))]>;
2667
2668 def : Pat<(v8i8 (vneg_conv DPR:$src)), (VNEGs8d DPR:$src)>;
2669 def : Pat<(v4i16 (vneg_conv DPR:$src)), (VNEGs16d DPR:$src)>;
2670 def : Pat<(v2i32 (vneg_conv DPR:$src)), (VNEGs32d DPR:$src)>;
2671 def : Pat<(v16i8 (vneg_conv QPR:$src)), (VNEGs8q QPR:$src)>;
2672 def : Pat<(v8i16 (vneg_conv QPR:$src)), (VNEGs16q QPR:$src)>;
2673 def : Pat<(v4i32 (vneg_conv QPR:$src)), (VNEGs32q QPR:$src)>;
2674
2675 //   VQNEG    : Vector Saturating Negate
2676 defm VQNEG    : N2VInt_QHS<0b11, 0b11, 0b00, 0b01111, 0,
2677                            IIC_VQUNAiD, IIC_VQUNAiQ, "vqneg", "s",
2678                            int_arm_neon_vqneg>;
2679
2680 // Vector Bit Counting Operations.
2681
2682 //   VCLS     : Vector Count Leading Sign Bits
2683 defm VCLS     : N2VInt_QHS<0b11, 0b11, 0b00, 0b01000, 0,
2684                            IIC_VCNTiD, IIC_VCNTiQ, "vcls", "s",
2685                            int_arm_neon_vcls>;
2686 //   VCLZ     : Vector Count Leading Zeros
2687 defm VCLZ     : N2VInt_QHS<0b11, 0b11, 0b00, 0b01001, 0,
2688                            IIC_VCNTiD, IIC_VCNTiQ, "vclz", "i",
2689                            int_arm_neon_vclz>;
2690 //   VCNT     : Vector Count One Bits
2691 def  VCNTd    : N2VDInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2692                         IIC_VCNTiD, "vcnt", "8",
2693                         v8i8, v8i8, int_arm_neon_vcnt>;
2694 def  VCNTq    : N2VQInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2695                         IIC_VCNTiQ, "vcnt", "8",
2696                         v16i8, v16i8, int_arm_neon_vcnt>;
2697
2698 // Vector Swap -- for disassembly only.
2699 def  VSWPd    : N2VX<0b11, 0b11, 0b00, 0b10, 0b00000, 0, 0,
2700                      (outs DPR:$dst), (ins DPR:$src), NoItinerary,
2701                      "vswp", "$dst, $src", "", []>;
2702 def  VSWPq    : N2VX<0b11, 0b11, 0b00, 0b10, 0b00000, 1, 0,
2703                      (outs QPR:$dst), (ins QPR:$src), NoItinerary,
2704                      "vswp", "$dst, $src", "", []>;
2705
2706 // Vector Move Operations.
2707
2708 //   VMOV     : Vector Move (Register)
2709
2710 def  VMOVDneon: N3VX<0, 0, 0b10, 0b0001, 0, 1, (outs DPR:$dst), (ins DPR:$src),
2711                     IIC_VMOVD, "vmov", "$dst, $src", "", []>;
2712 def  VMOVQ    : N3VX<0, 0, 0b10, 0b0001, 1, 1, (outs QPR:$dst), (ins QPR:$src),
2713                     IIC_VMOVD, "vmov", "$dst, $src", "", []>;
2714
2715 //   VMOV     : Vector Move (Immediate)
2716
2717 // VMOV_get_imm8 xform function: convert build_vector to VMOV.i8 imm.
2718 def VMOV_get_imm8 : SDNodeXForm<build_vector, [{
2719   return ARM::getVMOVImm(N, 1, *CurDAG);
2720 }]>;
2721 def vmovImm8 : PatLeaf<(build_vector), [{
2722   return ARM::getVMOVImm(N, 1, *CurDAG).getNode() != 0;
2723 }], VMOV_get_imm8>;
2724
2725 // VMOV_get_imm16 xform function: convert build_vector to VMOV.i16 imm.
2726 def VMOV_get_imm16 : SDNodeXForm<build_vector, [{
2727   return ARM::getVMOVImm(N, 2, *CurDAG);
2728 }]>;
2729 def vmovImm16 : PatLeaf<(build_vector), [{
2730   return ARM::getVMOVImm(N, 2, *CurDAG).getNode() != 0;
2731 }], VMOV_get_imm16>;
2732
2733 // VMOV_get_imm32 xform function: convert build_vector to VMOV.i32 imm.
2734 def VMOV_get_imm32 : SDNodeXForm<build_vector, [{
2735   return ARM::getVMOVImm(N, 4, *CurDAG);
2736 }]>;
2737 def vmovImm32 : PatLeaf<(build_vector), [{
2738   return ARM::getVMOVImm(N, 4, *CurDAG).getNode() != 0;
2739 }], VMOV_get_imm32>;
2740
2741 // VMOV_get_imm64 xform function: convert build_vector to VMOV.i64 imm.
2742 def VMOV_get_imm64 : SDNodeXForm<build_vector, [{
2743   return ARM::getVMOVImm(N, 8, *CurDAG);
2744 }]>;
2745 def vmovImm64 : PatLeaf<(build_vector), [{
2746   return ARM::getVMOVImm(N, 8, *CurDAG).getNode() != 0;
2747 }], VMOV_get_imm64>;
2748
2749 // Note: Some of the cmode bits in the following VMOV instructions need to
2750 // be encoded based on the immed values.
2751
2752 def VMOVv8i8  : N1ModImm<1, 0b000, 0b1110, 0, 0, 0, 1, (outs DPR:$dst),
2753                          (ins h8imm:$SIMM), IIC_VMOVImm,
2754                          "vmov", "i8", "$dst, $SIMM", "",
2755                          [(set DPR:$dst, (v8i8 vmovImm8:$SIMM))]>;
2756 def VMOVv16i8 : N1ModImm<1, 0b000, 0b1110, 0, 1, 0, 1, (outs QPR:$dst),
2757                          (ins h8imm:$SIMM), IIC_VMOVImm,
2758                          "vmov", "i8", "$dst, $SIMM", "",
2759                          [(set QPR:$dst, (v16i8 vmovImm8:$SIMM))]>;
2760
2761 def VMOVv4i16 : N1ModImm<1, 0b000, {1,0,?,?}, 0, 0, {?}, 1, (outs DPR:$dst),
2762                          (ins h16imm:$SIMM), IIC_VMOVImm,
2763                          "vmov", "i16", "$dst, $SIMM", "",
2764                          [(set DPR:$dst, (v4i16 vmovImm16:$SIMM))]>;
2765 def VMOVv8i16 : N1ModImm<1, 0b000, {1,0,?,?}, 0, 1, {?}, 1, (outs QPR:$dst),
2766                          (ins h16imm:$SIMM), IIC_VMOVImm,
2767                          "vmov", "i16", "$dst, $SIMM", "",
2768                          [(set QPR:$dst, (v8i16 vmovImm16:$SIMM))]>;
2769
2770 def VMOVv2i32 : N1ModImm<1, 0b000, {?,?,?,?}, 0, 0, {?}, 1, (outs DPR:$dst),
2771                          (ins h32imm:$SIMM), IIC_VMOVImm,
2772                          "vmov", "i32", "$dst, $SIMM", "",
2773                          [(set DPR:$dst, (v2i32 vmovImm32:$SIMM))]>;
2774 def VMOVv4i32 : N1ModImm<1, 0b000, {?,?,?,?}, 0, 1, {?}, 1, (outs QPR:$dst),
2775                          (ins h32imm:$SIMM), IIC_VMOVImm,
2776                          "vmov", "i32", "$dst, $SIMM", "",
2777                          [(set QPR:$dst, (v4i32 vmovImm32:$SIMM))]>;
2778
2779 def VMOVv1i64 : N1ModImm<1, 0b000, 0b1110, 0, 0, 1, 1, (outs DPR:$dst),
2780                          (ins h64imm:$SIMM), IIC_VMOVImm,
2781                          "vmov", "i64", "$dst, $SIMM", "",
2782                          [(set DPR:$dst, (v1i64 vmovImm64:$SIMM))]>;
2783 def VMOVv2i64 : N1ModImm<1, 0b000, 0b1110, 0, 1, 1, 1, (outs QPR:$dst),
2784                          (ins h64imm:$SIMM), IIC_VMOVImm,
2785                          "vmov", "i64", "$dst, $SIMM", "",
2786                          [(set QPR:$dst, (v2i64 vmovImm64:$SIMM))]>;
2787
2788 //   VMOV     : Vector Get Lane (move scalar to ARM core register)
2789
2790 def VGETLNs8  : NVGetLane<{1,1,1,0,0,1,?,1}, 0b1011, {?,?},
2791                           (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2792                           IIC_VMOVSI, "vmov", "s8", "$dst, $src[$lane]",
2793                           [(set GPR:$dst, (NEONvgetlanes (v8i8 DPR:$src),
2794                                            imm:$lane))]>;
2795 def VGETLNs16 : NVGetLane<{1,1,1,0,0,0,?,1}, 0b1011, {?,1},
2796                           (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2797                           IIC_VMOVSI, "vmov", "s16", "$dst, $src[$lane]",
2798                           [(set GPR:$dst, (NEONvgetlanes (v4i16 DPR:$src),
2799                                            imm:$lane))]>;
2800 def VGETLNu8  : NVGetLane<{1,1,1,0,1,1,?,1}, 0b1011, {?,?},
2801                           (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2802                           IIC_VMOVSI, "vmov", "u8", "$dst, $src[$lane]",
2803                           [(set GPR:$dst, (NEONvgetlaneu (v8i8 DPR:$src),
2804                                            imm:$lane))]>;
2805 def VGETLNu16 : NVGetLane<{1,1,1,0,1,0,?,1}, 0b1011, {?,1},
2806                           (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2807                           IIC_VMOVSI, "vmov", "u16", "$dst, $src[$lane]",
2808                           [(set GPR:$dst, (NEONvgetlaneu (v4i16 DPR:$src),
2809                                            imm:$lane))]>;
2810 def VGETLNi32 : NVGetLane<{1,1,1,0,0,0,?,1}, 0b1011, 0b00,
2811                           (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2812                           IIC_VMOVSI, "vmov", "32", "$dst, $src[$lane]",
2813                           [(set GPR:$dst, (extractelt (v2i32 DPR:$src),
2814                                            imm:$lane))]>;
2815 // def VGETLNf32: see FMRDH and FMRDL in ARMInstrVFP.td
2816 def : Pat<(NEONvgetlanes (v16i8 QPR:$src), imm:$lane),
2817           (VGETLNs8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2818                            (DSubReg_i8_reg imm:$lane))),
2819                      (SubReg_i8_lane imm:$lane))>;
2820 def : Pat<(NEONvgetlanes (v8i16 QPR:$src), imm:$lane),
2821           (VGETLNs16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2822                              (DSubReg_i16_reg imm:$lane))),
2823                      (SubReg_i16_lane imm:$lane))>;
2824 def : Pat<(NEONvgetlaneu (v16i8 QPR:$src), imm:$lane),
2825           (VGETLNu8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2826                            (DSubReg_i8_reg imm:$lane))),
2827                      (SubReg_i8_lane imm:$lane))>;
2828 def : Pat<(NEONvgetlaneu (v8i16 QPR:$src), imm:$lane),
2829           (VGETLNu16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2830                              (DSubReg_i16_reg imm:$lane))),
2831                      (SubReg_i16_lane imm:$lane))>;
2832 def : Pat<(extractelt (v4i32 QPR:$src), imm:$lane),
2833           (VGETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src,
2834                              (DSubReg_i32_reg imm:$lane))),
2835                      (SubReg_i32_lane imm:$lane))>;
2836 def : Pat<(extractelt (v2f32 DPR:$src1), imm:$src2),
2837           (EXTRACT_SUBREG (v2f32 (COPY_TO_REGCLASS (v2f32 DPR:$src1),DPR_VFP2)),
2838                           (SSubReg_f32_reg imm:$src2))>;
2839 def : Pat<(extractelt (v4f32 QPR:$src1), imm:$src2),
2840           (EXTRACT_SUBREG (v4f32 (COPY_TO_REGCLASS (v4f32 QPR:$src1),QPR_VFP2)),
2841                           (SSubReg_f32_reg imm:$src2))>;
2842 //def : Pat<(extractelt (v2i64 QPR:$src1), imm:$src2),
2843 //          (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2844 def : Pat<(extractelt (v2f64 QPR:$src1), imm:$src2),
2845           (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2846
2847
2848 //   VMOV     : Vector Set Lane (move ARM core register to scalar)
2849
2850 let Constraints = "$src1 = $dst" in {
2851 def VSETLNi8  : NVSetLane<{1,1,1,0,0,1,?,0}, 0b1011, {?,?}, (outs DPR:$dst),
2852                           (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2853                           IIC_VMOVISL, "vmov", "8", "$dst[$lane], $src2",
2854                           [(set DPR:$dst, (vector_insert (v8i8 DPR:$src1),
2855                                            GPR:$src2, imm:$lane))]>;
2856 def VSETLNi16 : NVSetLane<{1,1,1,0,0,0,?,0}, 0b1011, {?,1}, (outs DPR:$dst),
2857                           (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2858                           IIC_VMOVISL, "vmov", "16", "$dst[$lane], $src2",
2859                           [(set DPR:$dst, (vector_insert (v4i16 DPR:$src1),
2860                                            GPR:$src2, imm:$lane))]>;
2861 def VSETLNi32 : NVSetLane<{1,1,1,0,0,0,?,0}, 0b1011, 0b00, (outs DPR:$dst),
2862                           (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2863                           IIC_VMOVISL, "vmov", "32", "$dst[$lane], $src2",
2864                           [(set DPR:$dst, (insertelt (v2i32 DPR:$src1),
2865                                            GPR:$src2, imm:$lane))]>;
2866 }
2867 def : Pat<(vector_insert (v16i8 QPR:$src1), GPR:$src2, imm:$lane),
2868           (v16i8 (INSERT_SUBREG QPR:$src1,
2869                   (v8i8 (VSETLNi8 (v8i8 (EXTRACT_SUBREG QPR:$src1,
2870                                    (DSubReg_i8_reg imm:$lane))),
2871                             GPR:$src2, (SubReg_i8_lane imm:$lane))),
2872                   (DSubReg_i8_reg imm:$lane)))>;
2873 def : Pat<(vector_insert (v8i16 QPR:$src1), GPR:$src2, imm:$lane),
2874           (v8i16 (INSERT_SUBREG QPR:$src1,
2875                   (v4i16 (VSETLNi16 (v4i16 (EXTRACT_SUBREG QPR:$src1,
2876                                      (DSubReg_i16_reg imm:$lane))),
2877                              GPR:$src2, (SubReg_i16_lane imm:$lane))),
2878                   (DSubReg_i16_reg imm:$lane)))>;
2879 def : Pat<(insertelt (v4i32 QPR:$src1), GPR:$src2, imm:$lane),
2880           (v4i32 (INSERT_SUBREG QPR:$src1,
2881                   (v2i32 (VSETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src1,
2882                                      (DSubReg_i32_reg imm:$lane))),
2883                              GPR:$src2, (SubReg_i32_lane imm:$lane))),
2884                   (DSubReg_i32_reg imm:$lane)))>;
2885
2886 def : Pat<(v2f32 (insertelt DPR:$src1, SPR:$src2, imm:$src3)),
2887           (INSERT_SUBREG (v2f32 (COPY_TO_REGCLASS DPR:$src1, DPR_VFP2)),
2888                                 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
2889 def : Pat<(v4f32 (insertelt QPR:$src1, SPR:$src2, imm:$src3)),
2890           (INSERT_SUBREG (v4f32 (COPY_TO_REGCLASS QPR:$src1, QPR_VFP2)),
2891                                 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
2892
2893 //def : Pat<(v2i64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
2894 //          (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
2895 def : Pat<(v2f64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
2896           (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
2897
2898 def : Pat<(v2f32 (scalar_to_vector SPR:$src)),
2899           (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
2900 def : Pat<(v2f64 (scalar_to_vector (f64 DPR:$src))),
2901           (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), DPR:$src, arm_dsubreg_0)>;
2902 def : Pat<(v4f32 (scalar_to_vector SPR:$src)),
2903           (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
2904
2905 def : Pat<(v8i8 (scalar_to_vector GPR:$src)),
2906           (VSETLNi8  (v8i8  (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2907 def : Pat<(v4i16 (scalar_to_vector GPR:$src)),
2908           (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2909 def : Pat<(v2i32 (scalar_to_vector GPR:$src)),
2910           (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2911
2912 def : Pat<(v16i8 (scalar_to_vector GPR:$src)),
2913           (INSERT_SUBREG (v16i8 (IMPLICIT_DEF)),
2914                          (VSETLNi8 (v8i8 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2915                          arm_dsubreg_0)>;
2916 def : Pat<(v8i16 (scalar_to_vector GPR:$src)),
2917           (INSERT_SUBREG (v8i16 (IMPLICIT_DEF)),
2918                          (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2919                          arm_dsubreg_0)>;
2920 def : Pat<(v4i32 (scalar_to_vector GPR:$src)),
2921           (INSERT_SUBREG (v4i32 (IMPLICIT_DEF)),
2922                          (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2923                          arm_dsubreg_0)>;
2924
2925 //   VDUP     : Vector Duplicate (from ARM core register to all elements)
2926
2927 class VDUPD<bits<8> opcod1, bits<2> opcod3, string Dt, ValueType Ty>
2928   : NVDup<opcod1, 0b1011, opcod3, (outs DPR:$dst), (ins GPR:$src),
2929           IIC_VMOVIS, "vdup", Dt, "$dst, $src",
2930           [(set DPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
2931 class VDUPQ<bits<8> opcod1, bits<2> opcod3, string Dt, ValueType Ty>
2932   : NVDup<opcod1, 0b1011, opcod3, (outs QPR:$dst), (ins GPR:$src),
2933           IIC_VMOVIS, "vdup", Dt, "$dst, $src",
2934           [(set QPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
2935
2936 def  VDUP8d   : VDUPD<0b11101100, 0b00, "8", v8i8>;
2937 def  VDUP16d  : VDUPD<0b11101000, 0b01, "16", v4i16>;
2938 def  VDUP32d  : VDUPD<0b11101000, 0b00, "32", v2i32>;
2939 def  VDUP8q   : VDUPQ<0b11101110, 0b00, "8", v16i8>;
2940 def  VDUP16q  : VDUPQ<0b11101010, 0b01, "16", v8i16>;
2941 def  VDUP32q  : VDUPQ<0b11101010, 0b00, "32", v4i32>;
2942
2943 def  VDUPfd   : NVDup<0b11101000, 0b1011, 0b00, (outs DPR:$dst), (ins GPR:$src),
2944                       IIC_VMOVIS, "vdup", "32", "$dst, $src",
2945                       [(set DPR:$dst, (v2f32 (NEONvdup
2946                                               (f32 (bitconvert GPR:$src)))))]>;
2947 def  VDUPfq   : NVDup<0b11101010, 0b1011, 0b00, (outs QPR:$dst), (ins GPR:$src),
2948                       IIC_VMOVIS, "vdup", "32", "$dst, $src",
2949                       [(set QPR:$dst, (v4f32 (NEONvdup
2950                                               (f32 (bitconvert GPR:$src)))))]>;
2951
2952 //   VDUP     : Vector Duplicate Lane (from scalar to all elements)
2953
2954 class VDUPLND<bits<2> op19_18, bits<2> op17_16,
2955               string OpcodeStr, string Dt, ValueType Ty>
2956   : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 0, 0,
2957         (outs DPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
2958         OpcodeStr, Dt, "$dst, $src[$lane]", "",
2959         [(set DPR:$dst, (Ty (NEONvduplane (Ty DPR:$src), imm:$lane)))]>;
2960
2961 class VDUPLNQ<bits<2> op19_18, bits<2> op17_16, string OpcodeStr, string Dt,
2962               ValueType ResTy, ValueType OpTy>
2963   : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 1, 0,
2964         (outs QPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
2965         OpcodeStr, Dt, "$dst, $src[$lane]", "",
2966         [(set QPR:$dst, (ResTy (NEONvduplane (OpTy DPR:$src), imm:$lane)))]>;
2967
2968 // Inst{19-16} is partially specified depending on the element size.
2969
2970 def VDUPLN8d  : VDUPLND<{?,?}, {?,1}, "vdup", "8", v8i8>;
2971 def VDUPLN16d : VDUPLND<{?,?}, {1,0}, "vdup", "16", v4i16>;
2972 def VDUPLN32d : VDUPLND<{?,1}, {0,0}, "vdup", "32", v2i32>;
2973 def VDUPLNfd  : VDUPLND<{?,1}, {0,0}, "vdup", "32", v2f32>;
2974 def VDUPLN8q  : VDUPLNQ<{?,?}, {?,1}, "vdup", "8", v16i8, v8i8>;
2975 def VDUPLN16q : VDUPLNQ<{?,?}, {1,0}, "vdup", "16", v8i16, v4i16>;
2976 def VDUPLN32q : VDUPLNQ<{?,1}, {0,0}, "vdup", "32", v4i32, v2i32>;
2977 def VDUPLNfq  : VDUPLNQ<{?,1}, {0,0}, "vdup", "32", v4f32, v2f32>;
2978
2979 def : Pat<(v16i8 (NEONvduplane (v16i8 QPR:$src), imm:$lane)),
2980           (v16i8 (VDUPLN8q (v8i8 (EXTRACT_SUBREG QPR:$src,
2981                                   (DSubReg_i8_reg imm:$lane))),
2982                            (SubReg_i8_lane imm:$lane)))>;
2983 def : Pat<(v8i16 (NEONvduplane (v8i16 QPR:$src), imm:$lane)),
2984           (v8i16 (VDUPLN16q (v4i16 (EXTRACT_SUBREG QPR:$src,
2985                                     (DSubReg_i16_reg imm:$lane))),
2986                             (SubReg_i16_lane imm:$lane)))>;
2987 def : Pat<(v4i32 (NEONvduplane (v4i32 QPR:$src), imm:$lane)),
2988           (v4i32 (VDUPLN32q (v2i32 (EXTRACT_SUBREG QPR:$src,
2989                                     (DSubReg_i32_reg imm:$lane))),
2990                             (SubReg_i32_lane imm:$lane)))>;
2991 def : Pat<(v4f32 (NEONvduplane (v4f32 QPR:$src), imm:$lane)),
2992           (v4f32 (VDUPLNfq (v2f32 (EXTRACT_SUBREG QPR:$src,
2993                                    (DSubReg_i32_reg imm:$lane))),
2994                            (SubReg_i32_lane imm:$lane)))>;
2995
2996 def  VDUPfdf  : N2V<0b11, 0b11, {?,1}, {0,0}, 0b11000, 0, 0,
2997                     (outs DPR:$dst), (ins SPR:$src),
2998                     IIC_VMOVD, "vdup", "32", "$dst, ${src:lane}", "",
2999                     [(set DPR:$dst, (v2f32 (NEONvdup (f32 SPR:$src))))]>;
3000
3001 def  VDUPfqf  : N2V<0b11, 0b11, {?,1}, {0,0}, 0b11000, 1, 0,
3002                     (outs QPR:$dst), (ins SPR:$src),
3003                     IIC_VMOVD, "vdup", "32", "$dst, ${src:lane}", "",
3004                     [(set QPR:$dst, (v4f32 (NEONvdup (f32 SPR:$src))))]>;
3005
3006 def : Pat<(v2i64 (NEONvduplane (v2i64 QPR:$src), imm:$lane)),
3007           (INSERT_SUBREG QPR:$src,
3008                          (i64 (EXTRACT_SUBREG QPR:$src,
3009                                (DSubReg_f64_reg imm:$lane))),
3010                          (DSubReg_f64_other_reg imm:$lane))>;
3011 def : Pat<(v2f64 (NEONvduplane (v2f64 QPR:$src), imm:$lane)),
3012           (INSERT_SUBREG QPR:$src,
3013                          (f64 (EXTRACT_SUBREG QPR:$src,
3014                                (DSubReg_f64_reg imm:$lane))),
3015                          (DSubReg_f64_other_reg imm:$lane))>;
3016
3017 //   VMOVN    : Vector Narrowing Move
3018 defm VMOVN    : N2VNInt_HSD<0b11,0b11,0b10,0b00100,0,0, IIC_VMOVD,
3019                             "vmovn", "i", int_arm_neon_vmovn>;
3020 //   VQMOVN   : Vector Saturating Narrowing Move
3021 defm VQMOVNs  : N2VNInt_HSD<0b11,0b11,0b10,0b00101,0,0, IIC_VQUNAiD,
3022                             "vqmovn", "s", int_arm_neon_vqmovns>;
3023 defm VQMOVNu  : N2VNInt_HSD<0b11,0b11,0b10,0b00101,1,0, IIC_VQUNAiD,
3024                             "vqmovn", "u", int_arm_neon_vqmovnu>;
3025 defm VQMOVNsu : N2VNInt_HSD<0b11,0b11,0b10,0b00100,1,0, IIC_VQUNAiD,
3026                             "vqmovun", "s", int_arm_neon_vqmovnsu>;
3027 //   VMOVL    : Vector Lengthening Move
3028 defm VMOVLs   : N2VLInt_QHS<0b01,0b10100,0,1, "vmovl", "s",
3029                             int_arm_neon_vmovls>;
3030 defm VMOVLu   : N2VLInt_QHS<0b11,0b10100,0,1, "vmovl", "u",
3031                             int_arm_neon_vmovlu>;
3032
3033 // Vector Conversions.
3034
3035 //   VCVT     : Vector Convert Between Floating-Point and Integers
3036 def  VCVTf2sd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3037                      v2i32, v2f32, fp_to_sint>;
3038 def  VCVTf2ud : N2VD<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3039                      v2i32, v2f32, fp_to_uint>;
3040 def  VCVTs2fd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3041                      v2f32, v2i32, sint_to_fp>;
3042 def  VCVTu2fd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3043                      v2f32, v2i32, uint_to_fp>;
3044
3045 def  VCVTf2sq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3046                      v4i32, v4f32, fp_to_sint>;
3047 def  VCVTf2uq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3048                      v4i32, v4f32, fp_to_uint>;
3049 def  VCVTs2fq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3050                      v4f32, v4i32, sint_to_fp>;
3051 def  VCVTu2fq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3052                      v4f32, v4i32, uint_to_fp>;
3053
3054 //   VCVT     : Vector Convert Between Floating-Point and Fixed-Point.
3055 def VCVTf2xsd : N2VCvtD<0, 1, 0b1111, 0, 1, "vcvt", "s32.f32",
3056                         v2i32, v2f32, int_arm_neon_vcvtfp2fxs>;
3057 def VCVTf2xud : N2VCvtD<1, 1, 0b1111, 0, 1, "vcvt", "u32.f32",
3058                         v2i32, v2f32, int_arm_neon_vcvtfp2fxu>;
3059 def VCVTxs2fd : N2VCvtD<0, 1, 0b1110, 0, 1, "vcvt", "f32.s32",
3060                         v2f32, v2i32, int_arm_neon_vcvtfxs2fp>;
3061 def VCVTxu2fd : N2VCvtD<1, 1, 0b1110, 0, 1, "vcvt", "f32.u32",
3062                         v2f32, v2i32, int_arm_neon_vcvtfxu2fp>;
3063
3064 def VCVTf2xsq : N2VCvtQ<0, 1, 0b1111, 0, 1, "vcvt", "s32.f32",
3065                         v4i32, v4f32, int_arm_neon_vcvtfp2fxs>;
3066 def VCVTf2xuq : N2VCvtQ<1, 1, 0b1111, 0, 1, "vcvt", "u32.f32",
3067                         v4i32, v4f32, int_arm_neon_vcvtfp2fxu>;
3068 def VCVTxs2fq : N2VCvtQ<0, 1, 0b1110, 0, 1, "vcvt", "f32.s32",
3069                         v4f32, v4i32, int_arm_neon_vcvtfxs2fp>;
3070 def VCVTxu2fq : N2VCvtQ<1, 1, 0b1110, 0, 1, "vcvt", "f32.u32",
3071                         v4f32, v4i32, int_arm_neon_vcvtfxu2fp>;
3072
3073 // Vector Reverse.
3074
3075 //   VREV64   : Vector Reverse elements within 64-bit doublewords
3076
3077 class VREV64D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3078   : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 0, 0, (outs DPR:$dst),
3079         (ins DPR:$src), IIC_VMOVD,
3080         OpcodeStr, Dt, "$dst, $src", "",
3081         [(set DPR:$dst, (Ty (NEONvrev64 (Ty DPR:$src))))]>;
3082 class VREV64Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3083   : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 1, 0, (outs QPR:$dst),
3084         (ins QPR:$src), IIC_VMOVD,
3085         OpcodeStr, Dt, "$dst, $src", "",
3086         [(set QPR:$dst, (Ty (NEONvrev64 (Ty QPR:$src))))]>;
3087
3088 def VREV64d8  : VREV64D<0b00, "vrev64", "8", v8i8>;
3089 def VREV64d16 : VREV64D<0b01, "vrev64", "16", v4i16>;
3090 def VREV64d32 : VREV64D<0b10, "vrev64", "32", v2i32>;
3091 def VREV64df  : VREV64D<0b10, "vrev64", "32", v2f32>;
3092
3093 def VREV64q8  : VREV64Q<0b00, "vrev64", "8", v16i8>;
3094 def VREV64q16 : VREV64Q<0b01, "vrev64", "16", v8i16>;
3095 def VREV64q32 : VREV64Q<0b10, "vrev64", "32", v4i32>;
3096 def VREV64qf  : VREV64Q<0b10, "vrev64", "32", v4f32>;
3097
3098 //   VREV32   : Vector Reverse elements within 32-bit words
3099
3100 class VREV32D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3101   : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 0, 0, (outs DPR:$dst),
3102         (ins DPR:$src), IIC_VMOVD,
3103         OpcodeStr, Dt, "$dst, $src", "",
3104         [(set DPR:$dst, (Ty (NEONvrev32 (Ty DPR:$src))))]>;
3105 class VREV32Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3106   : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 1, 0, (outs QPR:$dst),
3107         (ins QPR:$src), IIC_VMOVD,
3108         OpcodeStr, Dt, "$dst, $src", "",
3109         [(set QPR:$dst, (Ty (NEONvrev32 (Ty QPR:$src))))]>;
3110
3111 def VREV32d8  : VREV32D<0b00, "vrev32", "8", v8i8>;
3112 def VREV32d16 : VREV32D<0b01, "vrev32", "16", v4i16>;
3113
3114 def VREV32q8  : VREV32Q<0b00, "vrev32", "8", v16i8>;
3115 def VREV32q16 : VREV32Q<0b01, "vrev32", "16", v8i16>;
3116
3117 //   VREV16   : Vector Reverse elements within 16-bit halfwords
3118
3119 class VREV16D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3120   : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 0, 0, (outs DPR:$dst),
3121         (ins DPR:$src), IIC_VMOVD,
3122         OpcodeStr, Dt, "$dst, $src", "",
3123         [(set DPR:$dst, (Ty (NEONvrev16 (Ty DPR:$src))))]>;
3124 class VREV16Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3125   : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 1, 0, (outs QPR:$dst),
3126         (ins QPR:$src), IIC_VMOVD,
3127         OpcodeStr, Dt, "$dst, $src", "",
3128         [(set QPR:$dst, (Ty (NEONvrev16 (Ty QPR:$src))))]>;
3129
3130 def VREV16d8  : VREV16D<0b00, "vrev16", "8", v8i8>;
3131 def VREV16q8  : VREV16Q<0b00, "vrev16", "8", v16i8>;
3132
3133 // Other Vector Shuffles.
3134
3135 //   VEXT     : Vector Extract
3136
3137 class VEXTd<string OpcodeStr, string Dt, ValueType Ty>
3138   : N3V<0,1,0b11,{?,?,?,?},0,0, (outs DPR:$dst),
3139         (ins DPR:$lhs, DPR:$rhs, i32imm:$index), IIC_VEXTD,
3140         OpcodeStr, Dt, "$dst, $lhs, $rhs, $index", "",
3141         [(set DPR:$dst, (Ty (NEONvext (Ty DPR:$lhs),
3142                                       (Ty DPR:$rhs), imm:$index)))]>;
3143
3144 class VEXTq<string OpcodeStr, string Dt, ValueType Ty>
3145   : N3V<0,1,0b11,{?,?,?,?},1,0, (outs QPR:$dst),
3146         (ins QPR:$lhs, QPR:$rhs, i32imm:$index), IIC_VEXTQ,
3147         OpcodeStr, Dt, "$dst, $lhs, $rhs, $index", "",
3148         [(set QPR:$dst, (Ty (NEONvext (Ty QPR:$lhs),
3149                                       (Ty QPR:$rhs), imm:$index)))]>;
3150
3151 def VEXTd8  : VEXTd<"vext", "8",  v8i8>;
3152 def VEXTd16 : VEXTd<"vext", "16", v4i16>;
3153 def VEXTd32 : VEXTd<"vext", "32", v2i32>;
3154 def VEXTdf  : VEXTd<"vext", "32", v2f32>;
3155
3156 def VEXTq8  : VEXTq<"vext", "8",  v16i8>;
3157 def VEXTq16 : VEXTq<"vext", "16", v8i16>;
3158 def VEXTq32 : VEXTq<"vext", "32", v4i32>;
3159 def VEXTqf  : VEXTq<"vext", "32", v4f32>;
3160
3161 //   VTRN     : Vector Transpose
3162
3163 def  VTRNd8   : N2VDShuffle<0b00, 0b00001, "vtrn", "8">;
3164 def  VTRNd16  : N2VDShuffle<0b01, 0b00001, "vtrn", "16">;
3165 def  VTRNd32  : N2VDShuffle<0b10, 0b00001, "vtrn", "32">;
3166
3167 def  VTRNq8   : N2VQShuffle<0b00, 0b00001, IIC_VPERMQ, "vtrn", "8">;
3168 def  VTRNq16  : N2VQShuffle<0b01, 0b00001, IIC_VPERMQ, "vtrn", "16">;
3169 def  VTRNq32  : N2VQShuffle<0b10, 0b00001, IIC_VPERMQ, "vtrn", "32">;
3170
3171 //   VUZP     : Vector Unzip (Deinterleave)
3172
3173 def  VUZPd8   : N2VDShuffle<0b00, 0b00010, "vuzp", "8">;
3174 def  VUZPd16  : N2VDShuffle<0b01, 0b00010, "vuzp", "16">;
3175 def  VUZPd32  : N2VDShuffle<0b10, 0b00010, "vuzp", "32">;
3176
3177 def  VUZPq8   : N2VQShuffle<0b00, 0b00010, IIC_VPERMQ3, "vuzp", "8">;
3178 def  VUZPq16  : N2VQShuffle<0b01, 0b00010, IIC_VPERMQ3, "vuzp", "16">;
3179 def  VUZPq32  : N2VQShuffle<0b10, 0b00010, IIC_VPERMQ3, "vuzp", "32">;
3180
3181 //   VZIP     : Vector Zip (Interleave)
3182
3183 def  VZIPd8   : N2VDShuffle<0b00, 0b00011, "vzip", "8">;
3184 def  VZIPd16  : N2VDShuffle<0b01, 0b00011, "vzip", "16">;
3185 def  VZIPd32  : N2VDShuffle<0b10, 0b00011, "vzip", "32">;
3186
3187 def  VZIPq8   : N2VQShuffle<0b00, 0b00011, IIC_VPERMQ3, "vzip", "8">;
3188 def  VZIPq16  : N2VQShuffle<0b01, 0b00011, IIC_VPERMQ3, "vzip", "16">;
3189 def  VZIPq32  : N2VQShuffle<0b10, 0b00011, IIC_VPERMQ3, "vzip", "32">;
3190
3191 // Vector Table Lookup and Table Extension.
3192
3193 //   VTBL     : Vector Table Lookup
3194 def  VTBL1
3195   : N3V<1,1,0b11,0b1000,0,0, (outs DPR:$dst),
3196         (ins DPR:$tbl1, DPR:$src), IIC_VTB1,
3197         "vtbl", "8", "$dst, \\{$tbl1\\}, $src", "",
3198         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl1 DPR:$tbl1, DPR:$src)))]>;
3199 let hasExtraSrcRegAllocReq = 1 in {
3200 def  VTBL2
3201   : N3V<1,1,0b11,0b1001,0,0, (outs DPR:$dst),
3202         (ins DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTB2,
3203         "vtbl", "8", "$dst, \\{$tbl1, $tbl2\\}, $src", "",
3204         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl2
3205                                DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
3206 def  VTBL3
3207   : N3V<1,1,0b11,0b1010,0,0, (outs DPR:$dst),
3208         (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTB3,
3209         "vtbl", "8", "$dst, \\{$tbl1, $tbl2, $tbl3\\}, $src", "",
3210         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl3
3211                                DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
3212 def  VTBL4
3213   : N3V<1,1,0b11,0b1011,0,0, (outs DPR:$dst),
3214         (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTB4,
3215         "vtbl", "8", "$dst, \\{$tbl1, $tbl2, $tbl3, $tbl4\\}, $src", "",
3216         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl4 DPR:$tbl1, DPR:$tbl2,
3217                                DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
3218 } // hasExtraSrcRegAllocReq = 1
3219
3220 //   VTBX     : Vector Table Extension
3221 def  VTBX1
3222   : N3V<1,1,0b11,0b1000,1,0, (outs DPR:$dst),
3223         (ins DPR:$orig, DPR:$tbl1, DPR:$src), IIC_VTBX1,
3224         "vtbx", "8", "$dst, \\{$tbl1\\}, $src", "$orig = $dst",
3225         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx1
3226                                DPR:$orig, DPR:$tbl1, DPR:$src)))]>;
3227 let hasExtraSrcRegAllocReq = 1 in {
3228 def  VTBX2
3229   : N3V<1,1,0b11,0b1001,1,0, (outs DPR:$dst),
3230         (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTBX2,
3231         "vtbx", "8", "$dst, \\{$tbl1, $tbl2\\}, $src", "$orig = $dst",
3232         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx2
3233                                DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
3234 def  VTBX3
3235   : N3V<1,1,0b11,0b1010,1,0, (outs DPR:$dst),
3236         (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTBX3,
3237         "vtbx", "8", "$dst, \\{$tbl1, $tbl2, $tbl3\\}, $src", "$orig = $dst",
3238         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx3 DPR:$orig, DPR:$tbl1,
3239                                DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
3240 def  VTBX4
3241   : N3V<1,1,0b11,0b1011,1,0, (outs DPR:$dst), (ins DPR:$orig, DPR:$tbl1,
3242         DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTBX4,
3243         "vtbx", "8", "$dst, \\{$tbl1, $tbl2, $tbl3, $tbl4\\}, $src",
3244         "$orig = $dst",
3245         [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx4 DPR:$orig, DPR:$tbl1,
3246                                DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
3247 } // hasExtraSrcRegAllocReq = 1
3248
3249 //===----------------------------------------------------------------------===//
3250 // NEON instructions for single-precision FP math
3251 //===----------------------------------------------------------------------===//
3252
3253 class N2VSPat<SDNode OpNode, ValueType ResTy, ValueType OpTy, NeonI Inst>
3254   : NEONFPPat<(ResTy (OpNode SPR:$a)),
3255               (EXTRACT_SUBREG (OpTy (Inst (INSERT_SUBREG (OpTy (IMPLICIT_DEF)),
3256                                                        SPR:$a, arm_ssubreg_0))),
3257                               arm_ssubreg_0)>;
3258
3259 class N3VSPat<SDNode OpNode, NeonI Inst>
3260   : NEONFPPat<(f32 (OpNode SPR:$a, SPR:$b)),
3261               (EXTRACT_SUBREG (v2f32
3262                                  (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3263                                                       SPR:$a, arm_ssubreg_0),
3264                                        (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3265                                                       SPR:$b, arm_ssubreg_0))),
3266                               arm_ssubreg_0)>;
3267
3268 class N3VSMulOpPat<SDNode MulNode, SDNode OpNode, NeonI Inst>
3269   : NEONFPPat<(f32 (OpNode SPR:$acc, (f32 (MulNode SPR:$a, SPR:$b)))),
3270               (EXTRACT_SUBREG (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3271                                                    SPR:$acc, arm_ssubreg_0),
3272                                     (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3273                                                    SPR:$a, arm_ssubreg_0),
3274                                     (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3275                                                    SPR:$b, arm_ssubreg_0)),
3276                               arm_ssubreg_0)>;
3277
3278 // These need separate instructions because they must use DPR_VFP2 register
3279 // class which have SPR sub-registers.
3280
3281 // Vector Add Operations used for single-precision FP
3282 let neverHasSideEffects = 1 in
3283 def VADDfd_sfp : N3VS<0,0,0b00,0b1101,0, "vadd", "f32", v2f32, v2f32, fadd, 1>;
3284 def : N3VSPat<fadd, VADDfd_sfp>;
3285
3286 // Vector Sub Operations used for single-precision FP
3287 let neverHasSideEffects = 1 in
3288 def VSUBfd_sfp : N3VS<0,0,0b10,0b1101,0, "vsub", "f32", v2f32, v2f32, fsub, 0>;
3289 def : N3VSPat<fsub, VSUBfd_sfp>;
3290
3291 // Vector Multiply Operations used for single-precision FP
3292 let neverHasSideEffects = 1 in
3293 def VMULfd_sfp : N3VS<1,0,0b00,0b1101,1, "vmul", "f32", v2f32, v2f32, fmul, 1>;
3294 def : N3VSPat<fmul, VMULfd_sfp>;
3295
3296 // Vector Multiply-Accumulate/Subtract used for single-precision FP
3297 // vml[as].f32 can cause 4-8 cycle stalls in following ASIMD instructions, so
3298 // we want to avoid them for now. e.g., alternating vmla/vadd instructions.
3299
3300 //let neverHasSideEffects = 1 in
3301 //def VMLAfd_sfp : N3VSMulOp<0,0,0b00,0b1101,1, IIC_VMACD, "vmla", "f32",
3302 //                            v2f32, fmul, fadd>;
3303 //def : N3VSMulOpPat<fmul, fadd, VMLAfd_sfp>;
3304
3305 //let neverHasSideEffects = 1 in
3306 //def VMLSfd_sfp : N3VSMulOp<0,0,0b10,0b1101,1, IIC_VMACD, "vmls", "f32",
3307 //                            v2f32, fmul, fsub>;
3308 //def : N3VSMulOpPat<fmul, fsub, VMLSfd_sfp>;
3309
3310 // Vector Absolute used for single-precision FP
3311 let neverHasSideEffects = 1 in
3312 def  VABSfd_sfp : N2V<0b11, 0b11, 0b10, 0b01, 0b01110, 0, 0,
3313                       (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), IIC_VUNAD,
3314                       "vabs", "f32", "$dst, $src", "", []>;
3315 def : N2VSPat<fabs, f32, v2f32, VABSfd_sfp>;
3316
3317 // Vector Negate used for single-precision FP
3318 let neverHasSideEffects = 1 in
3319 def  VNEGfd_sfp : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
3320                       (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), IIC_VUNAD,
3321                       "vneg", "f32", "$dst, $src", "", []>;
3322 def : N2VSPat<fneg, f32, v2f32, VNEGfd_sfp>;
3323
3324 // Vector Maximum used for single-precision FP
3325 let neverHasSideEffects = 1 in
3326 def VMAXfd_sfp : N3V<0, 0, 0b00, 0b1111, 0, 0, (outs DPR_VFP2:$dst),
3327                      (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
3328                      "vmax", "f32", "$dst, $src1, $src2", "", []>;
3329 def : N3VSPat<NEONfmax, VMAXfd_sfp>;
3330
3331 // Vector Minimum used for single-precision FP
3332 let neverHasSideEffects = 1 in
3333 def VMINfd_sfp : N3V<0, 0, 0b00, 0b1111, 0, 0, (outs DPR_VFP2:$dst),
3334                      (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
3335                      "vmin", "f32", "$dst, $src1, $src2", "", []>;
3336 def : N3VSPat<NEONfmin, VMINfd_sfp>;
3337
3338 // Vector Convert between single-precision FP and integer
3339 let neverHasSideEffects = 1 in
3340 def  VCVTf2sd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3341                          v2i32, v2f32, fp_to_sint>;
3342 def : N2VSPat<arm_ftosi, f32, v2f32, VCVTf2sd_sfp>;
3343
3344 let neverHasSideEffects = 1 in
3345 def  VCVTf2ud_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3346                          v2i32, v2f32, fp_to_uint>;
3347 def : N2VSPat<arm_ftoui, f32, v2f32, VCVTf2ud_sfp>;
3348
3349 let neverHasSideEffects = 1 in
3350 def  VCVTs2fd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3351                          v2f32, v2i32, sint_to_fp>;
3352 def : N2VSPat<arm_sitof, f32, v2i32, VCVTs2fd_sfp>;
3353
3354 let neverHasSideEffects = 1 in
3355 def  VCVTu2fd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3356                          v2f32, v2i32, uint_to_fp>;
3357 def : N2VSPat<arm_uitof, f32, v2i32, VCVTu2fd_sfp>;
3358
3359 //===----------------------------------------------------------------------===//
3360 // Non-Instruction Patterns
3361 //===----------------------------------------------------------------------===//
3362
3363 // bit_convert
3364 def : Pat<(v1i64 (bitconvert (v2i32 DPR:$src))), (v1i64 DPR:$src)>;
3365 def : Pat<(v1i64 (bitconvert (v4i16 DPR:$src))), (v1i64 DPR:$src)>;
3366 def : Pat<(v1i64 (bitconvert (v8i8  DPR:$src))), (v1i64 DPR:$src)>;
3367 def : Pat<(v1i64 (bitconvert (f64   DPR:$src))), (v1i64 DPR:$src)>;
3368 def : Pat<(v1i64 (bitconvert (v2f32 DPR:$src))), (v1i64 DPR:$src)>;
3369 def : Pat<(v2i32 (bitconvert (v1i64 DPR:$src))), (v2i32 DPR:$src)>;
3370 def : Pat<(v2i32 (bitconvert (v4i16 DPR:$src))), (v2i32 DPR:$src)>;
3371 def : Pat<(v2i32 (bitconvert (v8i8  DPR:$src))), (v2i32 DPR:$src)>;
3372 def : Pat<(v2i32 (bitconvert (f64   DPR:$src))), (v2i32 DPR:$src)>;
3373 def : Pat<(v2i32 (bitconvert (v2f32 DPR:$src))), (v2i32 DPR:$src)>;
3374 def : Pat<(v4i16 (bitconvert (v1i64 DPR:$src))), (v4i16 DPR:$src)>;
3375 def : Pat<(v4i16 (bitconvert (v2i32 DPR:$src))), (v4i16 DPR:$src)>;
3376 def : Pat<(v4i16 (bitconvert (v8i8  DPR:$src))), (v4i16 DPR:$src)>;
3377 def : Pat<(v4i16 (bitconvert (f64   DPR:$src))), (v4i16 DPR:$src)>;
3378 def : Pat<(v4i16 (bitconvert (v2f32 DPR:$src))), (v4i16 DPR:$src)>;
3379 def : Pat<(v8i8  (bitconvert (v1i64 DPR:$src))), (v8i8  DPR:$src)>;
3380 def : Pat<(v8i8  (bitconvert (v2i32 DPR:$src))), (v8i8  DPR:$src)>;
3381 def : Pat<(v8i8  (bitconvert (v4i16 DPR:$src))), (v8i8  DPR:$src)>;
3382 def : Pat<(v8i8  (bitconvert (f64   DPR:$src))), (v8i8  DPR:$src)>;
3383 def : Pat<(v8i8  (bitconvert (v2f32 DPR:$src))), (v8i8  DPR:$src)>;
3384 def : Pat<(f64   (bitconvert (v1i64 DPR:$src))), (f64   DPR:$src)>;
3385 def : Pat<(f64   (bitconvert (v2i32 DPR:$src))), (f64   DPR:$src)>;
3386 def : Pat<(f64   (bitconvert (v4i16 DPR:$src))), (f64   DPR:$src)>;
3387 def : Pat<(f64   (bitconvert (v8i8  DPR:$src))), (f64   DPR:$src)>;
3388 def : Pat<(f64   (bitconvert (v2f32 DPR:$src))), (f64   DPR:$src)>;
3389 def : Pat<(v2f32 (bitconvert (f64   DPR:$src))), (v2f32 DPR:$src)>;
3390 def : Pat<(v2f32 (bitconvert (v1i64 DPR:$src))), (v2f32 DPR:$src)>;
3391 def : Pat<(v2f32 (bitconvert (v2i32 DPR:$src))), (v2f32 DPR:$src)>;
3392 def : Pat<(v2f32 (bitconvert (v4i16 DPR:$src))), (v2f32 DPR:$src)>;
3393 def : Pat<(v2f32 (bitconvert (v8i8  DPR:$src))), (v2f32 DPR:$src)>;
3394
3395 def : Pat<(v2i64 (bitconvert (v4i32 QPR:$src))), (v2i64 QPR:$src)>;
3396 def : Pat<(v2i64 (bitconvert (v8i16 QPR:$src))), (v2i64 QPR:$src)>;
3397 def : Pat<(v2i64 (bitconvert (v16i8 QPR:$src))), (v2i64 QPR:$src)>;
3398 def : Pat<(v2i64 (bitconvert (v2f64 QPR:$src))), (v2i64 QPR:$src)>;
3399 def : Pat<(v2i64 (bitconvert (v4f32 QPR:$src))), (v2i64 QPR:$src)>;
3400 def : Pat<(v4i32 (bitconvert (v2i64 QPR:$src))), (v4i32 QPR:$src)>;
3401 def : Pat<(v4i32 (bitconvert (v8i16 QPR:$src))), (v4i32 QPR:$src)>;
3402 def : Pat<(v4i32 (bitconvert (v16i8 QPR:$src))), (v4i32 QPR:$src)>;
3403 def : Pat<(v4i32 (bitconvert (v2f64 QPR:$src))), (v4i32 QPR:$src)>;
3404 def : Pat<(v4i32 (bitconvert (v4f32 QPR:$src))), (v4i32 QPR:$src)>;
3405 def : Pat<(v8i16 (bitconvert (v2i64 QPR:$src))), (v8i16 QPR:$src)>;
3406 def : Pat<(v8i16 (bitconvert (v4i32 QPR:$src))), (v8i16 QPR:$src)>;
3407 def : Pat<(v8i16 (bitconvert (v16i8 QPR:$src))), (v8i16 QPR:$src)>;
3408 def : Pat<(v8i16 (bitconvert (v2f64 QPR:$src))), (v8i16 QPR:$src)>;
3409 def : Pat<(v8i16 (bitconvert (v4f32 QPR:$src))), (v8i16 QPR:$src)>;
3410 def : Pat<(v16i8 (bitconvert (v2i64 QPR:$src))), (v16i8 QPR:$src)>;
3411 def : Pat<(v16i8 (bitconvert (v4i32 QPR:$src))), (v16i8 QPR:$src)>;
3412 def : Pat<(v16i8 (bitconvert (v8i16 QPR:$src))), (v16i8 QPR:$src)>;
3413 def : Pat<(v16i8 (bitconvert (v2f64 QPR:$src))), (v16i8 QPR:$src)>;
3414 def : Pat<(v16i8 (bitconvert (v4f32 QPR:$src))), (v16i8 QPR:$src)>;
3415 def : Pat<(v4f32 (bitconvert (v2i64 QPR:$src))), (v4f32 QPR:$src)>;
3416 def : Pat<(v4f32 (bitconvert (v4i32 QPR:$src))), (v4f32 QPR:$src)>;
3417 def : Pat<(v4f32 (bitconvert (v8i16 QPR:$src))), (v4f32 QPR:$src)>;
3418 def : Pat<(v4f32 (bitconvert (v16i8 QPR:$src))), (v4f32 QPR:$src)>;
3419 def : Pat<(v4f32 (bitconvert (v2f64 QPR:$src))), (v4f32 QPR:$src)>;
3420 def : Pat<(v2f64 (bitconvert (v2i64 QPR:$src))), (v2f64 QPR:$src)>;
3421 def : Pat<(v2f64 (bitconvert (v4i32 QPR:$src))), (v2f64 QPR:$src)>;
3422 def : Pat<(v2f64 (bitconvert (v8i16 QPR:$src))), (v2f64 QPR:$src)>;
3423 def : Pat<(v2f64 (bitconvert (v16i8 QPR:$src))), (v2f64 QPR:$src)>;
3424 def : Pat<(v2f64 (bitconvert (v4f32 QPR:$src))), (v2f64 QPR:$src)>;