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