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