lib/Target/ARM/ARMInstrMVE.td

   1 //===-- ARMInstrMVE.td - MVE support for ARM ---------------*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file describes the ARM MVE instruction set.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 class ExpandImmAsmOp<string shift> : AsmOperandClass {
  14   let Name = !strconcat("ExpandImm", shift);
  15   let PredicateMethod = !strconcat("isExpImm<", shift, ">");
  16   let RenderMethod = "addImmOperands";
  17 }
  18 class InvertedExpandImmAsmOp<string shift, string size> : AsmOperandClass {
  19   let Name = !strconcat("InvertedExpandImm", shift, "_", size);
  20   let PredicateMethod = !strconcat("isInvertedExpImm<", shift, ",", size, ">");
  21   let RenderMethod = "addImmOperands";
  22 }
  23
  24 class ExpandImm<string shift> : Operand<i32> {
  25   let ParserMatchClass = ExpandImmAsmOp<shift>;
  26   let EncoderMethod = !strconcat("getExpandedImmOpValue<",shift,",false>");
  27   let DecoderMethod = !strconcat("DecodeExpandedImmOperand<",shift,">");
  28   let PrintMethod = "printExpandedImmOperand";
  29 }
  30 class InvertedExpandImm<string shift, string size> : Operand<i32> {
  31   let ParserMatchClass = InvertedExpandImmAsmOp<shift, size>;
  32   let EncoderMethod = !strconcat("getExpandedImmOpValue<",shift,",true>");
  33   let PrintMethod = "printExpandedImmOperand";
  34   // No decoder method needed, because this operand type is only used
  35   // by aliases (VAND and VORN)
  36 }
  37
  38 def expzero00 : ExpandImm<"0">;
  39 def expzero08 : ExpandImm<"8">;
  40 def expzero16 : ExpandImm<"16">;
  41 def expzero24 : ExpandImm<"24">;
  42
  43 def expzero00inv16 : InvertedExpandImm<"0", "16">;
  44 def expzero08inv16 : InvertedExpandImm<"8", "16">;
  45
  46 def expzero00inv32 : InvertedExpandImm<"0", "32">;
  47 def expzero08inv32 : InvertedExpandImm<"8", "32">;
  48 def expzero16inv32 : InvertedExpandImm<"16", "32">;
  49 def expzero24inv32 : InvertedExpandImm<"24", "32">;
  50
  51 // VPT condition mask
  52 def vpt_mask : Operand<i32> {
  53   let PrintMethod = "printVPTMask";
  54   let ParserMatchClass = it_mask_asmoperand;
  55   let EncoderMethod = "getVPTMaskOpValue";
  56   let DecoderMethod = "DecodeVPTMaskOperand";
  57 }
  58
  59 // VPT/VCMP restricted predicate for sign invariant types
  60 def pred_restricted_i_asmoperand : AsmOperandClass {
  61   let Name = "CondCodeRestrictedI";
  62   let RenderMethod = "addITCondCodeOperands";
  63   let PredicateMethod = "isITCondCodeRestrictedI";
  64   let ParserMethod = "parseITCondCode";
  65   let DiagnosticString = "condition code for sign-independent integer "#
  66                          "comparison must be EQ or NE";
  67 }
  68
  69 // VPT/VCMP restricted predicate for signed types
  70 def pred_restricted_s_asmoperand : AsmOperandClass {
  71   let Name = "CondCodeRestrictedS";
  72   let RenderMethod = "addITCondCodeOperands";
  73   let PredicateMethod = "isITCondCodeRestrictedS";
  74   let ParserMethod = "parseITCondCode";
  75   let DiagnosticString = "condition code for signed integer "#
  76                          "comparison must be EQ, NE, LT, GT, LE or GE";
  77 }
  78
  79 // VPT/VCMP restricted predicate for unsigned types
  80 def pred_restricted_u_asmoperand : AsmOperandClass {
  81   let Name = "CondCodeRestrictedU";
  82   let RenderMethod = "addITCondCodeOperands";
  83   let PredicateMethod = "isITCondCodeRestrictedU";
  84   let ParserMethod = "parseITCondCode";
  85   let DiagnosticString = "condition code for unsigned integer "#
  86                          "comparison must be EQ, NE, HS or HI";
  87 }
  88
  89 // VPT/VCMP restricted predicate for floating point
  90 def pred_restricted_fp_asmoperand : AsmOperandClass {
  91   let Name = "CondCodeRestrictedFP";
  92   let RenderMethod = "addITCondCodeOperands";
  93   let PredicateMethod = "isITCondCodeRestrictedFP";
  94   let ParserMethod = "parseITCondCode";
  95   let DiagnosticString = "condition code for floating-point "#
  96                          "comparison must be EQ, NE, LT, GT, LE or GE";
  97 }
  98
  99 class VCMPPredicateOperand : Operand<i32>;
 100
 101 def pred_basic_i : VCMPPredicateOperand {
 102   let PrintMethod = "printMandatoryRestrictedPredicateOperand";
 103   let ParserMatchClass = pred_restricted_i_asmoperand;
 104   let DecoderMethod = "DecodeRestrictedIPredicateOperand";
 105   let EncoderMethod = "getRestrictedCondCodeOpValue";
 106 }
 107
 108 def pred_basic_u : VCMPPredicateOperand {
 109   let PrintMethod = "printMandatoryRestrictedPredicateOperand";
 110   let ParserMatchClass = pred_restricted_u_asmoperand;
 111   let DecoderMethod = "DecodeRestrictedUPredicateOperand";
 112   let EncoderMethod = "getRestrictedCondCodeOpValue";
 113 }
 114
 115 def pred_basic_s : VCMPPredicateOperand {
 116   let PrintMethod = "printMandatoryRestrictedPredicateOperand";
 117   let ParserMatchClass = pred_restricted_s_asmoperand;
 118   let DecoderMethod = "DecodeRestrictedSPredicateOperand";
 119   let EncoderMethod = "getRestrictedCondCodeOpValue";
 120 }
 121
 122 def pred_basic_fp : VCMPPredicateOperand {
 123   let PrintMethod = "printMandatoryRestrictedPredicateOperand";
 124   let ParserMatchClass = pred_restricted_fp_asmoperand;
 125   let DecoderMethod = "DecodeRestrictedFPPredicateOperand";
 126   let EncoderMethod = "getRestrictedCondCodeOpValue";
 127 }
 128
 129 // Register list operands for interleaving load/stores
 130 def VecList2QAsmOperand : AsmOperandClass {
 131   let Name = "VecListTwoMQ";
 132   let ParserMethod = "parseVectorList";
 133   let RenderMethod = "addMVEVecListOperands";
 134   let DiagnosticString = "operand must be a list of two consecutive "#
 135                          "q-registers in range [q0,q7]";
 136 }
 137
 138 def VecList2Q : RegisterOperand<QQPR, "printMVEVectorListTwoQ"> {
 139   let ParserMatchClass = VecList2QAsmOperand;
 140   let PrintMethod = "printMVEVectorList<2>";
 141 }
 142
 143 def VecList4QAsmOperand : AsmOperandClass {
 144   let Name = "VecListFourMQ";
 145   let ParserMethod = "parseVectorList";
 146   let RenderMethod = "addMVEVecListOperands";
 147   let DiagnosticString = "operand must be a list of four consecutive "#
 148                          "q-registers in range [q0,q7]";
 149 }
 150
 151 def VecList4Q : RegisterOperand<QQQQPR, "printMVEVectorListFourQ"> {
 152   let ParserMatchClass = VecList4QAsmOperand;
 153   let PrintMethod = "printMVEVectorList<4>";
 154 }
 155
 156 // taddrmode_imm7  := reg[r0-r7] +/- (imm7 << shift)
 157 class TMemImm7ShiftOffsetAsmOperand<int shift> : AsmOperandClass {
 158   let Name = "TMemImm7Shift"#shift#"Offset";
 159   let PredicateMethod = "isMemImm7ShiftedOffset<"#shift#",ARM::tGPRRegClassID>";
 160   let RenderMethod = "addMemImmOffsetOperands";
 161 }
 162
 163 class taddrmode_imm7<int shift> : MemOperand,
 164     ComplexPattern<i32, 2, "SelectTAddrModeImm7<"#shift#">", []>  {
 165   let ParserMatchClass = TMemImm7ShiftOffsetAsmOperand<shift>;
 166   // They are printed the same way as the T2 imm8 version
 167   let PrintMethod = "printT2AddrModeImm8Operand<false>";
 168   // This can also be the same as the T2 version.
 169   let EncoderMethod = "getT2AddrModeImmOpValue<7,"#shift#">";
 170   let DecoderMethod = "DecodeTAddrModeImm7<"#shift#">";
 171   let MIOperandInfo = (ops tGPR:$base, i32imm:$offsimm);
 172 }
 173
 174 // t2addrmode_imm7  := reg +/- (imm7)
 175 class MemImm7ShiftOffsetAsmOperand<int shift> : AsmOperandClass {
 176   let Name = "MemImm7Shift"#shift#"Offset";
 177   let PredicateMethod = "isMemImm7ShiftedOffset<" # shift #
 178                         ",ARM::GPRnopcRegClassID>";
 179   let RenderMethod = "addMemImmOffsetOperands";
 180 }
 181
 182 def MemImm7Shift0OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<0>;
 183 def MemImm7Shift1OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<1>;
 184 def MemImm7Shift2OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<2>;
 185 class T2AddrMode_Imm7<int shift> : MemOperand,
 186       ComplexPattern<i32, 2, "SelectT2AddrModeImm7<"#shift#">", []> {
 187   let EncoderMethod = "getT2AddrModeImmOpValue<7,"#shift#">";
 188   let DecoderMethod = "DecodeT2AddrModeImm7<"#shift#", 0>";
 189   let ParserMatchClass =
 190     !cast<AsmOperandClass>("MemImm7Shift"#shift#"OffsetAsmOperand");
 191   let MIOperandInfo = (ops GPRnopc:$base, i32imm:$offsimm);
 192 }
 193
 194 class t2addrmode_imm7<int shift> : T2AddrMode_Imm7<shift> {
 195   // They are printed the same way as the imm8 version
 196   let PrintMethod = "printT2AddrModeImm8Operand<false>";
 197 }
 198
 199 class MemImm7ShiftOffsetWBAsmOperand<int shift> : AsmOperandClass {
 200   let Name = "MemImm7Shift"#shift#"OffsetWB";
 201   let PredicateMethod = "isMemImm7ShiftedOffset<" # shift #
 202                         ",ARM::rGPRRegClassID>";
 203   let RenderMethod = "addMemImmOffsetOperands";
 204 }
 205
 206 def MemImm7Shift0OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<0>;
 207 def MemImm7Shift1OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<1>;
 208 def MemImm7Shift2OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<2>;
 209
 210 class t2addrmode_imm7_pre<int shift> : T2AddrMode_Imm7<shift> {
 211   // They are printed the same way as the imm8 version
 212   let PrintMethod = "printT2AddrModeImm8Operand<true>";
 213   let ParserMatchClass =
 214     !cast<AsmOperandClass>("MemImm7Shift"#shift#"OffsetWBAsmOperand");
 215   let DecoderMethod = "DecodeT2AddrModeImm7<"#shift#", 1>";
 216   let MIOperandInfo = (ops rGPR:$base, i32imm:$offsim);
 217 }
 218
 219 class t2am_imm7shiftOffsetAsmOperand<int shift>
 220   : AsmOperandClass { let Name = "Imm7Shift"#shift; }
 221 def t2am_imm7shift0OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<0>;
 222 def t2am_imm7shift1OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<1>;
 223 def t2am_imm7shift2OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<2>;
 224
 225 class t2am_imm7_offset<int shift> : MemOperand,
 226       ComplexPattern<i32, 1, "SelectT2AddrModeImm7Offset<"#shift#">",
 227                      [], [SDNPWantRoot]> {
 228   // They are printed the same way as the imm8 version
 229   let PrintMethod = "printT2AddrModeImm8OffsetOperand";
 230   let ParserMatchClass =
 231     !cast<AsmOperandClass>("t2am_imm7shift"#shift#"OffsetAsmOperand");
 232   let EncoderMethod = "getT2ScaledImmOpValue<7,"#shift#">";
 233   let DecoderMethod = "DecodeT2Imm7<"#shift#">";
 234 }
 235
 236 // Operands for gather/scatter loads of the form [Rbase, Qoffsets]
 237 class MemRegRQOffsetAsmOperand<int shift> : AsmOperandClass {
 238   let Name = "MemRegRQS"#shift#"Offset";
 239   let PredicateMethod = "isMemRegRQOffset<"#shift#">";
 240   let RenderMethod = "addMemRegRQOffsetOperands";
 241 }
 242
 243 def MemRegRQS0OffsetAsmOperand : MemRegRQOffsetAsmOperand<0>;
 244 def MemRegRQS1OffsetAsmOperand : MemRegRQOffsetAsmOperand<1>;
 245 def MemRegRQS2OffsetAsmOperand : MemRegRQOffsetAsmOperand<2>;
 246 def MemRegRQS3OffsetAsmOperand : MemRegRQOffsetAsmOperand<3>;
 247
 248 // mve_addr_rq_shift  := reg + vreg{ << UXTW #shift}
 249 class mve_addr_rq_shift<int shift> : MemOperand {
 250   let EncoderMethod = "getMveAddrModeRQOpValue";
 251   let PrintMethod = "printMveAddrModeRQOperand<"#shift#">";
 252   let ParserMatchClass =
 253     !cast<AsmOperandClass>("MemRegRQS"#shift#"OffsetAsmOperand");
 254   let DecoderMethod = "DecodeMveAddrModeRQ";
 255   let MIOperandInfo = (ops GPRnopc:$base, MQPR:$offsreg);
 256 }
 257
 258 class MemRegQOffsetAsmOperand<int shift> : AsmOperandClass {
 259   let Name = "MemRegQS"#shift#"Offset";
 260   let PredicateMethod = "isMemRegQOffset<"#shift#">";
 261   let RenderMethod = "addMemImmOffsetOperands";
 262 }
 263
 264 def MemRegQS2OffsetAsmOperand : MemRegQOffsetAsmOperand<2>;
 265 def MemRegQS3OffsetAsmOperand : MemRegQOffsetAsmOperand<3>;
 266
 267 // mve_addr_q_shift  := vreg {+ #imm7s2/4}
 268 class mve_addr_q_shift<int shift> : MemOperand {
 269   let EncoderMethod = "getMveAddrModeQOpValue<"#shift#">";
 270   // Can be printed same way as other reg + imm operands
 271   let PrintMethod = "printT2AddrModeImm8Operand<false>";
 272   let ParserMatchClass =
 273     !cast<AsmOperandClass>("MemRegQS"#shift#"OffsetAsmOperand");
 274   let DecoderMethod = "DecodeMveAddrModeQ<"#shift#">";
 275   let MIOperandInfo = (ops MQPR:$base, i32imm:$imm);
 276 }
 277
 278 // --------- Start of base classes for the instructions themselves
 279
 280 class MVE_MI<dag oops, dag iops, InstrItinClass itin, string asm,
 281              string ops, string cstr, list<dag> pattern>
 282   : Thumb2XI<oops, iops, AddrModeNone, 4, itin, !strconcat(asm, "\t", ops), cstr,
 283              pattern>,
 284     Requires<[HasMVEInt]> {
 285   let D = MVEDomain;
 286   let DecoderNamespace = "MVE";
 287 }
 288
 289 // MVE_p is used for most predicated instructions, to add the cluster
 290 // of input operands that provides the VPT suffix (none, T or E) and
 291 // the input predicate register.
 292 class MVE_p<dag oops, dag iops, InstrItinClass itin, string iname,
 293             string suffix, string ops, vpred_ops vpred, string cstr,
 294             list<dag> pattern=[]>
 295   : MVE_MI<oops, !con(iops, (ins vpred:$vp)), itin,
 296            // If the instruction has a suffix, like vadd.f32, then the
 297            // VPT predication suffix goes before the dot, so the full
 298            // name has to be "vadd${vp}.f32".
 299            !strconcat(iname, "${vp}",
 300                       !if(!eq(suffix, ""), "", !strconcat(".", suffix))),
 301            ops, !strconcat(cstr, vpred.vpred_constraint), pattern> {
 302   let Inst{31-29} = 0b111;
 303   let Inst{27-26} = 0b11;
 304 }
 305
 306 class MVE_f<dag oops, dag iops, InstrItinClass itin, string iname,
 307             string suffix, string ops, vpred_ops vpred, string cstr,
 308             list<dag> pattern=[]>
 309   : MVE_p<oops, iops, itin, iname, suffix, ops, vpred, cstr, pattern> {
 310   let Predicates = [HasMVEFloat];
 311 }
 312
 313 class MVE_MI_with_pred<dag oops, dag iops, InstrItinClass itin, string asm,
 314                        string ops, string cstr, list<dag> pattern>
 315   : Thumb2I<oops, iops, AddrModeNone, 4, itin, asm, !strconcat("\t", ops), cstr,
 316              pattern>,
 317     Requires<[HasV8_1MMainline, HasMVEInt]> {
 318   let D = MVEDomain;
 319   let DecoderNamespace = "MVE";
 320 }
 321
 322 class MVE_VMOV_lane_base<dag oops, dag iops, InstrItinClass itin, string asm,
 323                          string suffix, string ops, string cstr,
 324                          list<dag> pattern>
 325   : Thumb2I<oops, iops, AddrModeNone, 4, itin, asm,
 326             !if(!eq(suffix, ""), "", "." # suffix) # "\t" # ops,
 327             cstr, pattern>,
 328     Requires<[HasV8_1MMainline, HasMVEInt]> {
 329   let D = MVEDomain;
 330   let DecoderNamespace = "MVE";
 331 }
 332
 333 class MVE_ScalarShift<string iname, dag oops, dag iops, string asm, string cstr,
 334             list<dag> pattern=[]>
 335   : MVE_MI_with_pred<oops, iops, NoItinerary, iname, asm, cstr, pattern> {
 336   let Inst{31-20} = 0b111010100101;
 337   let Inst{8} = 0b1;
 338
 339 }
 340
 341 class MVE_ScalarShiftSingleReg<string iname, dag iops, string asm, string cstr,
 342                     list<dag> pattern=[]>
 343   : MVE_ScalarShift<iname, (outs rGPR:$RdaDest), iops, asm, cstr, pattern> {
 344   bits<4> RdaDest;
 345
 346   let Inst{19-16} = RdaDest{3-0};
 347 }
 348
 349 class MVE_ScalarShiftSRegImm<string iname, bits<2> op5_4, list<dag> pattern=[]>
 350   : MVE_ScalarShiftSingleReg<iname, (ins rGPR:$RdaSrc, long_shift:$imm),
 351                      "$RdaSrc, $imm", "$RdaDest = $RdaSrc", pattern> {
 352   bits<5> imm;
 353
 354   let Inst{15} = 0b0;
 355   let Inst{14-12} = imm{4-2};
 356   let Inst{11-8} = 0b1111;
 357   let Inst{7-6} = imm{1-0};
 358   let Inst{5-4} = op5_4{1-0};
 359   let Inst{3-0} = 0b1111;
 360 }
 361
 362 def MVE_SQSHL : MVE_ScalarShiftSRegImm<"sqshl", 0b11>;
 363 def MVE_SRSHR : MVE_ScalarShiftSRegImm<"srshr", 0b10>;
 364 def MVE_UQSHL : MVE_ScalarShiftSRegImm<"uqshl", 0b00>;
 365 def MVE_URSHR : MVE_ScalarShiftSRegImm<"urshr", 0b01>;
 366
 367 class MVE_ScalarShiftSRegReg<string iname, bits<2> op5_4, list<dag> pattern=[]>
 368   : MVE_ScalarShiftSingleReg<iname, (ins rGPR:$RdaSrc, rGPR:$Rm),
 369                      "$RdaSrc, $Rm", "$RdaDest = $RdaSrc", pattern> {
 370   bits<4> Rm;
 371
 372   let Inst{15-12} = Rm{3-0};
 373   let Inst{11-8} = 0b1111;
 374   let Inst{7-6} = 0b00;
 375   let Inst{5-4} = op5_4{1-0};
 376   let Inst{3-0} = 0b1101;
 377
 378   let Unpredictable{8-6} = 0b111;
 379 }
 380
 381 def MVE_SQRSHR : MVE_ScalarShiftSRegReg<"sqrshr", 0b10>;
 382 def MVE_UQRSHL : MVE_ScalarShiftSRegReg<"uqrshl", 0b00>;
 383
 384 class MVE_ScalarShiftDoubleReg<string iname, dag iops, string asm,
 385                                string cstr, list<dag> pattern=[]>
 386   : MVE_ScalarShift<iname, (outs tGPREven:$RdaLo, tGPROdd:$RdaHi),
 387                     iops, asm, cstr, pattern> {
 388   bits<4> RdaLo;
 389   bits<4> RdaHi;
 390
 391   let Inst{19-17} = RdaLo{3-1};
 392   let Inst{11-9} = RdaHi{3-1};
 393 }
 394
 395 class MVE_ScalarShiftDRegImm<string iname, bits<2> op5_4, bit op16,
 396                              list<dag> pattern=[]>
 397   : MVE_ScalarShiftDoubleReg<
 398       iname, (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, long_shift:$imm),
 399       "$RdaLo, $RdaHi, $imm", "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
 400       pattern> {
 401   bits<5> imm;
 402
 403   let Inst{16} = op16;
 404   let Inst{15} = 0b0;
 405   let Inst{14-12} = imm{4-2};
 406   let Inst{7-6} = imm{1-0};
 407   let Inst{5-4} = op5_4{1-0};
 408   let Inst{3-0} = 0b1111;
 409 }
 410
 411 class MVE_ScalarShiftDRegRegBase<string iname, dag iops, string asm,
 412                                  bit op5, bit op16, list<dag> pattern=[]>
 413   : MVE_ScalarShiftDoubleReg<
 414      iname, iops, asm, "@earlyclobber $RdaHi,@earlyclobber $RdaLo,"
 415                        "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
 416      pattern> {
 417   bits<4> Rm;
 418
 419   let Inst{16} = op16;
 420   let Inst{15-12} = Rm{3-0};
 421   let Inst{6} = 0b0;
 422   let Inst{5} = op5;
 423   let Inst{4} = 0b0;
 424   let Inst{3-0} = 0b1101;
 425
 426   // Custom decoder method because of the following overlapping encodings:
 427   // ASRL and SQRSHR
 428   // LSLL and UQRSHL
 429   // SQRSHRL and SQRSHR
 430   // UQRSHLL and UQRSHL
 431   let DecoderMethod = "DecodeMVEOverlappingLongShift";
 432 }
 433
 434 class MVE_ScalarShiftDRegReg<string iname, bit op5, list<dag> pattern=[]>
 435   : MVE_ScalarShiftDRegRegBase<
 436      iname, (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, rGPR:$Rm),
 437      "$RdaLo, $RdaHi, $Rm", op5, 0b0, pattern> {
 438
 439   let Inst{7} = 0b0;
 440 }
 441
 442 class MVE_ScalarShiftDRegRegWithSat<string iname, bit op5, list<dag> pattern=[]>
 443   : MVE_ScalarShiftDRegRegBase<
 444      iname, (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, rGPR:$Rm, saturateop:$sat),
 445      "$RdaLo, $RdaHi, $sat, $Rm", op5, 0b1, pattern> {
 446   bit sat;
 447
 448   let Inst{7} = sat;
 449 }
 450
 451 def MVE_ASRLr   : MVE_ScalarShiftDRegReg<"asrl",    0b1,  [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
 452                                         (ARMasrl tGPREven:$RdaLo_src,
 453                                         tGPROdd:$RdaHi_src, rGPR:$Rm))]>;
 454 def MVE_ASRLi   : MVE_ScalarShiftDRegImm<"asrl",    0b10, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
 455                                         (ARMasrl tGPREven:$RdaLo_src,
 456                                         tGPROdd:$RdaHi_src, (i32 long_shift:$imm)))]>;
 457 def MVE_LSLLr   : MVE_ScalarShiftDRegReg<"lsll",    0b0,  [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
 458                                         (ARMlsll tGPREven:$RdaLo_src,
 459                                         tGPROdd:$RdaHi_src, rGPR:$Rm))]>;
 460 def MVE_LSLLi   : MVE_ScalarShiftDRegImm<"lsll",    0b00, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
 461                                         (ARMlsll tGPREven:$RdaLo_src,
 462                                         tGPROdd:$RdaHi_src, (i32 long_shift:$imm)))]>;
 463 def MVE_LSRL    : MVE_ScalarShiftDRegImm<"lsrl",    0b01, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
 464                                         (ARMlsrl tGPREven:$RdaLo_src,
 465                                         tGPROdd:$RdaHi_src, (i32 long_shift:$imm)))]>;
 466
 467 def MVE_SQRSHRL : MVE_ScalarShiftDRegRegWithSat<"sqrshrl", 0b1>;
 468 def MVE_SQSHLL  : MVE_ScalarShiftDRegImm<"sqshll",  0b11, 0b1>;
 469 def MVE_SRSHRL  : MVE_ScalarShiftDRegImm<"srshrl",  0b10, 0b1>;
 470
 471 def MVE_UQRSHLL : MVE_ScalarShiftDRegRegWithSat<"uqrshll", 0b0>;
 472 def MVE_UQSHLL  : MVE_ScalarShiftDRegImm<"uqshll",  0b00, 0b1>;
 473 def MVE_URSHRL  : MVE_ScalarShiftDRegImm<"urshrl",  0b01, 0b1>;
 474
 475 // start of mve_rDest instructions
 476
 477 class MVE_rDest<dag oops, dag iops, InstrItinClass itin,
 478                 string iname, string suffix,
 479                 string ops, string cstr, list<dag> pattern=[]>
 480 // Always use vpred_n and not vpred_r: with the output register being
 481 // a GPR and not a vector register, there can't be any question of
 482 // what to put in its inactive lanes.
 483   : MVE_p<oops, iops, itin, iname, suffix, ops, vpred_n, cstr, pattern> {
 484
 485   let Inst{25-23} = 0b101;
 486   let Inst{11-9} = 0b111;
 487   let Inst{4} = 0b0;
 488 }
 489
 490 class MVE_VABAV<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
 491   : MVE_rDest<(outs rGPR:$Rda), (ins rGPR:$Rda_src, MQPR:$Qn, MQPR:$Qm),
 492               NoItinerary, "vabav", suffix, "$Rda, $Qn, $Qm", "$Rda = $Rda_src",
 493               pattern> {
 494   bits<4> Qm;
 495   bits<4> Qn;
 496   bits<4> Rda;
 497
 498   let Inst{28} = U;
 499   let Inst{22} = 0b0;
 500   let Inst{21-20} = size{1-0};
 501   let Inst{19-17} = Qn{2-0};
 502   let Inst{16} = 0b0;
 503   let Inst{15-12} = Rda{3-0};
 504   let Inst{8} = 0b1;
 505   let Inst{7} = Qn{3};
 506   let Inst{6} = 0b0;
 507   let Inst{5} = Qm{3};
 508   let Inst{3-1} = Qm{2-0};
 509   let Inst{0} = 0b1;
 510   let invalidForTailPredication = 1;
 511 }
 512
 513 def MVE_VABAVs8  : MVE_VABAV<"s8", 0b0, 0b00>;
 514 def MVE_VABAVs16 : MVE_VABAV<"s16", 0b0, 0b01>;
 515 def MVE_VABAVs32 : MVE_VABAV<"s32", 0b0, 0b10>;
 516 def MVE_VABAVu8  : MVE_VABAV<"u8", 0b1, 0b00>;
 517 def MVE_VABAVu16 : MVE_VABAV<"u16", 0b1, 0b01>;
 518 def MVE_VABAVu32 : MVE_VABAV<"u32", 0b1, 0b10>;
 519
 520 class MVE_VADDV<string iname, string suffix, dag iops, string cstr,
 521               bit A, bit U, bits<2> size, list<dag> pattern=[]>
 522   : MVE_rDest<(outs tGPREven:$Rda), iops, NoItinerary,
 523               iname, suffix, "$Rda, $Qm", cstr, pattern> {
 524   bits<3> Qm;
 525   bits<4> Rda;
 526
 527   let Inst{28} = U;
 528   let Inst{22-20} = 0b111;
 529   let Inst{19-18} = size{1-0};
 530   let Inst{17-16} = 0b01;
 531   let Inst{15-13} = Rda{3-1};
 532   let Inst{12} = 0b0;
 533   let Inst{8-6} = 0b100;
 534   let Inst{5} = A;
 535   let Inst{3-1} = Qm{2-0};
 536   let Inst{0} = 0b0;
 537   let invalidForTailPredication = 1;
 538 }
 539
 540 multiclass MVE_VADDV_A<string suffix, bit U, bits<2> size,
 541                        list<dag> pattern=[]> {
 542   def acc    : MVE_VADDV<"vaddva", suffix,
 543                          (ins tGPREven:$Rda_src, MQPR:$Qm), "$Rda = $Rda_src",
 544                          0b1, U, size, pattern>;
 545   def no_acc : MVE_VADDV<"vaddv", suffix,
 546                          (ins MQPR:$Qm), "",
 547                          0b0, U, size, pattern>;
 548 }
 549
 550 defm MVE_VADDVs8  : MVE_VADDV_A<"s8",  0b0, 0b00>;
 551 defm MVE_VADDVs16 : MVE_VADDV_A<"s16", 0b0, 0b01>;
 552 defm MVE_VADDVs32 : MVE_VADDV_A<"s32", 0b0, 0b10>;
 553 defm MVE_VADDVu8  : MVE_VADDV_A<"u8",  0b1, 0b00>;
 554 defm MVE_VADDVu16 : MVE_VADDV_A<"u16", 0b1, 0b01>;
 555 defm MVE_VADDVu32 : MVE_VADDV_A<"u32", 0b1, 0b10>;
 556
 557 let Predicates = [HasMVEInt] in {
 558   def : Pat<(i32 (vecreduce_add (v4i32 MQPR:$src))), (i32 (MVE_VADDVu32no_acc $src))>;
 559   def : Pat<(i32 (vecreduce_add (v8i16 MQPR:$src))), (i32 (MVE_VADDVu16no_acc $src))>;
 560   def : Pat<(i32 (vecreduce_add (v16i8 MQPR:$src))), (i32 (MVE_VADDVu8no_acc $src))>;
 561   def : Pat<(i32 (add (i32 (vecreduce_add (v4i32 MQPR:$src1))), (i32 tGPR:$src2))),
 562             (i32 (MVE_VADDVu32acc $src2, $src1))>;
 563   def : Pat<(i32 (add (i32 (vecreduce_add (v8i16 MQPR:$src1))), (i32 tGPR:$src2))),
 564             (i32 (MVE_VADDVu16acc $src2, $src1))>;
 565   def : Pat<(i32 (add (i32 (vecreduce_add (v16i8 MQPR:$src1))), (i32 tGPR:$src2))),
 566             (i32 (MVE_VADDVu8acc $src2, $src1))>;
 567
 568 }
 569
 570 class MVE_VADDLV<string iname, string suffix, dag iops, string cstr,
 571                bit A, bit U, list<dag> pattern=[]>
 572   : MVE_rDest<(outs tGPREven:$RdaLo, tGPROdd:$RdaHi), iops, NoItinerary, iname,
 573               suffix, "$RdaLo, $RdaHi, $Qm", cstr, pattern> {
 574   bits<3> Qm;
 575   bits<4> RdaLo;
 576   bits<4> RdaHi;
 577
 578   let Inst{28} = U;
 579   let Inst{22-20} = RdaHi{3-1};
 580   let Inst{19-18} = 0b10;
 581   let Inst{17-16} = 0b01;
 582   let Inst{15-13} = RdaLo{3-1};
 583   let Inst{12} = 0b0;
 584   let Inst{8-6} = 0b100;
 585   let Inst{5} = A;
 586   let Inst{3-1} = Qm{2-0};
 587   let Inst{0} = 0b0;
 588   let invalidForTailPredication = 1;
 589 }
 590
 591 multiclass MVE_VADDLV_A<string suffix, bit U, list<dag> pattern=[]> {
 592   def acc    : MVE_VADDLV<"vaddlva", suffix,
 593                         (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, MQPR:$Qm),
 594                         "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
 595                         0b1, U, pattern>;
 596   def no_acc : MVE_VADDLV<"vaddlv", suffix,
 597                         (ins MQPR:$Qm), "",
 598                         0b0, U, pattern>;
 599 }
 600
 601
 602 defm MVE_VADDLVs32 : MVE_VADDLV_A<"s32", 0b0>;
 603 defm MVE_VADDLVu32 : MVE_VADDLV_A<"u32", 0b1>;
 604
 605 class MVE_VMINMAXNMV<string iname, string suffix, bit sz,
 606                      bit bit_17, bit bit_7, list<dag> pattern=[]>
 607   : MVE_rDest<(outs rGPR:$RdaDest), (ins rGPR:$RdaSrc, MQPR:$Qm),
 608               NoItinerary, iname, suffix, "$RdaSrc, $Qm",
 609               "$RdaDest = $RdaSrc", pattern> {
 610   bits<3> Qm;
 611   bits<4> RdaDest;
 612
 613   let Inst{28} = sz;
 614   let Inst{22-20} = 0b110;
 615   let Inst{19-18} = 0b11;
 616   let Inst{17} = bit_17;
 617   let Inst{16} = 0b0;
 618   let Inst{15-12} = RdaDest{3-0};
 619   let Inst{8} = 0b1;
 620   let Inst{7} = bit_7;
 621   let Inst{6-5} = 0b00;
 622   let Inst{3-1} = Qm{2-0};
 623   let Inst{0} = 0b0;
 624
 625   let Predicates = [HasMVEFloat];
 626   let invalidForTailPredication = 1;
 627 }
 628
 629 multiclass MVE_VMINMAXNMV_fty<string iname, bit bit_7, list<dag> pattern=[]> {
 630   def f32 : MVE_VMINMAXNMV<iname, "f32", 0b0, 0b1, bit_7, pattern>;
 631   def f16 : MVE_VMINMAXNMV<iname, "f16", 0b1, 0b1, bit_7, pattern>;
 632 }
 633
 634 defm MVE_VMINNMV : MVE_VMINMAXNMV_fty<"vminnmv", 0b1>;
 635 defm MVE_VMAXNMV : MVE_VMINMAXNMV_fty<"vmaxnmv", 0b0>;
 636
 637 multiclass MVE_VMINMAXNMAV_fty<string iname, bit bit_7, list<dag> pattern=[]> {
 638   def f32 : MVE_VMINMAXNMV<iname, "f32", 0b0, 0b0, bit_7, pattern>;
 639   def f16 : MVE_VMINMAXNMV<iname, "f16", 0b1, 0b0, bit_7, pattern>;
 640 }
 641
 642 defm MVE_VMINNMAV : MVE_VMINMAXNMAV_fty<"vminnmav", 0b1>;
 643 defm MVE_VMAXNMAV : MVE_VMINMAXNMAV_fty<"vmaxnmav", 0b0>;
 644
 645 class MVE_VMINMAXV<string iname, string suffix, bit U, bits<2> size,
 646                  bit bit_17, bit bit_7, list<dag> pattern=[]>
 647   : MVE_rDest<(outs rGPR:$RdaDest), (ins rGPR:$RdaSrc, MQPR:$Qm), NoItinerary,
 648               iname, suffix, "$RdaSrc, $Qm", "$RdaDest = $RdaSrc", pattern> {
 649   bits<3> Qm;
 650   bits<4> RdaDest;
 651
 652   let Inst{28} = U;
 653   let Inst{22-20} = 0b110;
 654   let Inst{19-18} = size{1-0};
 655   let Inst{17} = bit_17;
 656   let Inst{16} = 0b0;
 657   let Inst{15-12} = RdaDest{3-0};
 658   let Inst{8} = 0b1;
 659   let Inst{7} = bit_7;
 660   let Inst{6-5} = 0b00;
 661   let Inst{3-1} = Qm{2-0};
 662   let Inst{0} = 0b0;
 663   let invalidForTailPredication = 1;
 664 }
 665
 666 multiclass MVE_VMINMAXV_ty<string iname, bit bit_7, list<dag> pattern=[]> {
 667   def s8  : MVE_VMINMAXV<iname, "s8",  0b0, 0b00, 0b1, bit_7>;
 668   def s16 : MVE_VMINMAXV<iname, "s16", 0b0, 0b01, 0b1, bit_7>;
 669   def s32 : MVE_VMINMAXV<iname, "s32", 0b0, 0b10, 0b1, bit_7>;
 670   def u8  : MVE_VMINMAXV<iname, "u8",  0b1, 0b00, 0b1, bit_7>;
 671   def u16 : MVE_VMINMAXV<iname, "u16", 0b1, 0b01, 0b1, bit_7>;
 672   def u32 : MVE_VMINMAXV<iname, "u32", 0b1, 0b10, 0b1, bit_7>;
 673 }
 674
 675 defm MVE_VMINV : MVE_VMINMAXV_ty<"vminv", 0b1>;
 676 defm MVE_VMAXV : MVE_VMINMAXV_ty<"vmaxv", 0b0>;
 677
 678 let Predicates = [HasMVEInt] in {
 679   def : Pat<(i32 (vecreduce_smax (v16i8 MQPR:$src))),
 680             (i32 (MVE_VMAXVs8 (t2MVNi (i32 127)), $src))>;
 681   def : Pat<(i32 (vecreduce_smax (v8i16 MQPR:$src))),
 682             (i32 (MVE_VMAXVs16 (t2MOVi32imm (i32 -32768)), $src))>;
 683   def : Pat<(i32 (vecreduce_smax (v4i32 MQPR:$src))),
 684             (i32 (MVE_VMAXVs32 (t2MOVi (i32 -2147483648)), $src))>;
 685   def : Pat<(i32 (vecreduce_umax (v16i8 MQPR:$src))),
 686             (i32 (MVE_VMAXVu8 (t2MOVi (i32 0)), $src))>;
 687   def : Pat<(i32 (vecreduce_umax (v8i16 MQPR:$src))),
 688             (i32 (MVE_VMAXVu16 (t2MOVi (i32 0)), $src))>;
 689   def : Pat<(i32 (vecreduce_umax (v4i32 MQPR:$src))),
 690             (i32 (MVE_VMAXVu32 (t2MOVi (i32 0)), $src))>;
 691
 692   def : Pat<(i32 (vecreduce_smin (v16i8 MQPR:$src))),
 693             (i32 (MVE_VMINVs8 (t2MOVi (i32 127)), $src))>;
 694   def : Pat<(i32 (vecreduce_smin (v8i16 MQPR:$src))),
 695             (i32 (MVE_VMINVs16 (t2MOVi16 (i32 32767)), $src))>;
 696   def : Pat<(i32 (vecreduce_smin (v4i32 MQPR:$src))),
 697             (i32 (MVE_VMINVs32 (t2MVNi (i32 -2147483648)), $src))>;
 698   def : Pat<(i32 (vecreduce_umin (v16i8 MQPR:$src))),
 699             (i32 (MVE_VMINVu8 (t2MOVi (i32 255)), $src))>;
 700   def : Pat<(i32 (vecreduce_umin (v8i16 MQPR:$src))),
 701             (i32 (MVE_VMINVu16 (t2MOVi16 (i32 65535)), $src))>;
 702   def : Pat<(i32 (vecreduce_umin (v4i32 MQPR:$src))),
 703             (i32 (MVE_VMINVu32 (t2MOVi (i32 4294967295)), $src))>;
 704
 705 }
 706
 707 multiclass MVE_VMINMAXAV_ty<string iname, bit bit_7, list<dag> pattern=[]> {
 708   def s8  : MVE_VMINMAXV<iname, "s8",  0b0, 0b00, 0b0, bit_7>;
 709   def s16 : MVE_VMINMAXV<iname, "s16", 0b0, 0b01, 0b0, bit_7>;
 710   def s32 : MVE_VMINMAXV<iname, "s32", 0b0, 0b10, 0b0, bit_7>;
 711 }
 712
 713 defm MVE_VMINAV : MVE_VMINMAXAV_ty<"vminav", 0b1>;
 714 defm MVE_VMAXAV : MVE_VMINMAXAV_ty<"vmaxav", 0b0>;
 715
 716 class MVE_VMLAMLSDAV<string iname, string suffix, dag iops, string cstr,
 717                    bit sz, bit bit_28, bit A, bit X, bit bit_8, bit bit_0,
 718                    list<dag> pattern=[]>
 719   : MVE_rDest<(outs tGPREven:$RdaDest), iops, NoItinerary, iname, suffix,
 720               "$RdaDest, $Qn, $Qm", cstr, pattern> {
 721   bits<4> RdaDest;
 722   bits<3> Qm;
 723   bits<3> Qn;
 724
 725   let Inst{28} = bit_28;
 726   let Inst{22-20} = 0b111;
 727   let Inst{19-17} = Qn{2-0};
 728   let Inst{16} = sz;
 729   let Inst{15-13} = RdaDest{3-1};
 730   let Inst{12} = X;
 731   let Inst{8} = bit_8;
 732   let Inst{7-6} = 0b00;
 733   let Inst{5} = A;
 734   let Inst{3-1} = Qm{2-0};
 735   let Inst{0} = bit_0;
 736   let invalidForTailPredication = 1;
 737 }
 738
 739 multiclass MVE_VMLAMLSDAV_A<string iname, string x, string suffix,
 740                             bit sz, bit bit_28, bit X, bit bit_8, bit bit_0,
 741                             list<dag> pattern=[]> {
 742   def ""#x#suffix : MVE_VMLAMLSDAV<iname # x, suffix,
 743                                    (ins MQPR:$Qn, MQPR:$Qm), "",
 744                                    sz, bit_28, 0b0, X, bit_8, bit_0, pattern>;
 745   def "a"#x#suffix : MVE_VMLAMLSDAV<iname # "a" # x, suffix,
 746                                     (ins tGPREven:$RdaSrc, MQPR:$Qn, MQPR:$Qm),
 747                                     "$RdaDest = $RdaSrc",
 748                                     sz, bit_28, 0b1, X, bit_8, bit_0, pattern>;
 749 }
 750
 751 multiclass MVE_VMLAMLSDAV_AX<string iname, string suffix, bit sz, bit bit_28,
 752                              bit bit_8, bit bit_0, list<dag> pattern=[]> {
 753   defm "" : MVE_VMLAMLSDAV_A<iname, "", suffix, sz, bit_28,
 754                              0b0, bit_8, bit_0, pattern>;
 755   defm "" : MVE_VMLAMLSDAV_A<iname, "x", suffix, sz, bit_28,
 756                              0b1, bit_8, bit_0, pattern>;
 757 }
 758
 759 multiclass MVE_VMLADAV_multi<string suffix, bit sz, bit bit_8,
 760                              list<dag> pattern=[]> {
 761   defm "" : MVE_VMLAMLSDAV_AX<"vmladav", "s"#suffix,
 762                               sz, 0b0, bit_8, 0b0, pattern>;
 763   defm "" : MVE_VMLAMLSDAV_A<"vmladav", "", "u"#suffix,
 764                              sz, 0b1, 0b0, bit_8, 0b0, pattern>;
 765 }
 766
 767 multiclass MVE_VMLSDAV_multi<string suffix, bit sz, bit bit_28,
 768                              list<dag> pattern=[]> {
 769   defm "" : MVE_VMLAMLSDAV_AX<"vmlsdav", "s"#suffix,
 770                               sz, bit_28, 0b0, 0b1, pattern>;
 771 }
 772
 773 defm MVE_VMLADAV : MVE_VMLADAV_multi< "8", 0b0, 0b1>;
 774 defm MVE_VMLADAV : MVE_VMLADAV_multi<"16", 0b0, 0b0>;
 775 defm MVE_VMLADAV : MVE_VMLADAV_multi<"32", 0b1, 0b0>;
 776
 777 defm MVE_VMLSDAV : MVE_VMLSDAV_multi< "8", 0b0, 0b1>;
 778 defm MVE_VMLSDAV : MVE_VMLSDAV_multi<"16", 0b0, 0b0>;
 779 defm MVE_VMLSDAV : MVE_VMLSDAV_multi<"32", 0b1, 0b0>;
 780
 781 // vmlav aliases vmladav
 782 foreach acc = ["", "a"] in {
 783   foreach suffix = ["s8", "s16", "s32", "u8", "u16", "u32"] in {
 784     def : MVEInstAlias<"vmlav"#acc#"${vp}."#suffix#"\t$RdaDest, $Qn, $Qm",
 785                        (!cast<Instruction>("MVE_VMLADAV"#acc#suffix)
 786                         tGPREven:$RdaDest, MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 787   }
 788 }
 789
 790 // Base class for VMLALDAV and VMLSLDAV, VRMLALDAVH, VRMLSLDAVH
 791 class MVE_VMLALDAVBase<string iname, string suffix, dag iops, string cstr,
 792                        bit sz, bit bit_28, bit A, bit X, bit bit_8, bit bit_0,
 793                        list<dag> pattern=[]>
 794   : MVE_rDest<(outs tGPREven:$RdaLoDest, tGPROdd:$RdaHiDest), iops, NoItinerary,
 795               iname, suffix, "$RdaLoDest, $RdaHiDest, $Qn, $Qm", cstr, pattern> {
 796   bits<4> RdaLoDest;
 797   bits<4> RdaHiDest;
 798   bits<3> Qm;
 799   bits<3> Qn;
 800
 801   let Inst{28} = bit_28;
 802   let Inst{22-20} = RdaHiDest{3-1};
 803   let Inst{19-17} = Qn{2-0};
 804   let Inst{16} = sz;
 805   let Inst{15-13} = RdaLoDest{3-1};
 806   let Inst{12} = X;
 807   let Inst{8} = bit_8;
 808   let Inst{7-6} = 0b00;
 809   let Inst{5} = A;
 810   let Inst{3-1} = Qm{2-0};
 811   let Inst{0} = bit_0;
 812   let invalidForTailPredication = 1;
 813 }
 814
 815 multiclass MVE_VMLALDAVBase_A<string iname, string x, string suffix,
 816                                bit sz, bit bit_28, bit X, bit bit_8, bit bit_0,
 817                                list<dag> pattern=[]> {
 818   def ""#x#suffix : MVE_VMLALDAVBase<
 819      iname # x, suffix, (ins MQPR:$Qn, MQPR:$Qm), "",
 820      sz, bit_28, 0b0, X, bit_8, bit_0, pattern>;
 821   def "a"#x#suffix : MVE_VMLALDAVBase<
 822      iname # "a" # x, suffix,
 823      (ins tGPREven:$RdaLoSrc, tGPROdd:$RdaHiSrc, MQPR:$Qn, MQPR:$Qm),
 824      "$RdaLoDest = $RdaLoSrc,$RdaHiDest = $RdaHiSrc",
 825      sz, bit_28, 0b1, X, bit_8, bit_0, pattern>;
 826 }
 827
 828
 829 multiclass MVE_VMLALDAVBase_AX<string iname, string suffix, bit sz, bit bit_28,
 830                                bit bit_8, bit bit_0, list<dag> pattern=[]> {
 831   defm "" : MVE_VMLALDAVBase_A<iname, "", suffix, sz,
 832                                bit_28, 0b0, bit_8, bit_0, pattern>;
 833   defm "" : MVE_VMLALDAVBase_A<iname, "x", suffix, sz,
 834                                bit_28, 0b1, bit_8, bit_0, pattern>;
 835 }
 836
 837 multiclass MVE_VRMLALDAVH_multi<string suffix, list<dag> pattern=[]> {
 838   defm "" : MVE_VMLALDAVBase_AX<"vrmlaldavh", "s"#suffix,
 839                                 0b0, 0b0, 0b1, 0b0, pattern>;
 840   defm "" : MVE_VMLALDAVBase_A<"vrmlaldavh", "", "u"#suffix,
 841                                0b0, 0b1, 0b0, 0b1, 0b0, pattern>;
 842 }
 843
 844 defm MVE_VRMLALDAVH : MVE_VRMLALDAVH_multi<"32">;
 845
 846 // vrmlalvh aliases for vrmlaldavh
 847 def : MVEInstAlias<"vrmlalvh${vp}.s32\t$RdaLo, $RdaHi, $Qn, $Qm",
 848                   (MVE_VRMLALDAVHs32
 849                    tGPREven:$RdaLo, tGPROdd:$RdaHi,
 850                    MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 851 def : MVEInstAlias<"vrmlalvha${vp}.s32\t$RdaLo, $RdaHi, $Qn, $Qm",
 852                   (MVE_VRMLALDAVHas32
 853                    tGPREven:$RdaLo, tGPROdd:$RdaHi,
 854                    MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 855 def : MVEInstAlias<"vrmlalvh${vp}.u32\t$RdaLo, $RdaHi, $Qn, $Qm",
 856                   (MVE_VRMLALDAVHu32
 857                    tGPREven:$RdaLo, tGPROdd:$RdaHi,
 858                    MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 859 def : MVEInstAlias<"vrmlalvha${vp}.u32\t$RdaLo, $RdaHi, $Qn, $Qm",
 860                   (MVE_VRMLALDAVHau32
 861                    tGPREven:$RdaLo, tGPROdd:$RdaHi,
 862                    MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 863
 864 multiclass MVE_VMLALDAV_multi<string suffix, bit sz, list<dag> pattern=[]> {
 865   defm "" : MVE_VMLALDAVBase_AX<"vmlaldav", "s"#suffix, sz, 0b0, 0b0, 0b0, pattern>;
 866   defm "" : MVE_VMLALDAVBase_A<"vmlaldav", "", "u"#suffix,
 867                                sz, 0b1, 0b0, 0b0, 0b0, pattern>;
 868 }
 869
 870 defm MVE_VMLALDAV : MVE_VMLALDAV_multi<"16", 0b0>;
 871 defm MVE_VMLALDAV : MVE_VMLALDAV_multi<"32", 0b1>;
 872
 873 // vmlalv aliases vmlaldav
 874 foreach acc = ["", "a"] in {
 875   foreach suffix = ["s16", "s32", "u16", "u32"] in {
 876     def : MVEInstAlias<"vmlalv" # acc # "${vp}." # suffix #
 877                           "\t$RdaLoDest, $RdaHiDest, $Qn, $Qm",
 878                        (!cast<Instruction>("MVE_VMLALDAV"#acc#suffix)
 879                        tGPREven:$RdaLoDest, tGPROdd:$RdaHiDest,
 880                        MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
 881   }
 882 }
 883
 884 multiclass MVE_VMLSLDAV_multi<string iname, string suffix, bit sz,
 885                               bit bit_28, list<dag> pattern=[]> {
 886   defm "" : MVE_VMLALDAVBase_AX<iname, suffix, sz, bit_28, 0b0, 0b1, pattern>;
 887 }
 888
 889 defm MVE_VMLSLDAV   : MVE_VMLSLDAV_multi<"vmlsldav", "s16", 0b0, 0b0>;
 890 defm MVE_VMLSLDAV   : MVE_VMLSLDAV_multi<"vmlsldav", "s32", 0b1, 0b0>;
 891 defm MVE_VRMLSLDAVH : MVE_VMLSLDAV_multi<"vrmlsldavh", "s32", 0b0, 0b1>;
 892
 893 // end of mve_rDest instructions
 894
 895 // start of mve_comp instructions
 896
 897 class MVE_comp<InstrItinClass itin, string iname, string suffix,
 898                string cstr, list<dag> pattern=[]>
 899   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), itin, iname, suffix,
 900            "$Qd, $Qn, $Qm", vpred_r, cstr, pattern> {
 901   bits<4> Qd;
 902   bits<4> Qn;
 903   bits<4> Qm;
 904
 905   let Inst{22} = Qd{3};
 906   let Inst{19-17} = Qn{2-0};
 907   let Inst{16} = 0b0;
 908   let Inst{15-13} = Qd{2-0};
 909   let Inst{12} = 0b0;
 910   let Inst{10-9} = 0b11;
 911   let Inst{7} = Qn{3};
 912   let Inst{5} = Qm{3};
 913   let Inst{3-1} = Qm{2-0};
 914   let Inst{0} = 0b0;
 915 }
 916
 917 class MVE_VMINMAXNM<string iname, string suffix, bit sz, bit bit_21,
 918                 list<dag> pattern=[]>
 919   : MVE_comp<NoItinerary, iname, suffix, "", pattern> {
 920
 921   let Inst{28} = 0b1;
 922   let Inst{25-24} = 0b11;
 923   let Inst{23} = 0b0;
 924   let Inst{21} = bit_21;
 925   let Inst{20} = sz;
 926   let Inst{11} = 0b1;
 927   let Inst{8} = 0b1;
 928   let Inst{6} = 0b1;
 929   let Inst{4} = 0b1;
 930
 931   let Predicates = [HasMVEFloat];
 932 }
 933
 934 def MVE_VMAXNMf32 : MVE_VMINMAXNM<"vmaxnm", "f32", 0b0, 0b0>;
 935 def MVE_VMAXNMf16 : MVE_VMINMAXNM<"vmaxnm", "f16", 0b1, 0b0>;
 936
 937 let Predicates = [HasMVEFloat] in {
 938   def : Pat<(v4f32 (fmaxnum (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
 939             (v4f32 (MVE_VMAXNMf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
 940   def : Pat<(v8f16 (fmaxnum (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
 941             (v8f16 (MVE_VMAXNMf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
 942 }
 943
 944 def MVE_VMINNMf32 : MVE_VMINMAXNM<"vminnm", "f32", 0b0, 0b1>;
 945 def MVE_VMINNMf16 : MVE_VMINMAXNM<"vminnm", "f16", 0b1, 0b1>;
 946
 947 let Predicates = [HasMVEFloat] in {
 948   def : Pat<(v4f32 (fminnum (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
 949             (v4f32 (MVE_VMINNMf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
 950   def : Pat<(v8f16 (fminnum (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
 951             (v8f16 (MVE_VMINNMf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
 952 }
 953
 954
 955 class MVE_VMINMAX<string iname, string suffix, bit U, bits<2> size,
 956               bit bit_4, list<dag> pattern=[]>
 957   : MVE_comp<NoItinerary, iname, suffix, "", pattern> {
 958
 959   let Inst{28} = U;
 960   let Inst{25-24} = 0b11;
 961   let Inst{23} = 0b0;
 962   let Inst{21-20} = size{1-0};
 963   let Inst{11} = 0b0;
 964   let Inst{8} = 0b0;
 965   let Inst{6} = 0b1;
 966   let Inst{4} = bit_4;
 967 }
 968
 969 multiclass MVE_VMINMAX_all_sizes<string iname, bit bit_4> {
 970   def s8  : MVE_VMINMAX<iname, "s8",  0b0, 0b00, bit_4>;
 971   def s16 : MVE_VMINMAX<iname, "s16", 0b0, 0b01, bit_4>;
 972   def s32 : MVE_VMINMAX<iname, "s32", 0b0, 0b10, bit_4>;
 973   def u8  : MVE_VMINMAX<iname, "u8",  0b1, 0b00, bit_4>;
 974   def u16 : MVE_VMINMAX<iname, "u16", 0b1, 0b01, bit_4>;
 975   def u32 : MVE_VMINMAX<iname, "u32", 0b1, 0b10, bit_4>;
 976 }
 977
 978 defm MVE_VMAX : MVE_VMINMAX_all_sizes<"vmax", 0b0>;
 979 defm MVE_VMIN : MVE_VMINMAX_all_sizes<"vmin", 0b1>;
 980
 981 let Predicates = [HasMVEInt] in {
 982   def : Pat<(v16i8 (smin (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
 983             (v16i8 (MVE_VMINs8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
 984   def : Pat<(v8i16 (smin (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
 985             (v8i16 (MVE_VMINs16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
 986   def : Pat<(v4i32 (smin (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
 987             (v4i32 (MVE_VMINs32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
 988
 989   def : Pat<(v16i8 (smax (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
 990             (v16i8 (MVE_VMAXs8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
 991   def : Pat<(v8i16 (smax (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
 992             (v8i16 (MVE_VMAXs16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
 993   def : Pat<(v4i32 (smax (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
 994             (v4i32 (MVE_VMAXs32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
 995
 996   def : Pat<(v16i8 (umin (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
 997             (v16i8 (MVE_VMINu8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
 998   def : Pat<(v8i16 (umin (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
 999             (v8i16 (MVE_VMINu16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1000   def : Pat<(v4i32 (umin (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1001             (v4i32 (MVE_VMINu32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1002
1003   def : Pat<(v16i8 (umax (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1004             (v16i8 (MVE_VMAXu8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1005   def : Pat<(v8i16 (umax (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1006             (v8i16 (MVE_VMAXu16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1007   def : Pat<(v4i32 (umax (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1008             (v4i32 (MVE_VMAXu32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1009 }
1010
1011 // end of mve_comp instructions
1012
1013 // start of mve_bit instructions
1014
1015 class MVE_bit_arith<dag oops, dag iops, string iname, string suffix,
1016                     string ops, string cstr, list<dag> pattern=[]>
1017   : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred_r, cstr, pattern> {
1018   bits<4> Qd;
1019   bits<4> Qm;
1020
1021   let Inst{22} = Qd{3};
1022   let Inst{15-13} = Qd{2-0};
1023   let Inst{5} = Qm{3};
1024   let Inst{3-1} = Qm{2-0};
1025 }
1026
1027 def MVE_VBIC : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
1028                              "vbic", "", "$Qd, $Qn, $Qm", ""> {
1029   bits<4> Qn;
1030
1031   let Inst{28} = 0b0;
1032   let Inst{25-23} = 0b110;
1033   let Inst{21-20} = 0b01;
1034   let Inst{19-17} = Qn{2-0};
1035   let Inst{16} = 0b0;
1036   let Inst{12-8} = 0b00001;
1037   let Inst{7} = Qn{3};
1038   let Inst{6} = 0b1;
1039   let Inst{4} = 0b1;
1040   let Inst{0} = 0b0;
1041 }
1042
1043 class MVE_VREV<string iname, string suffix, bits<2> size, bits<2> bit_8_7, string cstr="">
1044   : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qm), iname,
1045                   suffix, "$Qd, $Qm", cstr> {
1046
1047   let Inst{28} = 0b1;
1048   let Inst{25-23} = 0b111;
1049   let Inst{21-20} = 0b11;
1050   let Inst{19-18} = size;
1051   let Inst{17-16} = 0b00;
1052   let Inst{12-9} = 0b0000;
1053   let Inst{8-7} = bit_8_7;
1054   let Inst{6} = 0b1;
1055   let Inst{4} = 0b0;
1056   let Inst{0} = 0b0;
1057 }
1058
1059 def MVE_VREV64_8  : MVE_VREV<"vrev64", "8", 0b00, 0b00, "@earlyclobber $Qd">;
1060 def MVE_VREV64_16 : MVE_VREV<"vrev64", "16", 0b01, 0b00, "@earlyclobber $Qd">;
1061 def MVE_VREV64_32 : MVE_VREV<"vrev64", "32", 0b10, 0b00, "@earlyclobber $Qd">;
1062
1063 def MVE_VREV32_8  : MVE_VREV<"vrev32", "8", 0b00, 0b01>;
1064 def MVE_VREV32_16 : MVE_VREV<"vrev32", "16", 0b01, 0b01>;
1065
1066 def MVE_VREV16_8  : MVE_VREV<"vrev16", "8", 0b00, 0b10>;
1067
1068 let Predicates = [HasMVEInt] in {
1069   def : Pat<(v8i16 (bswap (v8i16 MQPR:$src))),
1070             (v8i16 (MVE_VREV16_8 (v8i16 MQPR:$src)))>;
1071   def : Pat<(v4i32 (bswap (v4i32 MQPR:$src))),
1072             (v4i32 (MVE_VREV32_8 (v4i32 MQPR:$src)))>;
1073 }
1074
1075 let Predicates = [HasMVEInt] in {
1076   def : Pat<(v4i32 (ARMvrev64 (v4i32 MQPR:$src))),
1077             (v4i32 (MVE_VREV64_32 (v4i32 MQPR:$src)))>;
1078   def : Pat<(v8i16 (ARMvrev64 (v8i16 MQPR:$src))),
1079             (v8i16 (MVE_VREV64_16 (v8i16 MQPR:$src)))>;
1080   def : Pat<(v16i8 (ARMvrev64 (v16i8 MQPR:$src))),
1081             (v16i8 (MVE_VREV64_8  (v16i8 MQPR:$src)))>;
1082
1083   def : Pat<(v8i16 (ARMvrev32 (v8i16 MQPR:$src))),
1084             (v8i16 (MVE_VREV32_16 (v8i16 MQPR:$src)))>;
1085   def : Pat<(v16i8 (ARMvrev32 (v16i8 MQPR:$src))),
1086             (v16i8 (MVE_VREV32_8  (v16i8 MQPR:$src)))>;
1087
1088   def : Pat<(v16i8 (ARMvrev16 (v16i8 MQPR:$src))),
1089             (v16i8 (MVE_VREV16_8  (v16i8 MQPR:$src)))>;
1090
1091   def : Pat<(v4f32 (ARMvrev64 (v4f32 MQPR:$src))),
1092             (v4f32 (MVE_VREV64_32 (v4f32 MQPR:$src)))>;
1093   def : Pat<(v8f16 (ARMvrev64 (v8f16 MQPR:$src))),
1094             (v8f16 (MVE_VREV64_16 (v8f16 MQPR:$src)))>;
1095   def : Pat<(v8f16 (ARMvrev32 (v8f16 MQPR:$src))),
1096             (v8f16 (MVE_VREV32_16 (v8f16 MQPR:$src)))>;
1097 }
1098
1099 def MVE_VMVN : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qm),
1100                              "vmvn", "", "$Qd, $Qm", ""> {
1101   let Inst{28} = 0b1;
1102   let Inst{25-23} = 0b111;
1103   let Inst{21-16} = 0b110000;
1104   let Inst{12-6} = 0b0010111;
1105   let Inst{4} = 0b0;
1106   let Inst{0} = 0b0;
1107 }
1108
1109 let Predicates = [HasMVEInt] in {
1110   def : Pat<(v16i8 (vnotq  (v16i8 MQPR:$val1))),
1111             (v16i8 (MVE_VMVN (v16i8 MQPR:$val1)))>;
1112   def : Pat<(v8i16 (vnotq  (v8i16 MQPR:$val1))),
1113             (v8i16 (MVE_VMVN (v8i16 MQPR:$val1)))>;
1114   def : Pat<(v4i32 (vnotq  (v4i32 MQPR:$val1))),
1115             (v4i32 (MVE_VMVN (v4i32 MQPR:$val1)))>;
1116   def : Pat<(v2i64 (vnotq  (v2i64 MQPR:$val1))),
1117             (v2i64 (MVE_VMVN (v2i64 MQPR:$val1)))>;
1118 }
1119
1120 class MVE_bit_ops<string iname, bits<2> bit_21_20, bit bit_28>
1121   : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
1122                   iname, "", "$Qd, $Qn, $Qm", ""> {
1123   bits<4> Qn;
1124
1125   let Inst{28} = bit_28;
1126   let Inst{25-23} = 0b110;
1127   let Inst{21-20} = bit_21_20;
1128   let Inst{19-17} = Qn{2-0};
1129   let Inst{16} = 0b0;
1130   let Inst{12-8} = 0b00001;
1131   let Inst{7} = Qn{3};
1132   let Inst{6} = 0b1;
1133   let Inst{4} = 0b1;
1134   let Inst{0} = 0b0;
1135 }
1136
1137 def MVE_VEOR : MVE_bit_ops<"veor", 0b00, 0b1>;
1138 def MVE_VORN : MVE_bit_ops<"vorn", 0b11, 0b0>;
1139 def MVE_VORR : MVE_bit_ops<"vorr", 0b10, 0b0>;
1140 def MVE_VAND : MVE_bit_ops<"vand", 0b00, 0b0>;
1141
1142 // add ignored suffixes as aliases
1143
1144 foreach s=["s8", "s16", "s32", "u8", "u16", "u32", "i8", "i16", "i32", "f16", "f32"] in {
1145   def : MVEInstAlias<"vbic${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1146         (MVE_VBIC MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1147   def : MVEInstAlias<"veor${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1148         (MVE_VEOR MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1149   def : MVEInstAlias<"vorn${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1150         (MVE_VORN MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1151   def : MVEInstAlias<"vorr${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1152         (MVE_VORR MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1153   def : MVEInstAlias<"vand${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1154         (MVE_VAND MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1155 }
1156
1157 let Predicates = [HasMVEInt] in {
1158   def : Pat<(v16i8 (and (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1159             (v16i8 (MVE_VAND (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1160   def : Pat<(v8i16 (and (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1161             (v8i16 (MVE_VAND (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1162   def : Pat<(v4i32 (and (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1163             (v4i32 (MVE_VAND (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1164   def : Pat<(v2i64 (and (v2i64 MQPR:$val1), (v2i64 MQPR:$val2))),
1165             (v2i64 (MVE_VAND (v2i64 MQPR:$val1), (v2i64 MQPR:$val2)))>;
1166
1167   def : Pat<(v16i8 (or (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1168             (v16i8 (MVE_VORR (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1169   def : Pat<(v8i16 (or (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1170             (v8i16 (MVE_VORR (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1171   def : Pat<(v4i32 (or (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1172             (v4i32 (MVE_VORR (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1173   def : Pat<(v2i64 (or (v2i64 MQPR:$val1), (v2i64 MQPR:$val2))),
1174             (v2i64 (MVE_VORR (v2i64 MQPR:$val1), (v2i64 MQPR:$val2)))>;
1175
1176   def : Pat<(v16i8 (xor (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1177             (v16i8 (MVE_VEOR (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1178   def : Pat<(v8i16 (xor (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1179             (v8i16 (MVE_VEOR (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1180   def : Pat<(v4i32 (xor (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1181             (v4i32 (MVE_VEOR (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1182   def : Pat<(v2i64 (xor (v2i64 MQPR:$val1), (v2i64 MQPR:$val2))),
1183             (v2i64 (MVE_VEOR (v2i64 MQPR:$val1), (v2i64 MQPR:$val2)))>;
1184
1185   def : Pat<(v16i8 (and (v16i8 MQPR:$val1), (vnotq MQPR:$val2))),
1186             (v16i8 (MVE_VBIC (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1187   def : Pat<(v8i16 (and (v8i16 MQPR:$val1), (vnotq MQPR:$val2))),
1188             (v8i16 (MVE_VBIC (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1189   def : Pat<(v4i32 (and (v4i32 MQPR:$val1), (vnotq MQPR:$val2))),
1190             (v4i32 (MVE_VBIC (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1191   def : Pat<(v2i64 (and (v2i64 MQPR:$val1), (vnotq MQPR:$val2))),
1192             (v2i64 (MVE_VBIC (v2i64 MQPR:$val1), (v2i64 MQPR:$val2)))>;
1193
1194   def : Pat<(v16i8 (or (v16i8 MQPR:$val1), (vnotq MQPR:$val2))),
1195             (v16i8 (MVE_VORN (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1196   def : Pat<(v8i16 (or (v8i16 MQPR:$val1), (vnotq MQPR:$val2))),
1197             (v8i16 (MVE_VORN (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1198   def : Pat<(v4i32 (or (v4i32 MQPR:$val1), (vnotq MQPR:$val2))),
1199             (v4i32 (MVE_VORN (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1200   def : Pat<(v2i64 (or (v2i64 MQPR:$val1), (vnotq MQPR:$val2))),
1201             (v2i64 (MVE_VORN (v2i64 MQPR:$val1), (v2i64 MQPR:$val2)))>;
1202 }
1203
1204 class MVE_bit_cmode<string iname, string suffix, bits<4> cmode, dag inOps>
1205   : MVE_p<(outs MQPR:$Qd), inOps, NoItinerary,
1206           iname, suffix, "$Qd, $imm", vpred_n, "$Qd = $Qd_src"> {
1207   bits<8> imm;
1208   bits<4> Qd;
1209
1210   let Inst{28} = imm{7};
1211   let Inst{27-23} = 0b11111;
1212   let Inst{22} = Qd{3};
1213   let Inst{21-19} = 0b000;
1214   let Inst{18-16} = imm{6-4};
1215   let Inst{15-13} = Qd{2-0};
1216   let Inst{12} = 0b0;
1217   let Inst{11-8} = cmode;
1218   let Inst{7-6} = 0b01;
1219   let Inst{4} = 0b1;
1220   let Inst{3-0} = imm{3-0};
1221 }
1222
1223 class MVE_VORR<string suffix, bits<4> cmode, ExpandImm imm_type>
1224   : MVE_bit_cmode<"vorr", suffix, cmode, (ins MQPR:$Qd_src, imm_type:$imm)> {
1225   let Inst{5} = 0b0;
1226 }
1227
1228 def MVE_VORRIZ0v4i32  : MVE_VORR<"i32", 0b0001, expzero00>;
1229 def MVE_VORRIZ0v8i16  : MVE_VORR<"i16", 0b1001, expzero00>;
1230 def MVE_VORRIZ8v4i32  : MVE_VORR<"i32", 0b0011, expzero08>;
1231 def MVE_VORRIZ8v8i16  : MVE_VORR<"i16", 0b1011, expzero08>;
1232 def MVE_VORRIZ16v4i32 : MVE_VORR<"i32", 0b0101, expzero16>;
1233 def MVE_VORRIZ24v4i32 : MVE_VORR<"i32", 0b0111, expzero24>;
1234
1235 def MVE_VORNIZ0v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1236     (ins MQPR:$Qd_src, expzero00inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1237 def MVE_VORNIZ0v8i16 : MVEAsmPseudo<"vorn${vp}.i16\t$Qd, $imm",
1238     (ins MQPR:$Qd_src, expzero00inv16:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1239 def MVE_VORNIZ8v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1240     (ins MQPR:$Qd_src, expzero08inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1241 def MVE_VORNIZ8v8i16 : MVEAsmPseudo<"vorn${vp}.i16\t$Qd, $imm",
1242     (ins MQPR:$Qd_src, expzero08inv16:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1243 def MVE_VORNIZ16v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1244     (ins MQPR:$Qd_src, expzero16inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1245 def MVE_VORNIZ24v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1246     (ins MQPR:$Qd_src, expzero24inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1247
1248 def MVE_VMOV : MVEInstAlias<"vmov${vp}\t$Qd, $Qm",
1249     (MVE_VORR MQPR:$Qd, MQPR:$Qm, MQPR:$Qm, vpred_r:$vp)>;
1250
1251 class MVE_VBIC<string suffix, bits<4> cmode, ExpandImm imm_type>
1252   : MVE_bit_cmode<"vbic", suffix, cmode, (ins MQPR:$Qd_src, imm_type:$imm)> {
1253   let Inst{5} = 0b1;
1254 }
1255
1256 def MVE_VBICIZ0v4i32  : MVE_VBIC<"i32", 0b0001, expzero00>;
1257 def MVE_VBICIZ0v8i16  : MVE_VBIC<"i16", 0b1001, expzero00>;
1258 def MVE_VBICIZ8v4i32  : MVE_VBIC<"i32", 0b0011, expzero08>;
1259 def MVE_VBICIZ8v8i16  : MVE_VBIC<"i16", 0b1011, expzero08>;
1260 def MVE_VBICIZ16v4i32 : MVE_VBIC<"i32", 0b0101, expzero16>;
1261 def MVE_VBICIZ24v4i32 : MVE_VBIC<"i32", 0b0111, expzero24>;
1262
1263 def MVE_VANDIZ0v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1264     (ins MQPR:$Qda_src, expzero00inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1265 def MVE_VANDIZ0v8i16 : MVEAsmPseudo<"vand${vp}.i16\t$Qda, $imm",
1266     (ins MQPR:$Qda_src, expzero00inv16:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1267 def MVE_VANDIZ8v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1268     (ins MQPR:$Qda_src, expzero08inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1269 def MVE_VANDIZ8v8i16 : MVEAsmPseudo<"vand${vp}.i16\t$Qda, $imm",
1270     (ins MQPR:$Qda_src, expzero08inv16:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1271 def MVE_VANDIZ16v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1272     (ins MQPR:$Qda_src, expzero16inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1273 def MVE_VANDIZ24v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1274     (ins MQPR:$Qda_src, expzero24inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1275
1276 class MVE_VMOV_lane_direction {
1277   bit bit_20;
1278   dag oops;
1279   dag iops;
1280   string ops;
1281   string cstr;
1282 }
1283 def MVE_VMOV_from_lane : MVE_VMOV_lane_direction {
1284   let bit_20 = 0b1;
1285   let oops = (outs rGPR:$Rt);
1286   let iops = (ins MQPR:$Qd);
1287   let ops = "$Rt, $Qd$Idx";
1288   let cstr = "";
1289 }
1290 def MVE_VMOV_to_lane : MVE_VMOV_lane_direction {
1291   let bit_20 = 0b0;
1292   let oops = (outs MQPR:$Qd);
1293   let iops = (ins MQPR:$Qd_src, rGPR:$Rt);
1294   let ops = "$Qd$Idx, $Rt";
1295   let cstr = "$Qd = $Qd_src";
1296 }
1297
1298 class MVE_VMOV_lane<string suffix, bit U, dag indexop,
1299                     MVE_VMOV_lane_direction dir>
1300   : MVE_VMOV_lane_base<dir.oops, !con(dir.iops, indexop), NoItinerary,
1301                        "vmov", suffix, dir.ops, dir.cstr, []> {
1302   bits<4> Qd;
1303   bits<4> Rt;
1304
1305   let Inst{31-24} = 0b11101110;
1306   let Inst{23} = U;
1307   let Inst{20} = dir.bit_20;
1308   let Inst{19-17} = Qd{2-0};
1309   let Inst{15-12} = Rt{3-0};
1310   let Inst{11-8} = 0b1011;
1311   let Inst{7} = Qd{3};
1312   let Inst{4-0} = 0b10000;
1313 }
1314
1315 class MVE_VMOV_lane_32<MVE_VMOV_lane_direction dir>
1316     : MVE_VMOV_lane<"32", 0b0, (ins MVEVectorIndex<4>:$Idx), dir> {
1317   bits<2> Idx;
1318   let Inst{22} = 0b0;
1319   let Inst{6-5} = 0b00;
1320   let Inst{16} = Idx{1};
1321   let Inst{21} = Idx{0};
1322
1323   let Predicates = [HasFPRegsV8_1M];
1324 }
1325
1326 class MVE_VMOV_lane_16<string suffix, bit U, MVE_VMOV_lane_direction dir>
1327   : MVE_VMOV_lane<suffix, U, (ins MVEVectorIndex<8>:$Idx), dir> {
1328   bits<3> Idx;
1329   let Inst{22} = 0b0;
1330   let Inst{5} = 0b1;
1331   let Inst{16} = Idx{2};
1332   let Inst{21} = Idx{1};
1333   let Inst{6} = Idx{0};
1334 }
1335
1336 class MVE_VMOV_lane_8<string suffix, bit U, MVE_VMOV_lane_direction dir>
1337   : MVE_VMOV_lane<suffix, U, (ins MVEVectorIndex<16>:$Idx), dir> {
1338   bits<4> Idx;
1339   let Inst{22} = 0b1;
1340   let Inst{16} = Idx{3};
1341   let Inst{21} = Idx{2};
1342   let Inst{6} = Idx{1};
1343   let Inst{5} = Idx{0};
1344 }
1345
1346 def MVE_VMOV_from_lane_32  : MVE_VMOV_lane_32<            MVE_VMOV_from_lane>;
1347 def MVE_VMOV_to_lane_32    : MVE_VMOV_lane_32<            MVE_VMOV_to_lane>;
1348 def MVE_VMOV_from_lane_s16 : MVE_VMOV_lane_16<"s16", 0b0, MVE_VMOV_from_lane>;
1349 def MVE_VMOV_from_lane_u16 : MVE_VMOV_lane_16<"u16", 0b1, MVE_VMOV_from_lane>;
1350 def MVE_VMOV_to_lane_16    : MVE_VMOV_lane_16< "16", 0b0, MVE_VMOV_to_lane>;
1351 def MVE_VMOV_from_lane_s8  : MVE_VMOV_lane_8 < "s8", 0b0, MVE_VMOV_from_lane>;
1352 def MVE_VMOV_from_lane_u8  : MVE_VMOV_lane_8 < "u8", 0b1, MVE_VMOV_from_lane>;
1353 def MVE_VMOV_to_lane_8     : MVE_VMOV_lane_8 <  "8", 0b0, MVE_VMOV_to_lane>;
1354
1355 let Predicates = [HasMVEInt] in {
1356   def : Pat<(extractelt (v2f64 MQPR:$src), imm:$lane),
1357             (f64 (EXTRACT_SUBREG MQPR:$src, (DSubReg_f64_reg imm:$lane)))>;
1358   def : Pat<(insertelt (v2f64 MQPR:$src1), DPR:$src2, imm:$lane),
1359             (INSERT_SUBREG (v2f64 (COPY_TO_REGCLASS MQPR:$src1, MQPR)), DPR:$src2, (DSubReg_f64_reg imm:$lane))>;
1360
1361   def : Pat<(extractelt (v4i32 MQPR:$src), imm:$lane),
1362             (COPY_TO_REGCLASS
1363               (i32 (EXTRACT_SUBREG MQPR:$src, (SSubReg_f32_reg imm:$lane))), rGPR)>;
1364   def : Pat<(insertelt (v4i32 MQPR:$src1), rGPR:$src2, imm:$lane),
1365             (MVE_VMOV_to_lane_32 MQPR:$src1, rGPR:$src2, imm:$lane)>;
1366
1367   def : Pat<(vector_insert (v16i8 MQPR:$src1), rGPR:$src2, imm:$lane),
1368             (MVE_VMOV_to_lane_8  MQPR:$src1, rGPR:$src2, imm:$lane)>;
1369   def : Pat<(vector_insert (v8i16 MQPR:$src1), rGPR:$src2, imm:$lane),
1370             (MVE_VMOV_to_lane_16 MQPR:$src1, rGPR:$src2, imm:$lane)>;
1371
1372   def : Pat<(ARMvgetlanes (v16i8 MQPR:$src), imm:$lane),
1373             (MVE_VMOV_from_lane_s8 MQPR:$src, imm:$lane)>;
1374   def : Pat<(ARMvgetlanes (v8i16 MQPR:$src), imm:$lane),
1375             (MVE_VMOV_from_lane_s16 MQPR:$src, imm:$lane)>;
1376   def : Pat<(ARMvgetlaneu (v16i8 MQPR:$src), imm:$lane),
1377             (MVE_VMOV_from_lane_u8 MQPR:$src, imm:$lane)>;
1378   def : Pat<(ARMvgetlaneu (v8i16 MQPR:$src), imm:$lane),
1379             (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane)>;
1380
1381   def : Pat<(v16i8 (scalar_to_vector GPR:$src)),
1382             (MVE_VMOV_to_lane_8  (v16i8 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1383   def : Pat<(v8i16 (scalar_to_vector GPR:$src)),
1384             (MVE_VMOV_to_lane_16 (v8i16 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1385   def : Pat<(v4i32 (scalar_to_vector GPR:$src)),
1386             (MVE_VMOV_to_lane_32 (v4i32 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1387
1388   // Floating point patterns, still enabled under HasMVEInt
1389   def : Pat<(extractelt (v4f32 MQPR:$src), imm:$lane),
1390             (COPY_TO_REGCLASS (f32 (EXTRACT_SUBREG MQPR:$src, (SSubReg_f32_reg imm:$lane))), SPR)>;
1391   def : Pat<(insertelt (v4f32 MQPR:$src1), (f32 SPR:$src2), imm:$lane),
1392             (INSERT_SUBREG (v4f32 (COPY_TO_REGCLASS MQPR:$src1, MQPR)), SPR:$src2, (SSubReg_f32_reg imm:$lane))>;
1393
1394   def : Pat<(insertelt (v8f16 MQPR:$src1), HPR:$src2, imm:$lane),
1395             (MVE_VMOV_to_lane_16 MQPR:$src1, (COPY_TO_REGCLASS HPR:$src2, rGPR), imm:$lane)>;
1396   def : Pat<(extractelt (v8f16 MQPR:$src), imm_even:$lane),
1397             (EXTRACT_SUBREG MQPR:$src, (SSubReg_f16_reg imm_even:$lane))>;
1398   def : Pat<(extractelt (v8f16 MQPR:$src), imm_odd:$lane),
1399             (COPY_TO_REGCLASS
1400               (VMOVH (EXTRACT_SUBREG MQPR:$src, (SSubReg_f16_reg imm_odd:$lane))),
1401               HPR)>;
1402
1403   def : Pat<(v4f32 (scalar_to_vector SPR:$src)),
1404             (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), SPR:$src, ssub_0)>;
1405   def : Pat<(v4f32 (scalar_to_vector GPR:$src)),
1406             (MVE_VMOV_to_lane_32 (v4f32 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1407   def : Pat<(v8f16 (scalar_to_vector HPR:$src)),
1408             (INSERT_SUBREG (v8f16 (IMPLICIT_DEF)), HPR:$src, ssub_0)>;
1409   def : Pat<(v8f16 (scalar_to_vector GPR:$src)),
1410             (MVE_VMOV_to_lane_16 (v8f16 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1411 }
1412
1413 // end of mve_bit instructions
1414
1415 // start of MVE Integer instructions
1416
1417 class MVE_int<string iname, string suffix, bits<2> size, list<dag> pattern=[]>
1418   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), NoItinerary,
1419           iname, suffix, "$Qd, $Qn, $Qm", vpred_r, "", pattern> {
1420   bits<4> Qd;
1421   bits<4> Qn;
1422   bits<4> Qm;
1423
1424   let Inst{22} = Qd{3};
1425   let Inst{21-20} = size;
1426   let Inst{19-17} = Qn{2-0};
1427   let Inst{15-13} = Qd{2-0};
1428   let Inst{7} = Qn{3};
1429   let Inst{6} = 0b1;
1430   let Inst{5} = Qm{3};
1431   let Inst{3-1} = Qm{2-0};
1432 }
1433
1434 class MVE_VMULt1<string suffix, bits<2> size, list<dag> pattern=[]>
1435   : MVE_int<"vmul", suffix, size, pattern> {
1436
1437   let Inst{28} = 0b0;
1438   let Inst{25-23} = 0b110;
1439   let Inst{16} = 0b0;
1440   let Inst{12-8} = 0b01001;
1441   let Inst{4} = 0b1;
1442   let Inst{0} = 0b0;
1443 }
1444
1445 def MVE_VMULt1i8  : MVE_VMULt1<"i8", 0b00>;
1446 def MVE_VMULt1i16 : MVE_VMULt1<"i16", 0b01>;
1447 def MVE_VMULt1i32 : MVE_VMULt1<"i32", 0b10>;
1448
1449 let Predicates = [HasMVEInt] in {
1450   def : Pat<(v16i8 (mul (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1451             (v16i8 (MVE_VMULt1i8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1452   def : Pat<(v8i16 (mul (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1453             (v8i16 (MVE_VMULt1i16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1454   def : Pat<(v4i32 (mul (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1455             (v4i32 (MVE_VMULt1i32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1456 }
1457
1458 class MVE_VQxDMULH<string iname, string suffix, bits<2> size, bit rounding,
1459                   list<dag> pattern=[]>
1460   : MVE_int<iname, suffix, size, pattern> {
1461
1462   let Inst{28} = rounding;
1463   let Inst{25-23} = 0b110;
1464   let Inst{16} = 0b0;
1465   let Inst{12-8} = 0b01011;
1466   let Inst{4} = 0b0;
1467   let Inst{0} = 0b0;
1468 }
1469
1470 class MVE_VQDMULH<string suffix, bits<2> size, list<dag> pattern=[]>
1471   : MVE_VQxDMULH<"vqdmulh", suffix, size, 0b0, pattern>;
1472 class MVE_VQRDMULH<string suffix, bits<2> size, list<dag> pattern=[]>
1473   : MVE_VQxDMULH<"vqrdmulh", suffix, size, 0b1, pattern>;
1474
1475 def MVE_VQDMULHi8   : MVE_VQDMULH<"s8",  0b00>;
1476 def MVE_VQDMULHi16  : MVE_VQDMULH<"s16", 0b01>;
1477 def MVE_VQDMULHi32  : MVE_VQDMULH<"s32", 0b10>;
1478
1479 def MVE_VQRDMULHi8  : MVE_VQRDMULH<"s8",  0b00>;
1480 def MVE_VQRDMULHi16 : MVE_VQRDMULH<"s16", 0b01>;
1481 def MVE_VQRDMULHi32 : MVE_VQRDMULH<"s32", 0b10>;
1482
1483 class MVE_VADDSUB<string iname, string suffix, bits<2> size, bit subtract,
1484                     list<dag> pattern=[]>
1485   : MVE_int<iname, suffix, size, pattern> {
1486
1487   let Inst{28} = subtract;
1488   let Inst{25-23} = 0b110;
1489   let Inst{16} = 0b0;
1490   let Inst{12-8} = 0b01000;
1491   let Inst{4} = 0b0;
1492   let Inst{0} = 0b0;
1493 }
1494
1495 class MVE_VADD<string suffix, bits<2> size, list<dag> pattern=[]>
1496   : MVE_VADDSUB<"vadd", suffix, size, 0b0, pattern>;
1497 class MVE_VSUB<string suffix, bits<2> size, list<dag> pattern=[]>
1498   : MVE_VADDSUB<"vsub", suffix, size, 0b1, pattern>;
1499
1500 def MVE_VADDi8  : MVE_VADD<"i8",  0b00>;
1501 def MVE_VADDi16 : MVE_VADD<"i16", 0b01>;
1502 def MVE_VADDi32 : MVE_VADD<"i32", 0b10>;
1503
1504 let Predicates = [HasMVEInt] in {
1505   def : Pat<(v16i8 (add (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1506             (v16i8 (MVE_VADDi8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1507   def : Pat<(v8i16 (add (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1508             (v8i16 (MVE_VADDi16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1509   def : Pat<(v4i32 (add (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1510             (v4i32 (MVE_VADDi32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1511 }
1512
1513 def MVE_VSUBi8  : MVE_VSUB<"i8",  0b00>;
1514 def MVE_VSUBi16 : MVE_VSUB<"i16", 0b01>;
1515 def MVE_VSUBi32 : MVE_VSUB<"i32", 0b10>;
1516
1517 let Predicates = [HasMVEInt] in {
1518   def : Pat<(v16i8 (sub (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1519             (v16i8 (MVE_VSUBi8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1520   def : Pat<(v8i16 (sub (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1521             (v8i16 (MVE_VSUBi16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1522   def : Pat<(v4i32 (sub (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1523             (v4i32 (MVE_VSUBi32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1524 }
1525
1526 class MVE_VQADDSUB<string iname, string suffix, bit U, bit subtract,
1527                    bits<2> size, ValueType vt>
1528   : MVE_int<iname, suffix, size, []> {
1529
1530   let Inst{28} = U;
1531   let Inst{25-23} = 0b110;
1532   let Inst{16} = 0b0;
1533   let Inst{12-10} = 0b000;
1534   let Inst{9} = subtract;
1535   let Inst{8} = 0b0;
1536   let Inst{4} = 0b1;
1537   let Inst{0} = 0b0;
1538
1539   ValueType VT = vt;
1540 }
1541
1542 class MVE_VQADD<string suffix, bit U, bits<2> size, ValueType VT>
1543   : MVE_VQADDSUB<"vqadd", suffix, U, 0b0, size, VT>;
1544 class MVE_VQSUB<string suffix, bit U, bits<2> size, ValueType VT>
1545   : MVE_VQADDSUB<"vqsub", suffix, U, 0b1, size, VT>;
1546
1547 def MVE_VQADDs8  : MVE_VQADD<"s8",  0b0, 0b00, v16i8>;
1548 def MVE_VQADDs16 : MVE_VQADD<"s16", 0b0, 0b01, v8i16>;
1549 def MVE_VQADDs32 : MVE_VQADD<"s32", 0b0, 0b10, v4i32>;
1550 def MVE_VQADDu8  : MVE_VQADD<"u8",  0b1, 0b00, v16i8>;
1551 def MVE_VQADDu16 : MVE_VQADD<"u16", 0b1, 0b01, v8i16>;
1552 def MVE_VQADDu32 : MVE_VQADD<"u32", 0b1, 0b10, v4i32>;
1553
1554 def MVE_VQSUBs8  : MVE_VQSUB<"s8",  0b0, 0b00, v16i8>;
1555 def MVE_VQSUBs16 : MVE_VQSUB<"s16", 0b0, 0b01, v8i16>;
1556 def MVE_VQSUBs32 : MVE_VQSUB<"s32", 0b0, 0b10, v4i32>;
1557 def MVE_VQSUBu8  : MVE_VQSUB<"u8",  0b1, 0b00, v16i8>;
1558 def MVE_VQSUBu16 : MVE_VQSUB<"u16", 0b1, 0b01, v8i16>;
1559 def MVE_VQSUBu32 : MVE_VQSUB<"u32", 0b1, 0b10, v4i32>;
1560
1561 let Predicates = [HasMVEInt] in {
1562   foreach instr = [MVE_VQADDu8, MVE_VQADDu16, MVE_VQADDu32] in
1563     foreach VT = [instr.VT] in
1564       def : Pat<(VT (uaddsat (VT MQPR:$Qm), (VT MQPR:$Qn))),
1565                 (VT (instr (VT MQPR:$Qm), (VT MQPR:$Qn)))>;
1566   foreach instr = [MVE_VQADDs8, MVE_VQADDs16, MVE_VQADDs32] in
1567     foreach VT = [instr.VT] in
1568       def : Pat<(VT (saddsat (VT MQPR:$Qm), (VT MQPR:$Qn))),
1569                 (VT (instr (VT MQPR:$Qm), (VT MQPR:$Qn)))>;
1570   foreach instr = [MVE_VQSUBu8, MVE_VQSUBu16, MVE_VQSUBu32] in
1571     foreach VT = [instr.VT] in
1572       def : Pat<(VT (usubsat (VT MQPR:$Qm), (VT MQPR:$Qn))),
1573                 (VT (instr (VT MQPR:$Qm), (VT MQPR:$Qn)))>;
1574   foreach instr = [MVE_VQSUBs8, MVE_VQSUBs16, MVE_VQSUBs32] in
1575     foreach VT = [instr.VT] in
1576       def : Pat<(VT (ssubsat (VT MQPR:$Qm), (VT MQPR:$Qn))),
1577                 (VT (instr (VT MQPR:$Qm), (VT MQPR:$Qn)))>;
1578 }
1579
1580
1581 class MVE_VABD_int<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1582   : MVE_int<"vabd", suffix, size, pattern> {
1583
1584   let Inst{28} = U;
1585   let Inst{25-23} = 0b110;
1586   let Inst{16} = 0b0;
1587   let Inst{12-8} = 0b00111;
1588   let Inst{4} = 0b0;
1589   let Inst{0} = 0b0;
1590 }
1591
1592 def MVE_VABDs8  : MVE_VABD_int<"s8", 0b0, 0b00>;
1593 def MVE_VABDs16 : MVE_VABD_int<"s16", 0b0, 0b01>;
1594 def MVE_VABDs32 : MVE_VABD_int<"s32", 0b0, 0b10>;
1595 def MVE_VABDu8  : MVE_VABD_int<"u8", 0b1, 0b00>;
1596 def MVE_VABDu16 : MVE_VABD_int<"u16", 0b1, 0b01>;
1597 def MVE_VABDu32 : MVE_VABD_int<"u32", 0b1, 0b10>;
1598
1599 class MVE_VRHADD<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1600   : MVE_int<"vrhadd", suffix, size, pattern> {
1601
1602   let Inst{28} = U;
1603   let Inst{25-23} = 0b110;
1604   let Inst{16} = 0b0;
1605   let Inst{12-8} = 0b00001;
1606   let Inst{4} = 0b0;
1607   let Inst{0} = 0b0;
1608 }
1609
1610 def MVE_VRHADDs8  : MVE_VRHADD<"s8", 0b0, 0b00>;
1611 def MVE_VRHADDs16 : MVE_VRHADD<"s16", 0b0, 0b01>;
1612 def MVE_VRHADDs32 : MVE_VRHADD<"s32", 0b0, 0b10>;
1613 def MVE_VRHADDu8  : MVE_VRHADD<"u8", 0b1, 0b00>;
1614 def MVE_VRHADDu16 : MVE_VRHADD<"u16", 0b1, 0b01>;
1615 def MVE_VRHADDu32 : MVE_VRHADD<"u32", 0b1, 0b10>;
1616
1617 class MVE_VHADDSUB<string iname, string suffix, bit U, bit subtract,
1618                    bits<2> size, list<dag> pattern=[]>
1619   : MVE_int<iname, suffix, size, pattern> {
1620
1621   let Inst{28} = U;
1622   let Inst{25-23} = 0b110;
1623   let Inst{16} = 0b0;
1624   let Inst{12-10} = 0b000;
1625   let Inst{9} = subtract;
1626   let Inst{8} = 0b0;
1627   let Inst{4} = 0b0;
1628   let Inst{0} = 0b0;
1629 }
1630
1631 class MVE_VHADD<string suffix, bit U, bits<2> size,
1632               list<dag> pattern=[]>
1633   : MVE_VHADDSUB<"vhadd", suffix, U, 0b0, size, pattern>;
1634 class MVE_VHSUB<string suffix, bit U, bits<2> size,
1635               list<dag> pattern=[]>
1636   : MVE_VHADDSUB<"vhsub", suffix, U, 0b1, size, pattern>;
1637
1638 def MVE_VHADDs8  : MVE_VHADD<"s8",  0b0, 0b00>;
1639 def MVE_VHADDs16 : MVE_VHADD<"s16", 0b0, 0b01>;
1640 def MVE_VHADDs32 : MVE_VHADD<"s32", 0b0, 0b10>;
1641 def MVE_VHADDu8  : MVE_VHADD<"u8",  0b1, 0b00>;
1642 def MVE_VHADDu16 : MVE_VHADD<"u16", 0b1, 0b01>;
1643 def MVE_VHADDu32 : MVE_VHADD<"u32", 0b1, 0b10>;
1644
1645 def MVE_VHSUBs8  : MVE_VHSUB<"s8",  0b0, 0b00>;
1646 def MVE_VHSUBs16 : MVE_VHSUB<"s16", 0b0, 0b01>;
1647 def MVE_VHSUBs32 : MVE_VHSUB<"s32", 0b0, 0b10>;
1648 def MVE_VHSUBu8  : MVE_VHSUB<"u8",  0b1, 0b00>;
1649 def MVE_VHSUBu16 : MVE_VHSUB<"u16", 0b1, 0b01>;
1650 def MVE_VHSUBu32 : MVE_VHSUB<"u32", 0b1, 0b10>;
1651
1652 let Predicates = [HasMVEInt] in {
1653   def : Pat<(v16i8 (ARMvshrsImm
1654                      (v16i8 (add (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))), 1)),
1655             (v16i8 (MVE_VHADDs8
1656                      (v16i8 MQPR:$v1), (v16i8 MQPR:$v2)))>;
1657   def : Pat<(v8i16 (ARMvshrsImm
1658                      (v8i16 (add (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))), 1)),
1659             (v8i16 (MVE_VHADDs16
1660                      (v8i16 MQPR:$v1), (v8i16 MQPR:$v2)))>;
1661   def : Pat<(v4i32 (ARMvshrsImm
1662                      (v4i32 (add (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))), 1)),
1663             (v4i32 (MVE_VHADDs32
1664                      (v4i32 MQPR:$v1), (v4i32 MQPR:$v2)))>;
1665
1666   def : Pat<(v16i8 (ARMvshruImm
1667                      (v16i8 (add (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))), 1)),
1668             (v16i8 (MVE_VHADDu8
1669                      (v16i8 MQPR:$v1), (v16i8 MQPR:$v2)))>;
1670   def : Pat<(v8i16 (ARMvshruImm
1671                      (v8i16 (add (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))), 1)),
1672             (v8i16 (MVE_VHADDu16
1673                      (v8i16 MQPR:$v1), (v8i16 MQPR:$v2)))>;
1674   def : Pat<(v4i32 (ARMvshruImm
1675                      (v4i32 (add (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))), 1)),
1676             (v4i32 (MVE_VHADDu32
1677                      (v4i32 MQPR:$v1), (v4i32 MQPR:$v2)))>;
1678
1679   def : Pat<(v16i8 (ARMvshrsImm
1680                      (v16i8 (sub (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))), 1)),
1681             (v16i8 (MVE_VHSUBs8
1682                      (v16i8 MQPR:$v1), (v16i8 MQPR:$v2)))>;
1683   def : Pat<(v8i16 (ARMvshrsImm
1684                      (v8i16 (sub (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))), 1)),
1685             (v8i16 (MVE_VHSUBs16
1686                      (v8i16 MQPR:$v1), (v8i16 MQPR:$v2)))>;
1687   def : Pat<(v4i32 (ARMvshrsImm
1688                      (v4i32 (sub (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))), 1)),
1689             (v4i32 (MVE_VHSUBs32
1690                      (v4i32 MQPR:$v1), (v4i32 MQPR:$v2)))>;
1691
1692   def : Pat<(v16i8 (ARMvshruImm
1693                      (v16i8 (sub (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))), 1)),
1694             (v16i8 (MVE_VHSUBu8
1695                      (v16i8 MQPR:$v1), (v16i8 MQPR:$v2)))>;
1696   def : Pat<(v8i16 (ARMvshruImm
1697                      (v8i16 (sub (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))), 1)),
1698             (v8i16 (MVE_VHSUBu16
1699                      (v8i16 MQPR:$v1), (v8i16 MQPR:$v2)))>;
1700   def : Pat<(v4i32 (ARMvshruImm
1701                      (v4i32 (sub (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))), 1)),
1702             (v4i32 (MVE_VHSUBu32
1703                      (v4i32 MQPR:$v1), (v4i32 MQPR:$v2)))>;
1704 }
1705
1706 class MVE_VDUP<string suffix, bit B, bit E, list<dag> pattern=[]>
1707   : MVE_p<(outs MQPR:$Qd), (ins rGPR:$Rt), NoItinerary,
1708           "vdup", suffix, "$Qd, $Rt", vpred_r, "", pattern> {
1709   bits<4> Qd;
1710   bits<4> Rt;
1711
1712   let Inst{28} = 0b0;
1713   let Inst{25-23} = 0b101;
1714   let Inst{22} = B;
1715   let Inst{21-20} = 0b10;
1716   let Inst{19-17} = Qd{2-0};
1717   let Inst{16} = 0b0;
1718   let Inst{15-12} = Rt;
1719   let Inst{11-8} = 0b1011;
1720   let Inst{7} = Qd{3};
1721   let Inst{6} = 0b0;
1722   let Inst{5} = E;
1723   let Inst{4-0} = 0b10000;
1724 }
1725
1726 def MVE_VDUP32 : MVE_VDUP<"32", 0b0, 0b0>;
1727 def MVE_VDUP16 : MVE_VDUP<"16", 0b0, 0b1>;
1728 def MVE_VDUP8  : MVE_VDUP<"8",  0b1, 0b0>;
1729
1730 let Predicates = [HasMVEInt] in {
1731   def : Pat<(v16i8 (ARMvdup (i32 rGPR:$elem))),
1732             (MVE_VDUP8  rGPR:$elem)>;
1733   def : Pat<(v8i16 (ARMvdup (i32 rGPR:$elem))),
1734             (MVE_VDUP16 rGPR:$elem)>;
1735   def : Pat<(v4i32 (ARMvdup (i32 rGPR:$elem))),
1736             (MVE_VDUP32 rGPR:$elem)>;
1737
1738   def : Pat<(v4i32 (ARMvduplane (v4i32 MQPR:$src), imm:$lane)),
1739             (MVE_VDUP32 (MVE_VMOV_from_lane_32 MQPR:$src, imm:$lane))>;
1740   // For the 16-bit and 8-bit vduplanes we don't care about the signedness
1741   // of the lane move operation as we only want the lowest 8/16 bits anyway.
1742   def : Pat<(v8i16 (ARMvduplane (v8i16 MQPR:$src), imm:$lane)),
1743             (MVE_VDUP16 (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane))>;
1744   def : Pat<(v16i8 (ARMvduplane (v16i8 MQPR:$src), imm:$lane)),
1745             (MVE_VDUP8  (MVE_VMOV_from_lane_u8 MQPR:$src, imm:$lane))>;
1746
1747   def : Pat<(v4f32 (ARMvdup (f32 SPR:$elem))),
1748             (v4f32 (MVE_VDUP32 (i32 (COPY_TO_REGCLASS (f32 SPR:$elem), rGPR))))>;
1749   def : Pat<(v8f16 (ARMvdup (f16 HPR:$elem))),
1750             (v8f16 (MVE_VDUP16 (i32 (COPY_TO_REGCLASS (f16 HPR:$elem), rGPR))))>;
1751
1752   def : Pat<(v4f32 (ARMvduplane (v4f32 MQPR:$src), imm:$lane)),
1753             (MVE_VDUP32 (MVE_VMOV_from_lane_32 MQPR:$src, imm:$lane))>;
1754   def : Pat<(v8f16 (ARMvduplane (v8f16 MQPR:$src), imm:$lane)),
1755             (MVE_VDUP16 (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane))>;
1756 }
1757
1758
1759 class MVEIntSingleSrc<string iname, string suffix, bits<2> size,
1760                          list<dag> pattern=[]>
1761   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qm), NoItinerary,
1762           iname, suffix, "$Qd, $Qm", vpred_r, "", pattern> {
1763   bits<4> Qd;
1764   bits<4> Qm;
1765
1766   let Inst{22} = Qd{3};
1767   let Inst{19-18} = size{1-0};
1768   let Inst{15-13} = Qd{2-0};
1769   let Inst{5} = Qm{3};
1770   let Inst{3-1} = Qm{2-0};
1771 }
1772
1773 class MVE_VCLSCLZ<string iname, string suffix, bits<2> size,
1774                    bit count_zeroes, list<dag> pattern=[]>
1775   : MVEIntSingleSrc<iname, suffix, size, pattern> {
1776
1777   let Inst{28} = 0b1;
1778   let Inst{25-23} = 0b111;
1779   let Inst{21-20} = 0b11;
1780   let Inst{17-16} = 0b00;
1781   let Inst{12-8} = 0b00100;
1782   let Inst{7} = count_zeroes;
1783   let Inst{6} = 0b1;
1784   let Inst{4} = 0b0;
1785   let Inst{0} = 0b0;
1786 }
1787
1788 def MVE_VCLSs8  : MVE_VCLSCLZ<"vcls", "s8",  0b00, 0b0>;
1789 def MVE_VCLSs16 : MVE_VCLSCLZ<"vcls", "s16", 0b01, 0b0>;
1790 def MVE_VCLSs32 : MVE_VCLSCLZ<"vcls", "s32", 0b10, 0b0>;
1791
1792 def MVE_VCLZs8  : MVE_VCLSCLZ<"vclz", "i8",  0b00, 0b1>;
1793 def MVE_VCLZs16 : MVE_VCLSCLZ<"vclz", "i16", 0b01, 0b1>;
1794 def MVE_VCLZs32 : MVE_VCLSCLZ<"vclz", "i32", 0b10, 0b1>;
1795
1796 let Predicates = [HasMVEInt] in {
1797   def : Pat<(v16i8 ( ctlz (v16i8 MQPR:$val1))),
1798             (v16i8 ( MVE_VCLZs8 (v16i8 MQPR:$val1)))>;
1799   def : Pat<(v4i32 ( ctlz (v4i32 MQPR:$val1))),
1800             (v4i32 ( MVE_VCLZs32 (v4i32 MQPR:$val1)))>;
1801   def : Pat<(v8i16 ( ctlz (v8i16 MQPR:$val1))),
1802             (v8i16 ( MVE_VCLZs16 (v8i16 MQPR:$val1)))>;
1803 }
1804
1805 class MVE_VABSNEG_int<string iname, string suffix, bits<2> size, bit negate,
1806                       list<dag> pattern=[]>
1807   : MVEIntSingleSrc<iname, suffix, size, pattern> {
1808
1809   let Inst{28} = 0b1;
1810   let Inst{25-23} = 0b111;
1811   let Inst{21-20} = 0b11;
1812   let Inst{17-16} = 0b01;
1813   let Inst{12-8} = 0b00011;
1814   let Inst{7} = negate;
1815   let Inst{6} = 0b1;
1816   let Inst{4} = 0b0;
1817   let Inst{0} = 0b0;
1818 }
1819
1820 def MVE_VABSs8  : MVE_VABSNEG_int<"vabs", "s8",  0b00, 0b0>;
1821 def MVE_VABSs16 : MVE_VABSNEG_int<"vabs", "s16", 0b01, 0b0>;
1822 def MVE_VABSs32 : MVE_VABSNEG_int<"vabs", "s32", 0b10, 0b0>;
1823
1824 let Predicates = [HasMVEInt] in {
1825   def : Pat<(v16i8 (abs (v16i8 MQPR:$v))),
1826             (v16i8 (MVE_VABSs8 $v))>;
1827   def : Pat<(v8i16 (abs (v8i16 MQPR:$v))),
1828             (v8i16 (MVE_VABSs16 $v))>;
1829   def : Pat<(v4i32 (abs (v4i32 MQPR:$v))),
1830             (v4i32 (MVE_VABSs32 $v))>;
1831 }
1832
1833 def MVE_VNEGs8  : MVE_VABSNEG_int<"vneg", "s8",  0b00, 0b1>;
1834 def MVE_VNEGs16 : MVE_VABSNEG_int<"vneg", "s16", 0b01, 0b1>;
1835 def MVE_VNEGs32 : MVE_VABSNEG_int<"vneg", "s32", 0b10, 0b1>;
1836
1837 let Predicates = [HasMVEInt] in {
1838   def : Pat<(v16i8 (vnegq (v16i8 MQPR:$v))),
1839             (v16i8 (MVE_VNEGs8 $v))>;
1840   def : Pat<(v8i16 (vnegq (v8i16 MQPR:$v))),
1841             (v8i16 (MVE_VNEGs16 $v))>;
1842   def : Pat<(v4i32 (vnegq (v4i32 MQPR:$v))),
1843             (v4i32 (MVE_VNEGs32 $v))>;
1844 }
1845
1846 class MVE_VQABSNEG<string iname, string suffix, bits<2> size,
1847                    bit negate, list<dag> pattern=[]>
1848   : MVEIntSingleSrc<iname, suffix, size, pattern> {
1849
1850   let Inst{28} = 0b1;
1851   let Inst{25-23} = 0b111;
1852   let Inst{21-20} = 0b11;
1853   let Inst{17-16} = 0b00;
1854   let Inst{12-8} = 0b00111;
1855   let Inst{7} = negate;
1856   let Inst{6} = 0b1;
1857   let Inst{4} = 0b0;
1858   let Inst{0} = 0b0;
1859 }
1860
1861 def MVE_VQABSs8  : MVE_VQABSNEG<"vqabs", "s8",  0b00, 0b0>;
1862 def MVE_VQABSs16 : MVE_VQABSNEG<"vqabs", "s16", 0b01, 0b0>;
1863 def MVE_VQABSs32 : MVE_VQABSNEG<"vqabs", "s32", 0b10, 0b0>;
1864
1865 def MVE_VQNEGs8  : MVE_VQABSNEG<"vqneg", "s8",  0b00, 0b1>;
1866 def MVE_VQNEGs16 : MVE_VQABSNEG<"vqneg", "s16", 0b01, 0b1>;
1867 def MVE_VQNEGs32 : MVE_VQABSNEG<"vqneg", "s32", 0b10, 0b1>;
1868
1869 class MVE_mod_imm<string iname, string suffix, bits<4> cmode, bit op,
1870                   dag iops, list<dag> pattern=[]>
1871   : MVE_p<(outs MQPR:$Qd), iops, NoItinerary, iname, suffix, "$Qd, $imm",
1872           vpred_r, "", pattern> {
1873   bits<13> imm;
1874   bits<4> Qd;
1875
1876   let Inst{28} = imm{7};
1877   let Inst{25-23} = 0b111;
1878   let Inst{22} = Qd{3};
1879   let Inst{21-19} = 0b000;
1880   let Inst{18-16} = imm{6-4};
1881   let Inst{15-13} = Qd{2-0};
1882   let Inst{12} = 0b0;
1883   let Inst{11-8} = cmode{3-0};
1884   let Inst{7-6} = 0b01;
1885   let Inst{5} = op;
1886   let Inst{4} = 0b1;
1887   let Inst{3-0} = imm{3-0};
1888
1889   let DecoderMethod = "DecodeMVEModImmInstruction";
1890 }
1891
1892 let isReMaterializable = 1 in {
1893 let isAsCheapAsAMove = 1 in {
1894 def MVE_VMOVimmi8  : MVE_mod_imm<"vmov", "i8",  {1,1,1,0}, 0b0, (ins nImmSplatI8:$imm)>;
1895 def MVE_VMOVimmi16 : MVE_mod_imm<"vmov", "i16", {1,0,?,0}, 0b0, (ins nImmSplatI16:$imm)> {
1896   let Inst{9} = imm{9};
1897 }
1898 def MVE_VMOVimmi32 : MVE_mod_imm<"vmov", "i32", {?,?,?,?}, 0b0, (ins nImmVMOVI32:$imm)> {
1899   let Inst{11-8} = imm{11-8};
1900 }
1901 def MVE_VMOVimmi64 : MVE_mod_imm<"vmov", "i64", {1,1,1,0}, 0b1, (ins nImmSplatI64:$imm)>;
1902 def MVE_VMOVimmf32 : MVE_mod_imm<"vmov", "f32", {1,1,1,1}, 0b0, (ins nImmVMOVF32:$imm)>;
1903 } // let isAsCheapAsAMove = 1
1904
1905 def MVE_VMVNimmi16 : MVE_mod_imm<"vmvn", "i16", {1,0,?,0}, 0b1, (ins nImmSplatI16:$imm)> {
1906   let Inst{9} = imm{9};
1907 }
1908 def MVE_VMVNimmi32 : MVE_mod_imm<"vmvn", "i32", {?,?,?,?}, 0b1, (ins nImmVMOVI32:$imm)> {
1909   let Inst{11-8} = imm{11-8};
1910 }
1911 } // let isReMaterializable = 1
1912
1913 let Predicates = [HasMVEInt] in {
1914   def : Pat<(v16i8 (ARMvmovImm timm:$simm)),
1915             (v16i8 (MVE_VMOVimmi8  nImmSplatI8:$simm))>;
1916   def : Pat<(v8i16 (ARMvmovImm timm:$simm)),
1917             (v8i16 (MVE_VMOVimmi16 nImmSplatI16:$simm))>;
1918   def : Pat<(v4i32 (ARMvmovImm timm:$simm)),
1919             (v4i32 (MVE_VMOVimmi32 nImmVMOVI32:$simm))>;
1920
1921   def : Pat<(v8i16 (ARMvmvnImm timm:$simm)),
1922             (v8i16 (MVE_VMVNimmi16 nImmSplatI16:$simm))>;
1923   def : Pat<(v4i32 (ARMvmvnImm timm:$simm)),
1924             (v4i32 (MVE_VMVNimmi32 nImmVMOVI32:$simm))>;
1925
1926   def : Pat<(v4f32 (ARMvmovFPImm timm:$simm)),
1927             (v4f32 (MVE_VMOVimmf32 nImmVMOVF32:$simm))>;
1928 }
1929
1930 class MVE_VMINMAXA<string iname, string suffix, bits<2> size,
1931                    bit bit_12, list<dag> pattern=[]>
1932   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
1933           NoItinerary, iname, suffix, "$Qd, $Qm", vpred_n, "$Qd = $Qd_src",
1934           pattern> {
1935   bits<4> Qd;
1936   bits<4> Qm;
1937
1938   let Inst{28} = 0b0;
1939   let Inst{25-23} = 0b100;
1940   let Inst{22} = Qd{3};
1941   let Inst{21-20} = 0b11;
1942   let Inst{19-18} = size;
1943   let Inst{17-16} = 0b11;
1944   let Inst{15-13} = Qd{2-0};
1945   let Inst{12} = bit_12;
1946   let Inst{11-6} = 0b111010;
1947   let Inst{5} = Qm{3};
1948   let Inst{4} = 0b0;
1949   let Inst{3-1} = Qm{2-0};
1950   let Inst{0} = 0b1;
1951 }
1952
1953 def MVE_VMAXAs8  : MVE_VMINMAXA<"vmaxa", "s8",  0b00, 0b0>;
1954 def MVE_VMAXAs16 : MVE_VMINMAXA<"vmaxa", "s16", 0b01, 0b0>;
1955 def MVE_VMAXAs32 : MVE_VMINMAXA<"vmaxa", "s32", 0b10, 0b0>;
1956
1957 def MVE_VMINAs8  : MVE_VMINMAXA<"vmina", "s8",  0b00, 0b1>;
1958 def MVE_VMINAs16 : MVE_VMINMAXA<"vmina", "s16", 0b01, 0b1>;
1959 def MVE_VMINAs32 : MVE_VMINMAXA<"vmina", "s32", 0b10, 0b1>;
1960
1961 // end of MVE Integer instructions
1962
1963 // start of mve_imm_shift instructions
1964
1965 def MVE_VSHLC : MVE_p<(outs rGPR:$RdmDest, MQPR:$Qd),
1966                       (ins MQPR:$QdSrc, rGPR:$RdmSrc, long_shift:$imm),
1967                       NoItinerary, "vshlc", "", "$QdSrc, $RdmSrc, $imm",
1968                       vpred_n, "$RdmDest = $RdmSrc,$Qd = $QdSrc"> {
1969   bits<5> imm;
1970   bits<4> Qd;
1971   bits<4> RdmDest;
1972
1973   let Inst{28} = 0b0;
1974   let Inst{25-23} = 0b101;
1975   let Inst{22} = Qd{3};
1976   let Inst{21} = 0b1;
1977   let Inst{20-16} = imm{4-0};
1978   let Inst{15-13} = Qd{2-0};
1979   let Inst{12-4} = 0b011111100;
1980   let Inst{3-0} = RdmDest{3-0};
1981 }
1982
1983 class MVE_shift_imm<dag oops, dag iops, string iname, string suffix,
1984                     string ops, vpred_ops vpred, string cstr,
1985                     list<dag> pattern=[]>
1986   : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
1987   bits<4> Qd;
1988   bits<4> Qm;
1989
1990   let Inst{22} = Qd{3};
1991   let Inst{15-13} = Qd{2-0};
1992   let Inst{5} = Qm{3};
1993   let Inst{3-1} = Qm{2-0};
1994 }
1995
1996 class MVE_VMOVL<string iname, string suffix, bits<2> sz, bit U,
1997               list<dag> pattern=[]>
1998   : MVE_shift_imm<(outs MQPR:$Qd), (ins MQPR:$Qm),
1999                   iname, suffix, "$Qd, $Qm", vpred_r, "",
2000                   pattern> {
2001   let Inst{28} = U;
2002   let Inst{25-23} = 0b101;
2003   let Inst{21} = 0b1;
2004   let Inst{20-19} = sz{1-0};
2005   let Inst{18-16} = 0b000;
2006   let Inst{11-6} = 0b111101;
2007   let Inst{4} = 0b0;
2008   let Inst{0} = 0b0;
2009 }
2010
2011 multiclass MVE_VMOVL_shift_half<string iname, string suffix, bits<2> sz, bit U,
2012                                 list<dag> pattern=[]> {
2013   def bh : MVE_VMOVL<!strconcat(iname, "b"), suffix, sz, U, pattern> {
2014     let Inst{12} = 0b0;
2015   }
2016   def th : MVE_VMOVL<!strconcat(iname, "t"), suffix, sz, U, pattern> {
2017     let Inst{12} = 0b1;
2018   }
2019 }
2020
2021 defm MVE_VMOVLs8 : MVE_VMOVL_shift_half<"vmovl", "s8", 0b01, 0b0>;
2022 defm MVE_VMOVLu8 : MVE_VMOVL_shift_half<"vmovl", "u8", 0b01, 0b1>;
2023 defm MVE_VMOVLs16 : MVE_VMOVL_shift_half<"vmovl", "s16", 0b10, 0b0>;
2024 defm MVE_VMOVLu16 : MVE_VMOVL_shift_half<"vmovl", "u16", 0b10, 0b1>;
2025
2026 let Predicates = [HasMVEInt] in {
2027   def : Pat<(sext_inreg (v4i32 MQPR:$src), v4i16),
2028             (MVE_VMOVLs16bh MQPR:$src)>;
2029   def : Pat<(sext_inreg (v8i16 MQPR:$src), v8i8),
2030             (MVE_VMOVLs8bh MQPR:$src)>;
2031   def : Pat<(sext_inreg (v4i32 MQPR:$src), v4i8),
2032             (MVE_VMOVLs16bh (MVE_VMOVLs8bh MQPR:$src))>;
2033
2034   // zext_inreg 16 -> 32
2035   def : Pat<(and (v4i32 MQPR:$src), (v4i32 (ARMvmovImm (i32 0xCFF)))),
2036             (MVE_VMOVLu16bh MQPR:$src)>;
2037   // zext_inreg 8 -> 16
2038   def : Pat<(and (v8i16 MQPR:$src), (v8i16 (ARMvmovImm (i32 0x8FF)))),
2039             (MVE_VMOVLu8bh MQPR:$src)>;
2040 }
2041
2042
2043 class MVE_VSHLL_imm<string iname, string suffix, bit U, bit th,
2044                     dag immops, list<dag> pattern=[]>
2045   : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$Qm), immops),
2046                   iname, suffix, "$Qd, $Qm, $imm", vpred_r, "", pattern> {
2047   let Inst{28} = U;
2048   let Inst{25-23} = 0b101;
2049   let Inst{21} = 0b1;
2050   let Inst{12} = th;
2051   let Inst{11-6} = 0b111101;
2052   let Inst{4} = 0b0;
2053   let Inst{0} = 0b0;
2054 }
2055
2056 // The immediate VSHLL instructions accept shift counts from 1 up to
2057 // the lane width (8 or 16), but the full-width shifts have an
2058 // entirely separate encoding, given below with 'lw' in the name.
2059
2060 class MVE_VSHLL_imm8<string iname, string suffix,
2061                      bit U, bit th, list<dag> pattern=[]>
2062   : MVE_VSHLL_imm<iname, suffix, U, th, (ins mve_shift_imm1_7:$imm), pattern> {
2063   bits<3> imm;
2064   let Inst{20-19} = 0b01;
2065   let Inst{18-16} = imm;
2066 }
2067
2068 class MVE_VSHLL_imm16<string iname, string suffix,
2069                       bit U, bit th, list<dag> pattern=[]>
2070   : MVE_VSHLL_imm<iname, suffix, U, th, (ins mve_shift_imm1_15:$imm), pattern> {
2071   bits<4> imm;
2072   let Inst{20} = 0b1;
2073   let Inst{19-16} = imm;
2074 }
2075
2076 def MVE_VSHLL_imms8bh  : MVE_VSHLL_imm8 <"vshllb", "s8", 0b0, 0b0>;
2077 def MVE_VSHLL_imms8th  : MVE_VSHLL_imm8 <"vshllt", "s8", 0b0, 0b1>;
2078 def MVE_VSHLL_immu8bh  : MVE_VSHLL_imm8 <"vshllb", "u8", 0b1, 0b0>;
2079 def MVE_VSHLL_immu8th  : MVE_VSHLL_imm8 <"vshllt", "u8", 0b1, 0b1>;
2080 def MVE_VSHLL_imms16bh : MVE_VSHLL_imm16<"vshllb", "s16", 0b0, 0b0>;
2081 def MVE_VSHLL_imms16th : MVE_VSHLL_imm16<"vshllt", "s16", 0b0, 0b1>;
2082 def MVE_VSHLL_immu16bh : MVE_VSHLL_imm16<"vshllb", "u16", 0b1, 0b0>;
2083 def MVE_VSHLL_immu16th : MVE_VSHLL_imm16<"vshllt", "u16", 0b1, 0b1>;
2084
2085 class MVE_VSHLL_by_lane_width<string iname, string suffix, bits<2> size,
2086                               bit U, string ops, list<dag> pattern=[]>
2087   : MVE_shift_imm<(outs MQPR:$Qd), (ins MQPR:$Qm),
2088                   iname, suffix, ops, vpred_r, "", pattern> {
2089   let Inst{28} = U;
2090   let Inst{25-23} = 0b100;
2091   let Inst{21-20} = 0b11;
2092   let Inst{19-18} = size{1-0};
2093   let Inst{17-16} = 0b01;
2094   let Inst{11-6} = 0b111000;
2095   let Inst{4} = 0b0;
2096   let Inst{0} = 0b1;
2097 }
2098
2099 multiclass MVE_VSHLL_lw<string iname, string suffix, bits<2> sz, bit U,
2100                               string ops, list<dag> pattern=[]> {
2101   def bh : MVE_VSHLL_by_lane_width<iname#"b", suffix, sz, U, ops, pattern> {
2102     let Inst{12} = 0b0;
2103   }
2104   def th : MVE_VSHLL_by_lane_width<iname#"t", suffix, sz, U, ops, pattern> {
2105     let Inst{12} = 0b1;
2106   }
2107 }
2108
2109 defm MVE_VSHLL_lws8  : MVE_VSHLL_lw<"vshll", "s8",  0b00, 0b0, "$Qd, $Qm, #8">;
2110 defm MVE_VSHLL_lws16 : MVE_VSHLL_lw<"vshll", "s16", 0b01, 0b0, "$Qd, $Qm, #16">;
2111 defm MVE_VSHLL_lwu8  : MVE_VSHLL_lw<"vshll", "u8",  0b00, 0b1, "$Qd, $Qm, #8">;
2112 defm MVE_VSHLL_lwu16 : MVE_VSHLL_lw<"vshll", "u16", 0b01, 0b1, "$Qd, $Qm, #16">;
2113
2114 class MVE_VxSHRN<string iname, string suffix, bit bit_12, bit bit_28,
2115                dag immops, list<dag> pattern=[]>
2116   : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
2117                   iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
2118                   pattern> {
2119   bits<5> imm;
2120
2121   let Inst{28} = bit_28;
2122   let Inst{25-23} = 0b101;
2123   let Inst{21} = 0b0;
2124   let Inst{20-16} = imm{4-0};
2125   let Inst{12} = bit_12;
2126   let Inst{11-6} = 0b111111;
2127   let Inst{4} = 0b0;
2128   let Inst{0} = 0b1;
2129 }
2130
2131 def MVE_VRSHRNi16bh : MVE_VxSHRN<
2132     "vrshrnb", "i16", 0b0, 0b1, (ins shr_imm8:$imm)> {
2133   let Inst{20-19} = 0b01;
2134 }
2135 def MVE_VRSHRNi16th : MVE_VxSHRN<
2136     "vrshrnt", "i16", 0b1, 0b1,(ins shr_imm8:$imm)> {
2137   let Inst{20-19} = 0b01;
2138 }
2139 def MVE_VRSHRNi32bh : MVE_VxSHRN<
2140     "vrshrnb", "i32", 0b0, 0b1, (ins shr_imm16:$imm)> {
2141   let Inst{20} = 0b1;
2142 }
2143 def MVE_VRSHRNi32th : MVE_VxSHRN<
2144     "vrshrnt", "i32", 0b1, 0b1, (ins shr_imm16:$imm)> {
2145   let Inst{20} = 0b1;
2146 }
2147
2148 def MVE_VSHRNi16bh : MVE_VxSHRN<
2149     "vshrnb", "i16", 0b0, 0b0, (ins shr_imm8:$imm)> {
2150   let Inst{20-19} = 0b01;
2151 }
2152 def MVE_VSHRNi16th : MVE_VxSHRN<
2153     "vshrnt", "i16", 0b1, 0b0, (ins shr_imm8:$imm)> {
2154   let Inst{20-19} = 0b01;
2155 }
2156 def MVE_VSHRNi32bh : MVE_VxSHRN<
2157     "vshrnb", "i32", 0b0, 0b0, (ins shr_imm16:$imm)> {
2158   let Inst{20} = 0b1;
2159 }
2160 def MVE_VSHRNi32th : MVE_VxSHRN<
2161     "vshrnt", "i32", 0b1, 0b0, (ins shr_imm16:$imm)> {
2162   let Inst{20} = 0b1;
2163 }
2164
2165 class MVE_VxQRSHRUN<string iname, string suffix, bit bit_28, bit bit_12, dag immops,
2166                  list<dag> pattern=[]>
2167   : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
2168                   iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
2169                   pattern> {
2170   bits<5> imm;
2171
2172   let Inst{28} = bit_28;
2173   let Inst{25-23} = 0b101;
2174   let Inst{21} = 0b0;
2175   let Inst{20-16} = imm{4-0};
2176   let Inst{12} = bit_12;
2177   let Inst{11-6} = 0b111111;
2178   let Inst{4} = 0b0;
2179   let Inst{0} = 0b0;
2180 }
2181
2182 def MVE_VQRSHRUNs16bh : MVE_VxQRSHRUN<
2183     "vqrshrunb", "s16", 0b1, 0b0, (ins shr_imm8:$imm)> {
2184   let Inst{20-19} = 0b01;
2185 }
2186 def MVE_VQRSHRUNs16th : MVE_VxQRSHRUN<
2187     "vqrshrunt", "s16", 0b1, 0b1, (ins shr_imm8:$imm)> {
2188   let Inst{20-19} = 0b01;
2189 }
2190 def MVE_VQRSHRUNs32bh : MVE_VxQRSHRUN<
2191     "vqrshrunb", "s32", 0b1, 0b0, (ins shr_imm16:$imm)> {
2192   let Inst{20} = 0b1;
2193 }
2194 def MVE_VQRSHRUNs32th : MVE_VxQRSHRUN<
2195     "vqrshrunt", "s32", 0b1, 0b1, (ins shr_imm16:$imm)> {
2196   let Inst{20} = 0b1;
2197 }
2198
2199 def MVE_VQSHRUNs16bh : MVE_VxQRSHRUN<
2200     "vqshrunb", "s16", 0b0, 0b0, (ins shr_imm8:$imm)> {
2201   let Inst{20-19} = 0b01;
2202 }
2203 def MVE_VQSHRUNs16th : MVE_VxQRSHRUN<
2204     "vqshrunt", "s16", 0b0, 0b1, (ins shr_imm8:$imm)> {
2205   let Inst{20-19} = 0b01;
2206 }
2207 def MVE_VQSHRUNs32bh : MVE_VxQRSHRUN<
2208     "vqshrunb", "s32", 0b0, 0b0, (ins shr_imm16:$imm)> {
2209   let Inst{20} = 0b1;
2210 }
2211 def MVE_VQSHRUNs32th : MVE_VxQRSHRUN<
2212     "vqshrunt", "s32", 0b0, 0b1, (ins shr_imm16:$imm)> {
2213   let Inst{20} = 0b1;
2214 }
2215
2216 class MVE_VxQRSHRN<string iname, string suffix, bit bit_0, bit bit_12,
2217                    dag immops, list<dag> pattern=[]>
2218   : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
2219                   iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
2220                   pattern> {
2221   bits<5> imm;
2222
2223   let Inst{25-23} = 0b101;
2224   let Inst{21} = 0b0;
2225   let Inst{20-16} = imm{4-0};
2226   let Inst{12} = bit_12;
2227   let Inst{11-6} = 0b111101;
2228   let Inst{4} = 0b0;
2229   let Inst{0} = bit_0;
2230 }
2231
2232 multiclass MVE_VxQRSHRN_types<string iname, bit bit_0, bit bit_12> {
2233   def s16 : MVE_VxQRSHRN<iname, "s16", bit_0, bit_12, (ins shr_imm8:$imm)> {
2234     let Inst{28} = 0b0;
2235     let Inst{20-19} = 0b01;
2236   }
2237   def u16 : MVE_VxQRSHRN<iname, "u16", bit_0, bit_12, (ins shr_imm8:$imm)> {
2238     let Inst{28} = 0b1;
2239     let Inst{20-19} = 0b01;
2240   }
2241   def s32 : MVE_VxQRSHRN<iname, "s32", bit_0, bit_12, (ins shr_imm16:$imm)> {
2242     let Inst{28} = 0b0;
2243     let Inst{20} = 0b1;
2244   }
2245   def u32 : MVE_VxQRSHRN<iname, "u32", bit_0, bit_12, (ins shr_imm16:$imm)> {
2246     let Inst{28} = 0b1;
2247     let Inst{20} = 0b1;
2248   }
2249 }
2250
2251 defm MVE_VQRSHRNbh : MVE_VxQRSHRN_types<"vqrshrnb", 0b1, 0b0>;
2252 defm MVE_VQRSHRNth : MVE_VxQRSHRN_types<"vqrshrnt", 0b1, 0b1>;
2253 defm MVE_VQSHRNbh  : MVE_VxQRSHRN_types<"vqshrnb", 0b0, 0b0>;
2254 defm MVE_VQSHRNth  : MVE_VxQRSHRN_types<"vqshrnt", 0b0, 0b1>;
2255
2256 // end of mve_imm_shift instructions
2257
2258 // start of mve_shift instructions
2259
2260 class MVE_shift_by_vec<string iname, string suffix, bit U,
2261                        bits<2> size, bit bit_4, bit bit_8>
2262   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qm, MQPR:$Qn), NoItinerary,
2263            iname, suffix, "$Qd, $Qm, $Qn", vpred_r, "", []> {
2264   // Shift instructions which take a vector of shift counts
2265   bits<4> Qd;
2266   bits<4> Qm;
2267   bits<4> Qn;
2268
2269   let Inst{28} = U;
2270   let Inst{25-24} = 0b11;
2271   let Inst{23} = 0b0;
2272   let Inst{22} = Qd{3};
2273   let Inst{21-20} = size;
2274   let Inst{19-17} = Qn{2-0};
2275   let Inst{16} = 0b0;
2276   let Inst{15-13} = Qd{2-0};
2277   let Inst{12-9} = 0b0010;
2278   let Inst{8} = bit_8;
2279   let Inst{7} = Qn{3};
2280   let Inst{6} = 0b1;
2281   let Inst{5} = Qm{3};
2282   let Inst{4} = bit_4;
2283   let Inst{3-1} = Qm{2-0};
2284   let Inst{0} = 0b0;
2285 }
2286
2287 multiclass mve_shift_by_vec_multi<string iname, bit bit_4, bit bit_8> {
2288   def s8  : MVE_shift_by_vec<iname, "s8", 0b0, 0b00, bit_4, bit_8>;
2289   def s16 : MVE_shift_by_vec<iname, "s16", 0b0, 0b01, bit_4, bit_8>;
2290   def s32 : MVE_shift_by_vec<iname, "s32", 0b0, 0b10, bit_4, bit_8>;
2291   def u8  : MVE_shift_by_vec<iname, "u8", 0b1, 0b00, bit_4, bit_8>;
2292   def u16 : MVE_shift_by_vec<iname, "u16", 0b1, 0b01, bit_4, bit_8>;
2293   def u32 : MVE_shift_by_vec<iname, "u32", 0b1, 0b10, bit_4, bit_8>;
2294 }
2295
2296 defm MVE_VSHL_by_vec   : mve_shift_by_vec_multi<"vshl",   0b0, 0b0>;
2297 defm MVE_VQSHL_by_vec  : mve_shift_by_vec_multi<"vqshl",  0b1, 0b0>;
2298 defm MVE_VQRSHL_by_vec : mve_shift_by_vec_multi<"vqrshl", 0b1, 0b1>;
2299 defm MVE_VRSHL_by_vec  : mve_shift_by_vec_multi<"vrshl",  0b0, 0b1>;
2300
2301 let Predicates = [HasMVEInt] in {
2302   def : Pat<(v4i32 (ARMvshlu (v4i32 MQPR:$Qm), (v4i32 MQPR:$Qn))),
2303             (v4i32 (MVE_VSHL_by_vecu32 (v4i32 MQPR:$Qm), (v4i32 MQPR:$Qn)))>;
2304   def : Pat<(v8i16 (ARMvshlu (v8i16 MQPR:$Qm), (v8i16 MQPR:$Qn))),
2305             (v8i16 (MVE_VSHL_by_vecu16 (v8i16 MQPR:$Qm), (v8i16 MQPR:$Qn)))>;
2306   def : Pat<(v16i8 (ARMvshlu (v16i8 MQPR:$Qm), (v16i8 MQPR:$Qn))),
2307             (v16i8 (MVE_VSHL_by_vecu8 (v16i8 MQPR:$Qm), (v16i8 MQPR:$Qn)))>;
2308
2309   def : Pat<(v4i32 (ARMvshls (v4i32 MQPR:$Qm), (v4i32 MQPR:$Qn))),
2310             (v4i32 (MVE_VSHL_by_vecs32 (v4i32 MQPR:$Qm), (v4i32 MQPR:$Qn)))>;
2311   def : Pat<(v8i16 (ARMvshls (v8i16 MQPR:$Qm), (v8i16 MQPR:$Qn))),
2312             (v8i16 (MVE_VSHL_by_vecs16 (v8i16 MQPR:$Qm), (v8i16 MQPR:$Qn)))>;
2313   def : Pat<(v16i8 (ARMvshls (v16i8 MQPR:$Qm), (v16i8 MQPR:$Qn))),
2314             (v16i8 (MVE_VSHL_by_vecs8 (v16i8 MQPR:$Qm), (v16i8 MQPR:$Qn)))>;
2315 }
2316
2317 class MVE_shift_with_imm<string iname, string suffix, dag oops, dag iops,
2318                          string ops, vpred_ops vpred, string cstr,
2319                          list<dag> pattern=[]>
2320   : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
2321   bits<4> Qd;
2322   bits<4> Qm;
2323
2324   let Inst{23} = 0b1;
2325   let Inst{22} = Qd{3};
2326   let Inst{15-13} = Qd{2-0};
2327   let Inst{12-11} = 0b00;
2328   let Inst{7-6} = 0b01;
2329   let Inst{5} = Qm{3};
2330   let Inst{4} = 0b1;
2331   let Inst{3-1} = Qm{2-0};
2332   let Inst{0} = 0b0;
2333 }
2334
2335 class MVE_VSxI_imm<string iname, string suffix, bit bit_8, dag imm>
2336   : MVE_shift_with_imm<iname, suffix, (outs MQPR:$Qd),
2337                        !con((ins MQPR:$Qd_src, MQPR:$Qm), imm),
2338                        "$Qd, $Qm, $imm", vpred_n, "$Qd = $Qd_src"> {
2339   bits<6> imm;
2340   let Inst{28} = 0b1;
2341   let Inst{25-24} = 0b11;
2342   let Inst{21-16} = imm;
2343   let Inst{10-9} = 0b10;
2344   let Inst{8} = bit_8;
2345 }
2346
2347 def MVE_VSRIimm8 : MVE_VSxI_imm<"vsri", "8", 0b0, (ins shr_imm8:$imm)> {
2348   let Inst{21-19} = 0b001;
2349 }
2350
2351 def MVE_VSRIimm16 : MVE_VSxI_imm<"vsri", "16", 0b0, (ins shr_imm16:$imm)> {
2352   let Inst{21-20} = 0b01;
2353 }
2354
2355 def MVE_VSRIimm32 : MVE_VSxI_imm<"vsri", "32", 0b0, (ins shr_imm32:$imm)> {
2356   let Inst{21} = 0b1;
2357 }
2358
2359 def MVE_VSLIimm8 : MVE_VSxI_imm<"vsli", "8", 0b1, (ins imm0_7:$imm)> {
2360   let Inst{21-19} = 0b001;
2361 }
2362
2363 def MVE_VSLIimm16 : MVE_VSxI_imm<"vsli", "16", 0b1, (ins imm0_15:$imm)> {
2364   let Inst{21-20} = 0b01;
2365 }
2366
2367 def MVE_VSLIimm32 : MVE_VSxI_imm<"vsli", "32", 0b1,(ins imm0_31:$imm)> {
2368   let Inst{21} = 0b1;
2369 }
2370
2371 class MVE_VQSHL_imm<string suffix, dag imm>
2372   : MVE_shift_with_imm<"vqshl", suffix, (outs MQPR:$Qd),
2373                        !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2374                        vpred_r, ""> {
2375   bits<6> imm;
2376
2377   let Inst{25-24} = 0b11;
2378   let Inst{21-16} = imm;
2379   let Inst{10-8} = 0b111;
2380 }
2381
2382 def MVE_VSLIimms8 : MVE_VQSHL_imm<"s8", (ins imm0_7:$imm)> {
2383   let Inst{28} = 0b0;
2384   let Inst{21-19} = 0b001;
2385 }
2386
2387 def MVE_VSLIimmu8 : MVE_VQSHL_imm<"u8", (ins imm0_7:$imm)> {
2388   let Inst{28} = 0b1;
2389   let Inst{21-19} = 0b001;
2390 }
2391
2392 def MVE_VSLIimms16 : MVE_VQSHL_imm<"s16", (ins imm0_15:$imm)> {
2393   let Inst{28} = 0b0;
2394   let Inst{21-20} = 0b01;
2395 }
2396
2397 def MVE_VSLIimmu16 : MVE_VQSHL_imm<"u16", (ins imm0_15:$imm)> {
2398   let Inst{28} = 0b1;
2399   let Inst{21-20} = 0b01;
2400 }
2401
2402 def MVE_VSLIimms32 : MVE_VQSHL_imm<"s32", (ins imm0_31:$imm)> {
2403   let Inst{28} = 0b0;
2404   let Inst{21} = 0b1;
2405 }
2406
2407 def MVE_VSLIimmu32 : MVE_VQSHL_imm<"u32", (ins imm0_31:$imm)> {
2408   let Inst{28} = 0b1;
2409   let Inst{21} = 0b1;
2410 }
2411
2412 class MVE_VQSHLU_imm<string suffix, dag imm>
2413   : MVE_shift_with_imm<"vqshlu", suffix, (outs MQPR:$Qd),
2414                        !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2415                        vpred_r, ""> {
2416   bits<6> imm;
2417
2418   let Inst{28} = 0b1;
2419   let Inst{25-24} = 0b11;
2420   let Inst{21-16} = imm;
2421   let Inst{10-8} = 0b110;
2422 }
2423
2424 def MVE_VQSHLU_imms8 : MVE_VQSHLU_imm<"s8", (ins imm0_7:$imm)> {
2425   let Inst{21-19} = 0b001;
2426 }
2427
2428 def MVE_VQSHLU_imms16 : MVE_VQSHLU_imm<"s16", (ins imm0_15:$imm)> {
2429   let Inst{21-20} = 0b01;
2430 }
2431
2432 def MVE_VQSHLU_imms32 : MVE_VQSHLU_imm<"s32", (ins imm0_31:$imm)> {
2433   let Inst{21} = 0b1;
2434 }
2435
2436 class MVE_VRSHR_imm<string suffix, dag imm>
2437   : MVE_shift_with_imm<"vrshr", suffix, (outs MQPR:$Qd),
2438                        !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2439                        vpred_r, ""> {
2440   bits<6> imm;
2441
2442   let Inst{25-24} = 0b11;
2443   let Inst{21-16} = imm;
2444   let Inst{10-8} = 0b010;
2445 }
2446
2447 def MVE_VRSHR_imms8 : MVE_VRSHR_imm<"s8", (ins shr_imm8:$imm)> {
2448   let Inst{28} = 0b0;
2449   let Inst{21-19} = 0b001;
2450 }
2451
2452 def MVE_VRSHR_immu8 : MVE_VRSHR_imm<"u8", (ins shr_imm8:$imm)> {
2453   let Inst{28} = 0b1;
2454   let Inst{21-19} = 0b001;
2455 }
2456
2457 def MVE_VRSHR_imms16 : MVE_VRSHR_imm<"s16", (ins shr_imm16:$imm)> {
2458   let Inst{28} = 0b0;
2459   let Inst{21-20} = 0b01;
2460 }
2461
2462 def MVE_VRSHR_immu16 : MVE_VRSHR_imm<"u16", (ins shr_imm16:$imm)> {
2463   let Inst{28} = 0b1;
2464   let Inst{21-20} = 0b01;
2465 }
2466
2467 def MVE_VRSHR_imms32 : MVE_VRSHR_imm<"s32", (ins shr_imm32:$imm)> {
2468   let Inst{28} = 0b0;
2469   let Inst{21} = 0b1;
2470 }
2471
2472 def MVE_VRSHR_immu32 : MVE_VRSHR_imm<"u32", (ins shr_imm32:$imm)> {
2473   let Inst{28} = 0b1;
2474   let Inst{21} = 0b1;
2475 }
2476
2477 class MVE_VSHR_imm<string suffix, dag imm>
2478   : MVE_shift_with_imm<"vshr", suffix, (outs MQPR:$Qd),
2479                        !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2480                        vpred_r, ""> {
2481   bits<6> imm;
2482
2483   let Inst{25-24} = 0b11;
2484   let Inst{21-16} = imm;
2485   let Inst{10-8} = 0b000;
2486 }
2487
2488 def MVE_VSHR_imms8 : MVE_VSHR_imm<"s8", (ins shr_imm8:$imm)> {
2489   let Inst{28} = 0b0;
2490   let Inst{21-19} = 0b001;
2491 }
2492
2493 def MVE_VSHR_immu8 : MVE_VSHR_imm<"u8", (ins shr_imm8:$imm)> {
2494   let Inst{28} = 0b1;
2495   let Inst{21-19} = 0b001;
2496 }
2497
2498 def MVE_VSHR_imms16 : MVE_VSHR_imm<"s16", (ins shr_imm16:$imm)> {
2499   let Inst{28} = 0b0;
2500   let Inst{21-20} = 0b01;
2501 }
2502
2503 def MVE_VSHR_immu16 : MVE_VSHR_imm<"u16", (ins shr_imm16:$imm)> {
2504   let Inst{28} = 0b1;
2505   let Inst{21-20} = 0b01;
2506 }
2507
2508 def MVE_VSHR_imms32 : MVE_VSHR_imm<"s32", (ins shr_imm32:$imm)> {
2509   let Inst{28} = 0b0;
2510   let Inst{21} = 0b1;
2511 }
2512
2513 def MVE_VSHR_immu32 : MVE_VSHR_imm<"u32", (ins shr_imm32:$imm)> {
2514   let Inst{28} = 0b1;
2515   let Inst{21} = 0b1;
2516 }
2517
2518 class MVE_VSHL_imm<string suffix, dag imm>
2519   : MVE_shift_with_imm<"vshl", suffix, (outs MQPR:$Qd),
2520                        !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2521                        vpred_r, ""> {
2522   bits<6> imm;
2523
2524   let Inst{28} = 0b0;
2525   let Inst{25-24} = 0b11;
2526   let Inst{21-16} = imm;
2527   let Inst{10-8} = 0b101;
2528 }
2529
2530 def MVE_VSHL_immi8 : MVE_VSHL_imm<"i8", (ins imm0_7:$imm)> {
2531   let Inst{21-19} = 0b001;
2532 }
2533
2534 def MVE_VSHL_immi16 : MVE_VSHL_imm<"i16", (ins imm0_15:$imm)> {
2535   let Inst{21-20} = 0b01;
2536 }
2537
2538 def MVE_VSHL_immi32 : MVE_VSHL_imm<"i32", (ins imm0_31:$imm)> {
2539   let Inst{21} = 0b1;
2540 }
2541
2542 let Predicates = [HasMVEInt] in {
2543   def : Pat<(v4i32 (ARMvshlImm (v4i32 MQPR:$src), imm0_31:$imm)),
2544             (v4i32 (MVE_VSHL_immi32 (v4i32 MQPR:$src), imm0_31:$imm))>;
2545   def : Pat<(v8i16 (ARMvshlImm (v8i16 MQPR:$src), imm0_15:$imm)),
2546             (v8i16 (MVE_VSHL_immi16 (v8i16 MQPR:$src), imm0_15:$imm))>;
2547   def : Pat<(v16i8 (ARMvshlImm (v16i8 MQPR:$src), imm0_7:$imm)),
2548             (v16i8 (MVE_VSHL_immi8 (v16i8 MQPR:$src), imm0_7:$imm))>;
2549
2550   def : Pat<(v4i32 (ARMvshruImm (v4i32 MQPR:$src), imm0_31:$imm)),
2551             (v4i32 (MVE_VSHR_immu32 (v4i32 MQPR:$src), imm0_31:$imm))>;
2552   def : Pat<(v8i16 (ARMvshruImm (v8i16 MQPR:$src), imm0_15:$imm)),
2553             (v8i16 (MVE_VSHR_immu16 (v8i16 MQPR:$src), imm0_15:$imm))>;
2554   def : Pat<(v16i8 (ARMvshruImm (v16i8 MQPR:$src), imm0_7:$imm)),
2555             (v16i8 (MVE_VSHR_immu8 (v16i8 MQPR:$src), imm0_7:$imm))>;
2556
2557   def : Pat<(v4i32 (ARMvshrsImm (v4i32 MQPR:$src), imm0_31:$imm)),
2558             (v4i32 (MVE_VSHR_imms32 (v4i32 MQPR:$src), imm0_31:$imm))>;
2559   def : Pat<(v8i16 (ARMvshrsImm (v8i16 MQPR:$src), imm0_15:$imm)),
2560             (v8i16 (MVE_VSHR_imms16 (v8i16 MQPR:$src), imm0_15:$imm))>;
2561   def : Pat<(v16i8 (ARMvshrsImm (v16i8 MQPR:$src), imm0_7:$imm)),
2562             (v16i8 (MVE_VSHR_imms8 (v16i8 MQPR:$src), imm0_7:$imm))>;
2563 }
2564
2565 // end of mve_shift instructions
2566
2567 // start of MVE Floating Point instructions
2568
2569 class MVE_float<string iname, string suffix, dag oops, dag iops, string ops,
2570                 vpred_ops vpred, string cstr, list<dag> pattern=[]>
2571   : MVE_f<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
2572   bits<4> Qm;
2573
2574   let Inst{12} = 0b0;
2575   let Inst{6} = 0b1;
2576   let Inst{5} = Qm{3};
2577   let Inst{3-1} = Qm{2-0};
2578   let Inst{0} = 0b0;
2579 }
2580
2581 class MVE_VRINT<string rmode, bits<3> op, string suffix, bits<2> size,
2582                 list<dag> pattern=[]>
2583   : MVE_float<!strconcat("vrint", rmode), suffix, (outs MQPR:$Qd),
2584               (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2585   bits<4> Qd;
2586
2587   let Inst{28} = 0b1;
2588   let Inst{25-23} = 0b111;
2589   let Inst{22} = Qd{3};
2590   let Inst{21-20} = 0b11;
2591   let Inst{19-18} = size;
2592   let Inst{17-16} = 0b10;
2593   let Inst{15-13} = Qd{2-0};
2594   let Inst{11-10} = 0b01;
2595   let Inst{9-7} = op{2-0};
2596   let Inst{4} = 0b0;
2597
2598 }
2599
2600 multiclass MVE_VRINT_ops<string suffix, bits<2> size, list<dag> pattern=[]> {
2601   def N : MVE_VRINT<"n", 0b000, suffix, size, pattern>;
2602   def X : MVE_VRINT<"x", 0b001, suffix, size, pattern>;
2603   def A : MVE_VRINT<"a", 0b010, suffix, size, pattern>;
2604   def Z : MVE_VRINT<"z", 0b011, suffix, size, pattern>;
2605   def M : MVE_VRINT<"m", 0b101, suffix, size, pattern>;
2606   def P : MVE_VRINT<"p", 0b111, suffix, size, pattern>;
2607 }
2608
2609 defm MVE_VRINTf16 : MVE_VRINT_ops<"f16", 0b01>;
2610 defm MVE_VRINTf32 : MVE_VRINT_ops<"f32", 0b10>;
2611
2612 let Predicates = [HasMVEFloat] in {
2613   def : Pat<(v4f32 (frint (v4f32 MQPR:$val1))),
2614             (v4f32 (MVE_VRINTf32X (v4f32 MQPR:$val1)))>;
2615   def : Pat<(v8f16 (frint (v8f16 MQPR:$val1))),
2616             (v8f16 (MVE_VRINTf16X (v8f16 MQPR:$val1)))>;
2617   def : Pat<(v4f32 (fround (v4f32 MQPR:$val1))),
2618             (v4f32 (MVE_VRINTf32A (v4f32 MQPR:$val1)))>;
2619   def : Pat<(v8f16 (fround (v8f16 MQPR:$val1))),
2620             (v8f16 (MVE_VRINTf16A (v8f16 MQPR:$val1)))>;
2621   def : Pat<(v4f32 (ftrunc (v4f32 MQPR:$val1))),
2622             (v4f32 (MVE_VRINTf32Z (v4f32 MQPR:$val1)))>;
2623   def : Pat<(v8f16 (ftrunc (v8f16 MQPR:$val1))),
2624             (v8f16 (MVE_VRINTf16Z (v8f16 MQPR:$val1)))>;
2625   def : Pat<(v4f32 (ffloor (v4f32 MQPR:$val1))),
2626             (v4f32 (MVE_VRINTf32M (v4f32 MQPR:$val1)))>;
2627   def : Pat<(v8f16 (ffloor (v8f16 MQPR:$val1))),
2628             (v8f16 (MVE_VRINTf16M (v8f16 MQPR:$val1)))>;
2629   def : Pat<(v4f32 (fceil (v4f32 MQPR:$val1))),
2630             (v4f32 (MVE_VRINTf32P (v4f32 MQPR:$val1)))>;
2631   def : Pat<(v8f16 (fceil (v8f16 MQPR:$val1))),
2632             (v8f16 (MVE_VRINTf16P (v8f16 MQPR:$val1)))>;
2633 }
2634
2635 class MVEFloatArithNeon<string iname, string suffix, bit size,
2636                            dag oops, dag iops, string ops,
2637                            vpred_ops vpred, string cstr, list<dag> pattern=[]>
2638   : MVE_float<iname, suffix, oops, iops, ops, vpred, cstr, pattern> {
2639   let Inst{20} = size;
2640   let Inst{16} = 0b0;
2641 }
2642
2643 class MVE_VMUL_fp<string suffix, bit size, list<dag> pattern=[]>
2644   : MVEFloatArithNeon<"vmul", suffix, size, (outs MQPR:$Qd),
2645                       (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm", vpred_r, "",
2646                       pattern> {
2647   bits<4> Qd;
2648   bits<4> Qn;
2649
2650   let Inst{28} = 0b1;
2651   let Inst{25-23} = 0b110;
2652   let Inst{22} = Qd{3};
2653   let Inst{21} = 0b0;
2654   let Inst{19-17} = Qn{2-0};
2655   let Inst{15-13} = Qd{2-0};
2656   let Inst{12-8} = 0b01101;
2657   let Inst{7} = Qn{3};
2658   let Inst{4} = 0b1;
2659 }
2660
2661 def MVE_VMULf32 : MVE_VMUL_fp<"f32", 0b0>;
2662 def MVE_VMULf16 : MVE_VMUL_fp<"f16", 0b1>;
2663
2664 let Predicates = [HasMVEFloat] in {
2665   def : Pat<(v4f32 (fmul (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2666             (v4f32 (MVE_VMULf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2667   def : Pat<(v8f16 (fmul (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2668             (v8f16 (MVE_VMULf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2669 }
2670
2671 class MVE_VCMLA<string suffix, bit size, list<dag> pattern=[]>
2672   : MVEFloatArithNeon<"vcmla", suffix, size, (outs MQPR:$Qd),
2673                          (ins MQPR:$Qd_src, MQPR:$Qn, MQPR:$Qm, complexrotateop:$rot),
2674                          "$Qd, $Qn, $Qm, $rot", vpred_n, "$Qd = $Qd_src", pattern> {
2675   bits<4> Qd;
2676   bits<4> Qn;
2677   bits<2> rot;
2678
2679   let Inst{28} = 0b1;
2680   let Inst{25} = 0b0;
2681   let Inst{24-23} = rot;
2682   let Inst{22} = Qd{3};
2683   let Inst{21} = 0b1;
2684   let Inst{19-17} = Qn{2-0};
2685   let Inst{15-13} = Qd{2-0};
2686   let Inst{12-8} = 0b01000;
2687   let Inst{7} = Qn{3};
2688   let Inst{4} = 0b0;
2689 }
2690
2691 def MVE_VCMLAf16 : MVE_VCMLA<"f16", 0b0>;
2692 def MVE_VCMLAf32 : MVE_VCMLA<"f32", 0b1>;
2693
2694 class MVE_VADDSUBFMA_fp<string iname, string suffix, bit size, bit bit_4,
2695                         bit bit_8, bit bit_21, dag iops=(ins),
2696                         vpred_ops vpred=vpred_r, string cstr="",
2697                         list<dag> pattern=[]>
2698   : MVEFloatArithNeon<iname, suffix, size, (outs MQPR:$Qd),
2699                       !con(iops, (ins MQPR:$Qn, MQPR:$Qm)), "$Qd, $Qn, $Qm",
2700                       vpred, cstr, pattern> {
2701   bits<4> Qd;
2702   bits<4> Qn;
2703
2704   let Inst{28} = 0b0;
2705   let Inst{25-23} = 0b110;
2706   let Inst{22} = Qd{3};
2707   let Inst{21} = bit_21;
2708   let Inst{19-17} = Qn{2-0};
2709   let Inst{15-13} = Qd{2-0};
2710   let Inst{11-9} = 0b110;
2711   let Inst{8} = bit_8;
2712   let Inst{7} = Qn{3};
2713   let Inst{4} = bit_4;
2714 }
2715
2716 def MVE_VFMAf32 : MVE_VADDSUBFMA_fp<"vfma", "f32", 0b0, 0b1, 0b0, 0b0,
2717     (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2718 def MVE_VFMAf16 : MVE_VADDSUBFMA_fp<"vfma", "f16", 0b1, 0b1, 0b0, 0b0,
2719     (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2720
2721 def MVE_VFMSf32 : MVE_VADDSUBFMA_fp<"vfms", "f32", 0b0, 0b1, 0b0, 0b1,
2722     (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2723 def MVE_VFMSf16 : MVE_VADDSUBFMA_fp<"vfms", "f16", 0b1, 0b1, 0b0, 0b1,
2724     (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2725
2726 let Predicates = [HasMVEFloat, UseFusedMAC] in {
2727   def : Pat<(v8f16 (fadd (v8f16 MQPR:$src1),
2728                              (fmul (v8f16 MQPR:$src2),
2729                                       (v8f16 MQPR:$src3)))),
2730             (v8f16 (MVE_VFMAf16 $src1, $src2, $src3))>;
2731   def : Pat<(v4f32 (fadd (v4f32 MQPR:$src1),
2732                              (fmul (v4f32 MQPR:$src2),
2733                                       (v4f32 MQPR:$src3)))),
2734             (v4f32 (MVE_VFMAf32 $src1, $src2, $src3))>;
2735
2736   def : Pat<(v8f16 (fsub (v8f16 MQPR:$src1),
2737                              (fmul (v8f16 MQPR:$src2),
2738                                       (v8f16 MQPR:$src3)))),
2739             (v8f16 (MVE_VFMSf16 $src1, $src2, $src3))>;
2740   def : Pat<(v4f32 (fsub (v4f32 MQPR:$src1),
2741                              (fmul (v4f32 MQPR:$src2),
2742                                       (v4f32 MQPR:$src3)))),
2743             (v4f32 (MVE_VFMSf32 $src1, $src2, $src3))>;
2744 }
2745
2746 let Predicates = [HasMVEFloat] in {
2747   def : Pat<(v8f16 (fma (v8f16 MQPR:$src1), (v8f16 MQPR:$src2), (v8f16 MQPR:$src3))),
2748             (v8f16 (MVE_VFMAf16 $src3, $src1, $src2))>;
2749   def : Pat<(v4f32 (fma (v4f32 MQPR:$src1), (v4f32 MQPR:$src2), (v4f32 MQPR:$src3))),
2750             (v4f32 (MVE_VFMAf32 $src3, $src1, $src2))>;
2751 }
2752
2753
2754 def MVE_VADDf32 : MVE_VADDSUBFMA_fp<"vadd", "f32", 0b0, 0b0, 0b1, 0b0>;
2755 def MVE_VADDf16 : MVE_VADDSUBFMA_fp<"vadd", "f16", 0b1, 0b0, 0b1, 0b0>;
2756
2757 let Predicates = [HasMVEFloat] in {
2758   def : Pat<(v4f32 (fadd (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2759             (v4f32 (MVE_VADDf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2760   def : Pat<(v8f16 (fadd (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2761             (v8f16 (MVE_VADDf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2762 }
2763
2764 def MVE_VSUBf32 : MVE_VADDSUBFMA_fp<"vsub", "f32", 0b0, 0b0, 0b1, 0b1>;
2765 def MVE_VSUBf16 : MVE_VADDSUBFMA_fp<"vsub", "f16", 0b1, 0b0, 0b1, 0b1>;
2766
2767 let Predicates = [HasMVEFloat] in {
2768   def : Pat<(v4f32 (fsub (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2769             (v4f32 (MVE_VSUBf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2770   def : Pat<(v8f16 (fsub (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2771             (v8f16 (MVE_VSUBf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2772 }
2773
2774 class MVE_VCADD<string suffix, bit size, string cstr="", list<dag> pattern=[]>
2775   : MVEFloatArithNeon<"vcadd", suffix, size, (outs MQPR:$Qd),
2776                          (ins MQPR:$Qn, MQPR:$Qm, complexrotateopodd:$rot),
2777                          "$Qd, $Qn, $Qm, $rot", vpred_r, cstr, pattern> {
2778   bits<4> Qd;
2779   bits<4> Qn;
2780   bit rot;
2781
2782   let Inst{28} = 0b1;
2783   let Inst{25} = 0b0;
2784   let Inst{24} = rot;
2785   let Inst{23} = 0b1;
2786   let Inst{22} = Qd{3};
2787   let Inst{21} = 0b0;
2788   let Inst{19-17} = Qn{2-0};
2789   let Inst{15-13} = Qd{2-0};
2790   let Inst{12-8} = 0b01000;
2791   let Inst{7} = Qn{3};
2792   let Inst{4} = 0b0;
2793 }
2794
2795 def MVE_VCADDf16 : MVE_VCADD<"f16", 0b0>;
2796 def MVE_VCADDf32 : MVE_VCADD<"f32", 0b1, "@earlyclobber $Qd">;
2797
2798 class MVE_VABD_fp<string suffix, bit size>
2799   : MVE_float<"vabd", suffix, (outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
2800               "$Qd, $Qn, $Qm", vpred_r, ""> {
2801   bits<4> Qd;
2802   bits<4> Qn;
2803
2804   let Inst{28} = 0b1;
2805   let Inst{25-23} = 0b110;
2806   let Inst{22} = Qd{3};
2807   let Inst{21} = 0b1;
2808   let Inst{20} = size;
2809   let Inst{19-17} = Qn{2-0};
2810   let Inst{16} = 0b0;
2811   let Inst{15-13} = Qd{2-0};
2812   let Inst{11-8} = 0b1101;
2813   let Inst{7} = Qn{3};
2814   let Inst{4} = 0b0;
2815 }
2816
2817 def MVE_VABDf32 : MVE_VABD_fp<"f32", 0b0>;
2818 def MVE_VABDf16 : MVE_VABD_fp<"f16", 0b1>;
2819
2820 class MVE_VCVT_fix<string suffix, bit fsi, bit U, bit op,
2821                    Operand imm_operand_type, list<dag> pattern=[]>
2822   : MVE_float<"vcvt", suffix,
2823               (outs MQPR:$Qd), (ins MQPR:$Qm, imm_operand_type:$imm6),
2824               "$Qd, $Qm, $imm6", vpred_r, "", pattern> {
2825   bits<4> Qd;
2826   bits<6> imm6;
2827
2828   let Inst{28} = U;
2829   let Inst{25-23} = 0b111;
2830   let Inst{22} = Qd{3};
2831   let Inst{21} = 0b1;
2832   let Inst{19-16} = imm6{3-0};
2833   let Inst{15-13} = Qd{2-0};
2834   let Inst{11-10} = 0b11;
2835   let Inst{9} = fsi;
2836   let Inst{8} = op;
2837   let Inst{7} = 0b0;
2838   let Inst{4} = 0b1;
2839
2840   let DecoderMethod = "DecodeMVEVCVTt1fp";
2841 }
2842
2843 class MVE_VCVT_imm_asmop<int Bits> : AsmOperandClass {
2844   let PredicateMethod = "isImmediate<1," # Bits # ">";
2845   let DiagnosticString =
2846       "MVE fixed-point immediate operand must be between 1 and " # Bits;
2847   let Name = "MVEVcvtImm" # Bits;
2848   let RenderMethod = "addImmOperands";
2849 }
2850 class MVE_VCVT_imm<int Bits>: Operand<i32> {
2851   let ParserMatchClass = MVE_VCVT_imm_asmop<Bits>;
2852   let EncoderMethod = "getNEONVcvtImm32OpValue";
2853   let DecoderMethod = "DecodeVCVTImmOperand";
2854 }
2855
2856 class MVE_VCVT_fix_f32<string suffix, bit U, bit op>
2857     : MVE_VCVT_fix<suffix, 0b1, U, op, MVE_VCVT_imm<32>> {
2858   let Inst{20} = imm6{4};
2859 }
2860 class MVE_VCVT_fix_f16<string suffix, bit U, bit op>
2861     : MVE_VCVT_fix<suffix, 0b0, U, op, MVE_VCVT_imm<16>> {
2862   let Inst{20} = 0b1;
2863 }
2864
2865 def MVE_VCVTf16s16_fix : MVE_VCVT_fix_f16<"f16.s16", 0b0, 0b0>;
2866 def MVE_VCVTs16f16_fix : MVE_VCVT_fix_f16<"s16.f16", 0b0, 0b1>;
2867 def MVE_VCVTf16u16_fix : MVE_VCVT_fix_f16<"f16.u16", 0b1, 0b0>;
2868 def MVE_VCVTu16f16_fix : MVE_VCVT_fix_f16<"u16.f16", 0b1, 0b1>;
2869 def MVE_VCVTf32s32_fix : MVE_VCVT_fix_f32<"f32.s32", 0b0, 0b0>;
2870 def MVE_VCVTs32f32_fix : MVE_VCVT_fix_f32<"s32.f32", 0b0, 0b1>;
2871 def MVE_VCVTf32u32_fix : MVE_VCVT_fix_f32<"f32.u32", 0b1, 0b0>;
2872 def MVE_VCVTu32f32_fix : MVE_VCVT_fix_f32<"u32.f32", 0b1, 0b1>;
2873
2874 class MVE_VCVT_fp_int_anpm<string suffix, bits<2> size, bit op, string anpm,
2875                 bits<2> rm, list<dag> pattern=[]>
2876   : MVE_float<!strconcat("vcvt", anpm), suffix, (outs MQPR:$Qd),
2877               (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2878   bits<4> Qd;
2879
2880   let Inst{28} = 0b1;
2881   let Inst{25-23} = 0b111;
2882   let Inst{22} = Qd{3};
2883   let Inst{21-20} = 0b11;
2884   let Inst{19-18} = size;
2885   let Inst{17-16} = 0b11;
2886   let Inst{15-13} = Qd{2-0};
2887   let Inst{12-10} = 0b000;
2888   let Inst{9-8} = rm;
2889   let Inst{7} = op;
2890   let Inst{4} = 0b0;
2891 }
2892
2893 multiclass MVE_VCVT_fp_int_anpm_multi<string suffix, bits<2> size, bit op,
2894                                 list<dag> pattern=[]> {
2895   def a : MVE_VCVT_fp_int_anpm<suffix, size, op, "a", 0b00>;
2896   def n : MVE_VCVT_fp_int_anpm<suffix, size, op, "n", 0b01>;
2897   def p : MVE_VCVT_fp_int_anpm<suffix, size, op, "p", 0b10>;
2898   def m : MVE_VCVT_fp_int_anpm<suffix, size, op, "m", 0b11>;
2899 }
2900
2901 // This defines instructions such as MVE_VCVTu16f16a, with an explicit
2902 // rounding-mode suffix on the mnemonic. The class below will define
2903 // the bare MVE_VCVTu16f16 (with implied rounding toward zero).
2904 defm MVE_VCVTs16f16 : MVE_VCVT_fp_int_anpm_multi<"s16.f16", 0b01, 0b0>;
2905 defm MVE_VCVTu16f16 : MVE_VCVT_fp_int_anpm_multi<"u16.f16", 0b01, 0b1>;
2906 defm MVE_VCVTs32f32 : MVE_VCVT_fp_int_anpm_multi<"s32.f32", 0b10, 0b0>;
2907 defm MVE_VCVTu32f32 : MVE_VCVT_fp_int_anpm_multi<"u32.f32", 0b10, 0b1>;
2908
2909 class MVE_VCVT_fp_int<string suffix, bits<2> size, bits<2> op,
2910                       list<dag> pattern=[]>
2911   : MVE_float<"vcvt", suffix, (outs MQPR:$Qd),
2912               (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2913   bits<4> Qd;
2914
2915   let Inst{28} = 0b1;
2916   let Inst{25-23} = 0b111;
2917   let Inst{22} = Qd{3};
2918   let Inst{21-20} = 0b11;
2919   let Inst{19-18} = size;
2920   let Inst{17-16} = 0b11;
2921   let Inst{15-13} = Qd{2-0};
2922   let Inst{12-9} = 0b0011;
2923   let Inst{8-7} = op;
2924   let Inst{4} = 0b0;
2925 }
2926
2927 // The unsuffixed VCVT for float->int implicitly rounds toward zero,
2928 // which I reflect here in the llvm instruction names
2929 def MVE_VCVTs16f16z : MVE_VCVT_fp_int<"s16.f16", 0b01, 0b10>;
2930 def MVE_VCVTu16f16z : MVE_VCVT_fp_int<"u16.f16", 0b01, 0b11>;
2931 def MVE_VCVTs32f32z : MVE_VCVT_fp_int<"s32.f32", 0b10, 0b10>;
2932 def MVE_VCVTu32f32z : MVE_VCVT_fp_int<"u32.f32", 0b10, 0b11>;
2933 // Whereas VCVT for int->float rounds to nearest
2934 def MVE_VCVTf16s16n : MVE_VCVT_fp_int<"f16.s16", 0b01, 0b00>;
2935 def MVE_VCVTf16u16n : MVE_VCVT_fp_int<"f16.u16", 0b01, 0b01>;
2936 def MVE_VCVTf32s32n : MVE_VCVT_fp_int<"f32.s32", 0b10, 0b00>;
2937 def MVE_VCVTf32u32n : MVE_VCVT_fp_int<"f32.u32", 0b10, 0b01>;
2938
2939 let Predicates = [HasMVEFloat] in {
2940   def : Pat<(v4i32 (fp_to_sint (v4f32 MQPR:$src))),
2941             (v4i32 (MVE_VCVTs32f32z (v4f32 MQPR:$src)))>;
2942   def : Pat<(v4i32 (fp_to_uint (v4f32 MQPR:$src))),
2943             (v4i32 (MVE_VCVTu32f32z (v4f32 MQPR:$src)))>;
2944   def : Pat<(v8i16 (fp_to_sint (v8f16 MQPR:$src))),
2945             (v8i16 (MVE_VCVTs16f16z (v8f16 MQPR:$src)))>;
2946   def : Pat<(v8i16 (fp_to_uint (v8f16 MQPR:$src))),
2947             (v8i16 (MVE_VCVTu16f16z (v8f16 MQPR:$src)))>;
2948   def : Pat<(v4f32 (sint_to_fp (v4i32 MQPR:$src))),
2949             (v4f32 (MVE_VCVTf32s32n (v4i32 MQPR:$src)))>;
2950   def : Pat<(v4f32 (uint_to_fp (v4i32 MQPR:$src))),
2951             (v4f32 (MVE_VCVTf32u32n (v4i32 MQPR:$src)))>;
2952   def : Pat<(v8f16 (sint_to_fp (v8i16 MQPR:$src))),
2953             (v8f16 (MVE_VCVTf16s16n (v8i16 MQPR:$src)))>;
2954   def : Pat<(v8f16 (uint_to_fp (v8i16 MQPR:$src))),
2955             (v8f16 (MVE_VCVTf16u16n (v8i16 MQPR:$src)))>;
2956 }
2957
2958 class MVE_VABSNEG_fp<string iname, string suffix, bits<2> size, bit negate,
2959                    list<dag> pattern=[]>
2960   : MVE_float<iname, suffix, (outs MQPR:$Qd),
2961               (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2962   bits<4> Qd;
2963
2964   let Inst{28} = 0b1;
2965   let Inst{25-23} = 0b111;
2966   let Inst{22} = Qd{3};
2967   let Inst{21-20} = 0b11;
2968   let Inst{19-18} = size;
2969   let Inst{17-16} = 0b01;
2970   let Inst{15-13} = Qd{2-0};
2971   let Inst{11-8} = 0b0111;
2972   let Inst{7} = negate;
2973   let Inst{4} = 0b0;
2974 }
2975
2976 def MVE_VABSf16 : MVE_VABSNEG_fp<"vabs", "f16", 0b01, 0b0>;
2977 def MVE_VABSf32 : MVE_VABSNEG_fp<"vabs", "f32", 0b10, 0b0>;
2978
2979 let Predicates = [HasMVEFloat] in {
2980   def : Pat<(v8f16 (fabs MQPR:$src)),
2981             (MVE_VABSf16 MQPR:$src)>;
2982   def : Pat<(v4f32 (fabs MQPR:$src)),
2983             (MVE_VABSf32 MQPR:$src)>;
2984 }
2985
2986 def MVE_VNEGf16 : MVE_VABSNEG_fp<"vneg", "f16", 0b01, 0b1>;
2987 def MVE_VNEGf32 : MVE_VABSNEG_fp<"vneg", "f32", 0b10, 0b1>;
2988
2989 let Predicates = [HasMVEFloat] in {
2990   def : Pat<(v8f16 (fneg MQPR:$src)),
2991             (MVE_VNEGf16 MQPR:$src)>;
2992   def : Pat<(v4f32 (fneg MQPR:$src)),
2993             (MVE_VNEGf32 MQPR:$src)>;
2994 }
2995
2996 class MVE_VMAXMINNMA<string iname, string suffix, bit size, bit bit_12,
2997                      list<dag> pattern=[]>
2998   : MVE_f<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
2999           NoItinerary, iname, suffix, "$Qd, $Qm", vpred_n, "$Qd = $Qd_src",
3000           pattern> {
3001   bits<4> Qd;
3002   bits<4> Qm;
3003
3004   let Inst{28} = size;
3005   let Inst{25-23} = 0b100;
3006   let Inst{22} = Qd{3};
3007   let Inst{21-16} = 0b111111;
3008   let Inst{15-13} = Qd{2-0};
3009   let Inst{12} = bit_12;
3010   let Inst{11-6} = 0b111010;
3011   let Inst{5} = Qm{3};
3012   let Inst{4} = 0b0;
3013   let Inst{3-1} = Qm{2-0};
3014   let Inst{0} = 0b1;
3015 }
3016
3017 def MVE_VMAXNMAf32 : MVE_VMAXMINNMA<"vmaxnma", "f32", 0b0, 0b0>;
3018 def MVE_VMAXNMAf16 : MVE_VMAXMINNMA<"vmaxnma", "f16", 0b1, 0b0>;
3019
3020 def MVE_VMINNMAf32 : MVE_VMAXMINNMA<"vminnma", "f32", 0b0, 0b1>;
3021 def MVE_VMINNMAf16 : MVE_VMAXMINNMA<"vminnma", "f16", 0b1, 0b1>;
3022
3023 // end of MVE Floating Point instructions
3024
3025 // start of MVE compares
3026
3027 class MVE_VCMPqq<string suffix, bit bit_28, bits<2> bits_21_20,
3028                  VCMPPredicateOperand predtype, list<dag> pattern=[]>
3029   : MVE_p<(outs VCCR:$P0), (ins MQPR:$Qn, MQPR:$Qm, predtype:$fc),
3030            NoItinerary, "vcmp", suffix, "$fc, $Qn, $Qm", vpred_n, "", pattern> {
3031   // Base class for comparing two vector registers
3032   bits<3> fc;
3033   bits<4> Qn;
3034   bits<4> Qm;
3035
3036   let Inst{28} = bit_28;
3037   let Inst{25-22} = 0b1000;
3038   let Inst{21-20} = bits_21_20;
3039   let Inst{19-17} = Qn{2-0};
3040   let Inst{16-13} = 0b1000;
3041   let Inst{12} = fc{2};
3042   let Inst{11-8} = 0b1111;
3043   let Inst{7} = fc{0};
3044   let Inst{6} = 0b0;
3045   let Inst{5} = Qm{3};
3046   let Inst{4} = 0b0;
3047   let Inst{3-1} = Qm{2-0};
3048   let Inst{0} = fc{1};
3049
3050   let Constraints = "";
3051
3052   // We need a custom decoder method for these instructions because of
3053   // the output VCCR operand, which isn't encoded in the instruction
3054   // bits anywhere (there is only one choice for it) but has to be
3055   // included in the MC operands so that codegen will be able to track
3056   // its data flow between instructions, spill/reload it when
3057   // necessary, etc. There seems to be no way to get the Tablegen
3058   // decoder to emit an operand that isn't affected by any instruction
3059   // bit.
3060   let DecoderMethod = "DecodeMVEVCMP<false," # predtype.DecoderMethod # ">";
3061 }
3062
3063 class MVE_VCMPqqf<string suffix, bit size>
3064     : MVE_VCMPqq<suffix, size, 0b11, pred_basic_fp> {
3065   let Predicates = [HasMVEFloat];
3066 }
3067
3068 class MVE_VCMPqqi<string suffix, bits<2> size>
3069     : MVE_VCMPqq<suffix, 0b1, size, pred_basic_i> {
3070   let Inst{12} = 0b0;
3071   let Inst{0} = 0b0;
3072 }
3073
3074 class MVE_VCMPqqu<string suffix, bits<2> size>
3075     : MVE_VCMPqq<suffix, 0b1, size, pred_basic_u> {
3076   let Inst{12} = 0b0;
3077   let Inst{0} = 0b1;
3078 }
3079
3080 class MVE_VCMPqqs<string suffix, bits<2> size>
3081     : MVE_VCMPqq<suffix, 0b1, size, pred_basic_s> {
3082   let Inst{12} = 0b1;
3083 }
3084
3085 def MVE_VCMPf32 : MVE_VCMPqqf<"f32", 0b0>;
3086 def MVE_VCMPf16 : MVE_VCMPqqf<"f16", 0b1>;
3087
3088 def MVE_VCMPi8  : MVE_VCMPqqi<"i8",  0b00>;
3089 def MVE_VCMPi16 : MVE_VCMPqqi<"i16", 0b01>;
3090 def MVE_VCMPi32 : MVE_VCMPqqi<"i32", 0b10>;
3091
3092 def MVE_VCMPu8  : MVE_VCMPqqu<"u8",  0b00>;
3093 def MVE_VCMPu16 : MVE_VCMPqqu<"u16", 0b01>;
3094 def MVE_VCMPu32 : MVE_VCMPqqu<"u32", 0b10>;
3095
3096 def MVE_VCMPs8  : MVE_VCMPqqs<"s8",  0b00>;
3097 def MVE_VCMPs16 : MVE_VCMPqqs<"s16", 0b01>;
3098 def MVE_VCMPs32 : MVE_VCMPqqs<"s32", 0b10>;
3099
3100 class MVE_VCMPqr<string suffix, bit bit_28, bits<2> bits_21_20,
3101                  VCMPPredicateOperand predtype, list<dag> pattern=[]>
3102   : MVE_p<(outs VCCR:$P0), (ins MQPR:$Qn, GPRwithZR:$Rm, predtype:$fc),
3103            NoItinerary, "vcmp", suffix, "$fc, $Qn, $Rm", vpred_n, "", pattern> {
3104   // Base class for comparing a vector register with a scalar
3105   bits<3> fc;
3106   bits<4> Qn;
3107   bits<4> Rm;
3108
3109   let Inst{28} = bit_28;
3110   let Inst{25-22} = 0b1000;
3111   let Inst{21-20} = bits_21_20;
3112   let Inst{19-17} = Qn{2-0};
3113   let Inst{16-13} = 0b1000;
3114   let Inst{12} = fc{2};
3115   let Inst{11-8} = 0b1111;
3116   let Inst{7} = fc{0};
3117   let Inst{6} = 0b1;
3118   let Inst{5} = fc{1};
3119   let Inst{4} = 0b0;
3120   let Inst{3-0} = Rm{3-0};
3121
3122   let Constraints = "";
3123   // Custom decoder method, for the same reason as MVE_VCMPqq
3124   let DecoderMethod = "DecodeMVEVCMP<true," # predtype.DecoderMethod # ">";
3125 }
3126
3127 class MVE_VCMPqrf<string suffix, bit size>
3128     : MVE_VCMPqr<suffix, size, 0b11, pred_basic_fp> {
3129   let Predicates = [HasMVEFloat];
3130 }
3131
3132 class MVE_VCMPqri<string suffix, bits<2> size>
3133     : MVE_VCMPqr<suffix, 0b1, size, pred_basic_i> {
3134   let Inst{12} = 0b0;
3135   let Inst{5} = 0b0;
3136 }
3137
3138 class MVE_VCMPqru<string suffix, bits<2> size>
3139     : MVE_VCMPqr<suffix, 0b1, size, pred_basic_u> {
3140   let Inst{12} = 0b0;
3141   let Inst{5} = 0b1;
3142 }
3143
3144 class MVE_VCMPqrs<string suffix, bits<2> size>
3145     : MVE_VCMPqr<suffix, 0b1, size, pred_basic_s> {
3146   let Inst{12} = 0b1;
3147 }
3148
3149 def MVE_VCMPf32r : MVE_VCMPqrf<"f32", 0b0>;
3150 def MVE_VCMPf16r : MVE_VCMPqrf<"f16", 0b1>;
3151
3152 def MVE_VCMPi8r  : MVE_VCMPqri<"i8",  0b00>;
3153 def MVE_VCMPi16r : MVE_VCMPqri<"i16", 0b01>;
3154 def MVE_VCMPi32r : MVE_VCMPqri<"i32", 0b10>;
3155
3156 def MVE_VCMPu8r  : MVE_VCMPqru<"u8",  0b00>;
3157 def MVE_VCMPu16r : MVE_VCMPqru<"u16", 0b01>;
3158 def MVE_VCMPu32r : MVE_VCMPqru<"u32", 0b10>;
3159
3160 def MVE_VCMPs8r  : MVE_VCMPqrs<"s8",  0b00>;
3161 def MVE_VCMPs16r : MVE_VCMPqrs<"s16", 0b01>;
3162 def MVE_VCMPs32r : MVE_VCMPqrs<"s32", 0b10>;
3163
3164 multiclass unpred_vcmp_z<string suffix, int fc> {
3165   def i8  : Pat<(v16i1 (ARMvcmpz (v16i8 MQPR:$v1), (i32 fc))),
3166                 (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8r") (v16i8 MQPR:$v1), ZR, fc))>;
3167   def i16 : Pat<(v8i1 (ARMvcmpz (v8i16 MQPR:$v1), (i32 fc))),
3168                 (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16r") (v8i16 MQPR:$v1), ZR, fc))>;
3169   def i32 : Pat<(v4i1 (ARMvcmpz (v4i32 MQPR:$v1), (i32 fc))),
3170                 (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32r") (v4i32 MQPR:$v1), ZR, fc))>;
3171
3172   def : Pat<(v16i1 (and (v16i1 VCCR:$p1), (v16i1 (ARMvcmpz (v16i8 MQPR:$v1), (i32 fc))))),
3173             (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8r") (v16i8 MQPR:$v1), ZR, fc, 1, VCCR:$p1))>;
3174   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmpz (v8i16 MQPR:$v1), (i32 fc))))),
3175             (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16r") (v8i16 MQPR:$v1), ZR, fc, 1, VCCR:$p1))>;
3176   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmpz (v4i32 MQPR:$v1), (i32 fc))))),
3177             (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32r") (v4i32 MQPR:$v1), ZR, fc, 1, VCCR:$p1))>;
3178 }
3179
3180 multiclass unpred_vcmp_r<string suffix, int fc> {
3181   def i8  : Pat<(v16i1 (ARMvcmp (v16i8 MQPR:$v1), (v16i8 MQPR:$v2), (i32 fc))),
3182                 (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8") (v16i8 MQPR:$v1), (v16i8 MQPR:$v2), fc))>;
3183   def i16 : Pat<(v8i1 (ARMvcmp (v8i16 MQPR:$v1), (v8i16 MQPR:$v2), (i32 fc))),
3184                 (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16") (v8i16 MQPR:$v1), (v8i16 MQPR:$v2), fc))>;
3185   def i32 : Pat<(v4i1 (ARMvcmp (v4i32 MQPR:$v1), (v4i32 MQPR:$v2), (i32 fc))),
3186                 (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32") (v4i32 MQPR:$v1), (v4i32 MQPR:$v2), fc))>;
3187
3188   def i8r  : Pat<(v16i1 (ARMvcmp (v16i8 MQPR:$v1), (v16i8 (ARMvdup GPR:$v2)), (i32 fc))),
3189                  (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8r") (v16i8 MQPR:$v1), (i32 GPR:$v2), fc))>;
3190   def i16r : Pat<(v8i1 (ARMvcmp (v8i16 MQPR:$v1), (v8i16 (ARMvdup GPR:$v2)), (i32 fc))),
3191                  (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16r") (v8i16 MQPR:$v1), (i32 GPR:$v2), fc))>;
3192   def i32r : Pat<(v4i1 (ARMvcmp (v4i32 MQPR:$v1), (v4i32 (ARMvdup GPR:$v2)), (i32 fc))),
3193                  (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32r") (v4i32 MQPR:$v1), (i32 GPR:$v2), fc))>;
3194
3195   def : Pat<(v16i1 (and (v16i1 VCCR:$p1), (v16i1 (ARMvcmp (v16i8 MQPR:$v1), (v16i8 MQPR:$v2), (i32 fc))))),
3196             (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8") (v16i8 MQPR:$v1), (v16i8 MQPR:$v2), fc, 1, VCCR:$p1))>;
3197   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmp (v8i16 MQPR:$v1), (v8i16 MQPR:$v2), (i32 fc))))),
3198             (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16") (v8i16 MQPR:$v1), (v8i16 MQPR:$v2), fc, 1, VCCR:$p1))>;
3199   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmp (v4i32 MQPR:$v1), (v4i32 MQPR:$v2), (i32 fc))))),
3200             (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32") (v4i32 MQPR:$v1), (v4i32 MQPR:$v2), fc, 1, VCCR:$p1))>;
3201
3202   def : Pat<(v16i1 (and (v16i1 VCCR:$p1), (v16i1 (ARMvcmp (v16i8 MQPR:$v1), (v16i8 (ARMvdup GPR:$v2)), (i32 fc))))),
3203             (v16i1 (!cast<Instruction>("MVE_VCMP"#suffix#"8r") (v16i8 MQPR:$v1), (i32 GPR:$v2), fc, 1, VCCR:$p1))>;
3204   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmp (v8i16 MQPR:$v1), (v8i16 (ARMvdup GPR:$v2)), (i32 fc))))),
3205             (v8i1 (!cast<Instruction>("MVE_VCMP"#suffix#"16r") (v8i16 MQPR:$v1), (i32 GPR:$v2), fc, 1, VCCR:$p1))>;
3206   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmp (v4i32 MQPR:$v1), (v4i32 (ARMvdup GPR:$v2)), (i32 fc))))),
3207             (v4i1 (!cast<Instruction>("MVE_VCMP"#suffix#"32r") (v4i32 MQPR:$v1), (i32 GPR:$v2), fc, 1, VCCR:$p1))>;
3208 }
3209
3210 multiclass unpred_vcmpf_z<int fc> {
3211   def f16 : Pat<(v8i1 (ARMvcmpz (v8f16 MQPR:$v1), (i32 fc))),
3212                 (v8i1 (MVE_VCMPf16r (v8f16 MQPR:$v1), ZR, fc))>;
3213   def f32 : Pat<(v4i1 (ARMvcmpz (v4f32 MQPR:$v1), (i32 fc))),
3214                 (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), ZR, fc))>;
3215
3216   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmpz (v8f16 MQPR:$v1), (i32 fc))))),
3217             (v8i1 (MVE_VCMPf32r (v8f16 MQPR:$v1), ZR, fc, 1, VCCR:$p1))>;
3218   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmpz (v4f32 MQPR:$v1), (i32 fc))))),
3219             (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), ZR, fc, 1, VCCR:$p1))>;
3220 }
3221
3222 multiclass unpred_vcmpf_r<int fc> {
3223   def f16 : Pat<(v8i1 (ARMvcmp (v8f16 MQPR:$v1), (v8f16 MQPR:$v2), (i32 fc))),
3224                 (v8i1 (MVE_VCMPf16 (v8f16 MQPR:$v1), (v8f16 MQPR:$v2), fc))>;
3225   def f32 : Pat<(v4i1 (ARMvcmp (v4f32 MQPR:$v1), (v4f32 MQPR:$v2), (i32 fc))),
3226                 (v4i1 (MVE_VCMPf32 (v4f32 MQPR:$v1), (v4f32 MQPR:$v2), fc))>;
3227
3228   def f16r : Pat<(v8i1 (ARMvcmp (v8f16 MQPR:$v1), (v8f16 (ARMvdup HPR:$v2)), (i32 fc))),
3229                  (v8i1 (MVE_VCMPf16r (v8f16 MQPR:$v1), (i32 (COPY_TO_REGCLASS (f16 HPR:$v2), rGPR)), fc))>;
3230   def f32r : Pat<(v4i1 (ARMvcmp (v4f32 MQPR:$v1), (v4f32 (ARMvdup SPR:$v2)), (i32 fc))),
3231                  (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), (i32 (COPY_TO_REGCLASS (f32 SPR:$v2), rGPR)), fc))>;
3232
3233   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmp (v8f16 MQPR:$v1), (v8f16 MQPR:$v2), (i32 fc))))),
3234             (v8i1 (MVE_VCMPf16 (v8f16 MQPR:$v1), (v8f16 MQPR:$v2), fc, 1, VCCR:$p1))>;
3235   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmp (v4f32 MQPR:$v1), (v4f32 MQPR:$v2), (i32 fc))))),
3236             (v4i1 (MVE_VCMPf32 (v4f32 MQPR:$v1), (v4f32 MQPR:$v2), fc, 1, VCCR:$p1))>;
3237
3238   def : Pat<(v8i1 (and (v8i1 VCCR:$p1), (v8i1 (ARMvcmp (v8f16 MQPR:$v1), (v8f16 (ARMvdup HPR:$v2)), (i32 fc))))),
3239             (v8i1 (MVE_VCMPf16r (v8f16 MQPR:$v1), (i32 (COPY_TO_REGCLASS (f16 HPR:$v2), rGPR)), fc, 1, VCCR:$p1))>;
3240   def : Pat<(v4i1 (and (v4i1 VCCR:$p1), (v4i1 (ARMvcmp (v4f32 MQPR:$v1), (v4f32 (ARMvdup SPR:$v2)), (i32 fc))))),
3241             (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), (i32 (COPY_TO_REGCLASS (f32 SPR:$v2), rGPR)), fc, 1, VCCR:$p1))>;
3242 }
3243
3244 let Predicates = [HasMVEInt] in {
3245   defm MVE_VCEQZ  : unpred_vcmp_z<"i", 0>;
3246   defm MVE_VCNEZ  : unpred_vcmp_z<"i", 1>;
3247   defm MVE_VCGEZ  : unpred_vcmp_z<"s", 10>;
3248   defm MVE_VCLTZ  : unpred_vcmp_z<"s", 11>;
3249   defm MVE_VCGTZ  : unpred_vcmp_z<"s", 12>;
3250   defm MVE_VCLEZ  : unpred_vcmp_z<"s", 13>;
3251   defm MVE_VCGTUZ : unpred_vcmp_z<"u", 8>;
3252   defm MVE_VCGEUZ : unpred_vcmp_z<"u", 2>;
3253
3254   defm MVE_VCEQ   : unpred_vcmp_r<"i", 0>;
3255   defm MVE_VCNE   : unpred_vcmp_r<"i", 1>;
3256   defm MVE_VCGE   : unpred_vcmp_r<"s", 10>;
3257   defm MVE_VCLT   : unpred_vcmp_r<"s", 11>;
3258   defm MVE_VCGT   : unpred_vcmp_r<"s", 12>;
3259   defm MVE_VCLE   : unpred_vcmp_r<"s", 13>;
3260   defm MVE_VCGTU  : unpred_vcmp_r<"u", 8>;
3261   defm MVE_VCGEU  : unpred_vcmp_r<"u", 2>;
3262 }
3263
3264 let Predicates = [HasMVEFloat] in {
3265   defm MVE_VFCEQZ  : unpred_vcmpf_z<0>;
3266   defm MVE_VFCNEZ  : unpred_vcmpf_z<1>;
3267   defm MVE_VFCGEZ  : unpred_vcmpf_z<10>;
3268   defm MVE_VFCLTZ  : unpred_vcmpf_z<11>;
3269   defm MVE_VFCGTZ  : unpred_vcmpf_z<12>;
3270   defm MVE_VFCLEZ  : unpred_vcmpf_z<13>;
3271
3272   defm MVE_VFCEQ   : unpred_vcmpf_r<0>;
3273   defm MVE_VFCNE   : unpred_vcmpf_r<1>;
3274   defm MVE_VFCGE   : unpred_vcmpf_r<10>;
3275   defm MVE_VFCLT   : unpred_vcmpf_r<11>;
3276   defm MVE_VFCGT   : unpred_vcmpf_r<12>;
3277   defm MVE_VFCLE   : unpred_vcmpf_r<13>;
3278 }
3279
3280
3281 // Extra "worst case" and/or/xor partterns, going into and out of GRP
3282 multiclass two_predops<SDPatternOperator opnode, Instruction insn> {
3283   def v16i1 : Pat<(v16i1 (opnode (v16i1 VCCR:$p1), (v16i1 VCCR:$p2))),
3284                   (v16i1 (COPY_TO_REGCLASS
3285                            (insn (i32 (COPY_TO_REGCLASS (v16i1 VCCR:$p1), rGPR)),
3286                                  (i32 (COPY_TO_REGCLASS (v16i1 VCCR:$p2), rGPR))),
3287                            VCCR))>;
3288   def v8i1  : Pat<(v8i1 (opnode (v8i1 VCCR:$p1), (v8i1 VCCR:$p2))),
3289                   (v8i1 (COPY_TO_REGCLASS
3290                           (insn (i32 (COPY_TO_REGCLASS (v8i1 VCCR:$p1), rGPR)),
3291                                 (i32 (COPY_TO_REGCLASS (v8i1 VCCR:$p2), rGPR))),
3292                           VCCR))>;
3293   def v4i1  : Pat<(v4i1 (opnode (v4i1 VCCR:$p1), (v4i1 VCCR:$p2))),
3294                   (v4i1 (COPY_TO_REGCLASS
3295                           (insn (i32 (COPY_TO_REGCLASS (v4i1 VCCR:$p1), rGPR)),
3296                                 (i32 (COPY_TO_REGCLASS (v4i1 VCCR:$p2), rGPR))),
3297                           VCCR))>;
3298 }
3299
3300 let Predicates = [HasMVEInt] in {
3301   defm POR    : two_predops<or,  t2ORRrr>;
3302   defm PAND   : two_predops<and, t2ANDrr>;
3303   defm PEOR   : two_predops<xor, t2EORrr>;
3304 }
3305
3306 // Occasionally we need to cast between a i32 and a boolean vector, for
3307 // example when moving between rGPR and VPR.P0 as part of predicate vector
3308 // shuffles. We also sometimes need to cast between different predicate
3309 // vector types (v4i1<>v8i1, etc.) also as part of lowering vector shuffles.
3310
3311 def predicate_cast : SDNode<"ARMISD::PREDICATE_CAST", SDTUnaryOp>;
3312
3313 let Predicates = [HasMVEInt] in {
3314   foreach VT = [ v4i1, v8i1, v16i1 ] in {
3315     def : Pat<(i32 (predicate_cast (VT VCCR:$src))),
3316               (i32 (COPY_TO_REGCLASS (VT VCCR:$src), VCCR))>;
3317     def : Pat<(VT  (predicate_cast (i32 VCCR:$src))),
3318               (VT  (COPY_TO_REGCLASS (i32 VCCR:$src), VCCR))>;
3319
3320     foreach VT2 = [ v4i1, v8i1, v16i1 ] in
3321       def : Pat<(VT  (predicate_cast (VT2 VCCR:$src))),
3322                 (VT  (COPY_TO_REGCLASS (VT2 VCCR:$src), VCCR))>;
3323   }
3324 }
3325
3326 // end of MVE compares
3327
3328 // start of MVE_qDest_qSrc
3329
3330 class MVE_qDest_qSrc<string iname, string suffix, dag oops, dag iops,
3331                      string ops, vpred_ops vpred, string cstr,
3332                      list<dag> pattern=[]>
3333   : MVE_p<oops, iops, NoItinerary, iname, suffix,
3334           ops, vpred, cstr, pattern> {
3335   bits<4> Qd;
3336   bits<4> Qm;
3337
3338   let Inst{25-23} = 0b100;
3339   let Inst{22} = Qd{3};
3340   let Inst{15-13} = Qd{2-0};
3341   let Inst{11-9} = 0b111;
3342   let Inst{6} = 0b0;
3343   let Inst{5} = Qm{3};
3344   let Inst{4} = 0b0;
3345   let Inst{3-1} = Qm{2-0};
3346 }
3347
3348 class MVE_VQxDMLxDH<string iname, bit exch, bit round, bit subtract,
3349                     string suffix, bits<2> size, string cstr="", list<dag> pattern=[]>
3350   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3351                    (ins MQPR:$Qd_src, MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3352                    vpred_n, "$Qd = $Qd_src"#cstr, pattern> {
3353   bits<4> Qn;
3354
3355   let Inst{28} = subtract;
3356   let Inst{21-20} = size;
3357   let Inst{19-17} = Qn{2-0};
3358   let Inst{16} = 0b0;
3359   let Inst{12} = exch;
3360   let Inst{8} = 0b0;
3361   let Inst{7} = Qn{3};
3362   let Inst{0} = round;
3363 }
3364
3365 multiclass MVE_VQxDMLxDH_multi<string iname, bit exch,
3366                                bit round, bit subtract> {
3367   def s8  : MVE_VQxDMLxDH<iname, exch, round, subtract, "s8",  0b00>;
3368   def s16 : MVE_VQxDMLxDH<iname, exch, round, subtract, "s16", 0b01>;
3369   def s32 : MVE_VQxDMLxDH<iname, exch, round, subtract, "s32", 0b10, ",@earlyclobber $Qd">;
3370 }
3371
3372 defm MVE_VQDMLADH   : MVE_VQxDMLxDH_multi<"vqdmladh",   0b0, 0b0, 0b0>;
3373 defm MVE_VQDMLADHX  : MVE_VQxDMLxDH_multi<"vqdmladhx",  0b1, 0b0, 0b0>;
3374 defm MVE_VQRDMLADH  : MVE_VQxDMLxDH_multi<"vqrdmladh",  0b0, 0b1, 0b0>;
3375 defm MVE_VQRDMLADHX : MVE_VQxDMLxDH_multi<"vqrdmladhx", 0b1, 0b1, 0b0>;
3376 defm MVE_VQDMLSDH   : MVE_VQxDMLxDH_multi<"vqdmlsdh",   0b0, 0b0, 0b1>;
3377 defm MVE_VQDMLSDHX  : MVE_VQxDMLxDH_multi<"vqdmlsdhx",  0b1, 0b0, 0b1>;
3378 defm MVE_VQRDMLSDH  : MVE_VQxDMLxDH_multi<"vqrdmlsdh",  0b0, 0b1, 0b1>;
3379 defm MVE_VQRDMLSDHX : MVE_VQxDMLxDH_multi<"vqrdmlsdhx", 0b1, 0b1, 0b1>;
3380
3381 class MVE_VCMUL<string iname, string suffix, bit size, string cstr="", list<dag> pattern=[]>
3382   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3383                    (ins MQPR:$Qn, MQPR:$Qm, complexrotateop:$rot),
3384                    "$Qd, $Qn, $Qm, $rot", vpred_r, cstr, pattern> {
3385   bits<4> Qn;
3386   bits<2> rot;
3387
3388   let Inst{28} = size;
3389   let Inst{21-20} = 0b11;
3390   let Inst{19-17} = Qn{2-0};
3391   let Inst{16} = 0b0;
3392   let Inst{12} = rot{1};
3393   let Inst{8} = 0b0;
3394   let Inst{7} = Qn{3};
3395   let Inst{0} = rot{0};
3396
3397   let Predicates = [HasMVEFloat];
3398 }
3399
3400 def MVE_VCMULf16 : MVE_VCMUL<"vcmul", "f16", 0b0>;
3401 def MVE_VCMULf32 : MVE_VCMUL<"vcmul", "f32", 0b1, "@earlyclobber $Qd">;
3402
3403 class MVE_VMULL<string iname, string suffix, bit bit_28, bits<2> bits_21_20,
3404                 bit T, string cstr, list<dag> pattern=[]>
3405   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3406                    (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3407                    vpred_r, cstr, pattern> {
3408   bits<4> Qd;
3409   bits<4> Qn;
3410   bits<4> Qm;
3411
3412   let Inst{28} = bit_28;
3413   let Inst{21-20} = bits_21_20;
3414   let Inst{19-17} = Qn{2-0};
3415   let Inst{16} = 0b1;
3416   let Inst{12} = T;
3417   let Inst{8} = 0b0;
3418   let Inst{7} = Qn{3};
3419   let Inst{0} = 0b0;
3420 }
3421
3422 multiclass MVE_VMULL_multi<string iname, string suffix,
3423                            bit bit_28, bits<2> bits_21_20, string cstr=""> {
3424   def bh : MVE_VMULL<iname # "b", suffix, bit_28, bits_21_20, 0b0, cstr>;
3425   def th : MVE_VMULL<iname # "t", suffix, bit_28, bits_21_20, 0b1, cstr>;
3426 }
3427
3428 // For integer multiplies, bits 21:20 encode size, and bit 28 signedness.
3429 // For polynomial multiplies, bits 21:20 take the unused value 0b11, and
3430 // bit 28 switches to encoding the size.
3431
3432 defm MVE_VMULLs8  : MVE_VMULL_multi<"vmull", "s8",  0b0, 0b00>;
3433 defm MVE_VMULLs16 : MVE_VMULL_multi<"vmull", "s16", 0b0, 0b01>;
3434 defm MVE_VMULLs32 : MVE_VMULL_multi<"vmull", "s32", 0b0, 0b10, "@earlyclobber $Qd">;
3435 defm MVE_VMULLu8  : MVE_VMULL_multi<"vmull", "u8",  0b1, 0b00>;
3436 defm MVE_VMULLu16 : MVE_VMULL_multi<"vmull", "u16", 0b1, 0b01>;
3437 defm MVE_VMULLu32 : MVE_VMULL_multi<"vmull", "u32", 0b1, 0b10, "@earlyclobber $Qd">;
3438 defm MVE_VMULLp8  : MVE_VMULL_multi<"vmull", "p8",  0b0, 0b11>;
3439 defm MVE_VMULLp16 : MVE_VMULL_multi<"vmull", "p16", 0b1, 0b11>;
3440
3441 class MVE_VxMULH<string iname, string suffix, bit U, bits<2> size,
3442                  bit round, list<dag> pattern=[]>
3443   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3444                    (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3445                    vpred_r, "", pattern> {
3446   bits<4> Qn;
3447
3448   let Inst{28} = U;
3449   let Inst{21-20} = size;
3450   let Inst{19-17} = Qn{2-0};
3451   let Inst{16} = 0b1;
3452   let Inst{12} = round;
3453   let Inst{8} = 0b0;
3454   let Inst{7} = Qn{3};
3455   let Inst{0} = 0b1;
3456 }
3457
3458 def MVE_VMULHs8   : MVE_VxMULH<"vmulh",  "s8",  0b0, 0b00, 0b0>;
3459 def MVE_VMULHs16  : MVE_VxMULH<"vmulh",  "s16", 0b0, 0b01, 0b0>;
3460 def MVE_VMULHs32  : MVE_VxMULH<"vmulh",  "s32", 0b0, 0b10, 0b0>;
3461 def MVE_VMULHu8   : MVE_VxMULH<"vmulh",  "u8",  0b1, 0b00, 0b0>;
3462 def MVE_VMULHu16  : MVE_VxMULH<"vmulh",  "u16", 0b1, 0b01, 0b0>;
3463 def MVE_VMULHu32  : MVE_VxMULH<"vmulh",  "u32", 0b1, 0b10, 0b0>;
3464
3465 def MVE_VRMULHs8  : MVE_VxMULH<"vrmulh", "s8",  0b0, 0b00, 0b1>;
3466 def MVE_VRMULHs16 : MVE_VxMULH<"vrmulh", "s16", 0b0, 0b01, 0b1>;
3467 def MVE_VRMULHs32 : MVE_VxMULH<"vrmulh", "s32", 0b0, 0b10, 0b1>;
3468 def MVE_VRMULHu8  : MVE_VxMULH<"vrmulh", "u8",  0b1, 0b00, 0b1>;
3469 def MVE_VRMULHu16 : MVE_VxMULH<"vrmulh", "u16", 0b1, 0b01, 0b1>;
3470 def MVE_VRMULHu32 : MVE_VxMULH<"vrmulh", "u32", 0b1, 0b10, 0b1>;
3471
3472 class MVE_VxMOVxN<string iname, string suffix, bit bit_28, bit bit_17,
3473                   bits<2> size, bit T, list<dag> pattern=[]>
3474   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3475                    (ins MQPR:$Qd_src, MQPR:$Qm), "$Qd, $Qm",
3476                    vpred_n, "$Qd = $Qd_src", pattern> {
3477
3478   let Inst{28} = bit_28;
3479   let Inst{21-20} = 0b11;
3480   let Inst{19-18} = size;
3481   let Inst{17} = bit_17;
3482   let Inst{16} = 0b1;
3483   let Inst{12} = T;
3484   let Inst{8} = 0b0;
3485   let Inst{7} = !if(!eq(bit_17, 0), 1, 0);
3486   let Inst{0} = 0b1;
3487 }
3488
3489 multiclass MVE_VxMOVxN_halves<string iname, string suffix,
3490                               bit bit_28, bit bit_17, bits<2> size> {
3491   def bh : MVE_VxMOVxN<iname # "b", suffix, bit_28, bit_17, size, 0b0>;
3492   def th : MVE_VxMOVxN<iname # "t", suffix, bit_28, bit_17, size, 0b1>;
3493 }
3494
3495 defm MVE_VMOVNi16   : MVE_VxMOVxN_halves<"vmovn",   "i16", 0b1, 0b0, 0b00>;
3496 defm MVE_VMOVNi32   : MVE_VxMOVxN_halves<"vmovn",   "i32", 0b1, 0b0, 0b01>;
3497 defm MVE_VQMOVNs16  : MVE_VxMOVxN_halves<"vqmovn",  "s16", 0b0, 0b1, 0b00>;
3498 defm MVE_VQMOVNs32  : MVE_VxMOVxN_halves<"vqmovn",  "s32", 0b0, 0b1, 0b01>;
3499 defm MVE_VQMOVNu16  : MVE_VxMOVxN_halves<"vqmovn",  "u16", 0b1, 0b1, 0b00>;
3500 defm MVE_VQMOVNu32  : MVE_VxMOVxN_halves<"vqmovn",  "u32", 0b1, 0b1, 0b01>;
3501 defm MVE_VQMOVUNs16 : MVE_VxMOVxN_halves<"vqmovun", "s16", 0b0, 0b0, 0b00>;
3502 defm MVE_VQMOVUNs32 : MVE_VxMOVxN_halves<"vqmovun", "s32", 0b0, 0b0, 0b01>;
3503
3504 class MVE_VCVT_ff<string iname, string suffix, bit op, bit T,
3505                   list<dag> pattern=[]>
3506   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
3507                    "$Qd, $Qm", vpred_n, "$Qd = $Qd_src", pattern> {
3508   let Inst{28} = op;
3509   let Inst{21-16} = 0b111111;
3510   let Inst{12} = T;
3511   let Inst{8-7} = 0b00;
3512   let Inst{0} = 0b1;
3513
3514   let Predicates = [HasMVEFloat];
3515 }
3516
3517 multiclass MVE_VCVT_ff_halves<string suffix, bit op> {
3518   def bh : MVE_VCVT_ff<"vcvtb", suffix, op, 0b0>;
3519   def th : MVE_VCVT_ff<"vcvtt", suffix, op, 0b1>;
3520 }
3521
3522 defm MVE_VCVTf16f32 : MVE_VCVT_ff_halves<"f16.f32", 0b0>;
3523 defm MVE_VCVTf32f16 : MVE_VCVT_ff_halves<"f32.f16", 0b1>;
3524
3525 class MVE_VxCADD<string iname, string suffix, bits<2> size, bit halve,
3526                  string cstr="", list<dag> pattern=[]>
3527   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3528                    (ins MQPR:$Qn, MQPR:$Qm, complexrotateopodd:$rot),
3529                    "$Qd, $Qn, $Qm, $rot", vpred_r, cstr, pattern> {
3530   bits<4> Qn;
3531   bit rot;
3532
3533   let Inst{28} = halve;
3534   let Inst{21-20} = size;
3535   let Inst{19-17} = Qn{2-0};
3536   let Inst{16} = 0b0;
3537   let Inst{12} = rot;
3538   let Inst{8} = 0b1;
3539   let Inst{7} = Qn{3};
3540   let Inst{0} = 0b0;
3541 }
3542
3543 def MVE_VCADDi8   : MVE_VxCADD<"vcadd", "i8", 0b00, 0b1>;
3544 def MVE_VCADDi16  : MVE_VxCADD<"vcadd", "i16", 0b01, 0b1>;
3545 def MVE_VCADDi32  : MVE_VxCADD<"vcadd", "i32", 0b10, 0b1, "@earlyclobber $Qd">;
3546
3547 def MVE_VHCADDs8  : MVE_VxCADD<"vhcadd", "s8", 0b00, 0b0>;
3548 def MVE_VHCADDs16 : MVE_VxCADD<"vhcadd", "s16", 0b01, 0b0>;
3549 def MVE_VHCADDs32 : MVE_VxCADD<"vhcadd", "s32", 0b10, 0b0, "@earlyclobber $Qd">;
3550
3551 class MVE_VADCSBC<string iname, bit I, bit subtract,
3552                   dag carryin, list<dag> pattern=[]>
3553   : MVE_qDest_qSrc<iname, "i32", (outs MQPR:$Qd, cl_FPSCR_NZCV:$carryout),
3554                    !con((ins MQPR:$Qn, MQPR:$Qm), carryin),
3555                    "$Qd, $Qn, $Qm", vpred_r, "", pattern> {
3556   bits<4> Qn;
3557
3558   let Inst{28} = subtract;
3559   let Inst{21-20} = 0b11;
3560   let Inst{19-17} = Qn{2-0};
3561   let Inst{16} = 0b0;
3562   let Inst{12} = I;
3563   let Inst{8} = 0b1;
3564   let Inst{7} = Qn{3};
3565   let Inst{0} = 0b0;
3566
3567   // Custom decoder method in order to add the FPSCR operand(s), which
3568   // Tablegen won't do right
3569   let DecoderMethod = "DecodeMVEVADCInstruction";
3570 }
3571
3572 def MVE_VADC  : MVE_VADCSBC<"vadc",  0b0, 0b0, (ins cl_FPSCR_NZCV:$carryin)>;
3573 def MVE_VADCI : MVE_VADCSBC<"vadci", 0b1, 0b0, (ins)>;
3574
3575 def MVE_VSBC  : MVE_VADCSBC<"vsbc",  0b0, 0b1, (ins cl_FPSCR_NZCV:$carryin)>;
3576 def MVE_VSBCI : MVE_VADCSBC<"vsbci", 0b1, 0b1, (ins)>;
3577
3578 class MVE_VQDMULL<string iname, string suffix, bit size, bit T,
3579                   string cstr="", list<dag> pattern=[]>
3580   : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3581                    (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3582                    vpred_r, cstr, pattern> {
3583   bits<4> Qn;
3584
3585   let Inst{28} = size;
3586   let Inst{21-20} = 0b11;
3587   let Inst{19-17} = Qn{2-0};
3588   let Inst{16} = 0b0;
3589   let Inst{12} = T;
3590   let Inst{8} = 0b1;
3591   let Inst{7} = Qn{3};
3592   let Inst{0} = 0b1;
3593 }
3594
3595 multiclass MVE_VQDMULL_halves<string suffix, bit size, string cstr=""> {
3596   def bh : MVE_VQDMULL<"vqdmullb", suffix, size, 0b0, cstr>;
3597   def th : MVE_VQDMULL<"vqdmullt", suffix, size, 0b1, cstr>;
3598 }
3599
3600 defm MVE_VQDMULLs16 : MVE_VQDMULL_halves<"s16", 0b0>;
3601 defm MVE_VQDMULLs32 : MVE_VQDMULL_halves<"s32", 0b1, "@earlyclobber $Qd">;
3602
3603 // end of mve_qDest_qSrc
3604
3605 // start of mve_qDest_rSrc
3606
3607 class MVE_qr_base<dag oops, dag iops, InstrItinClass itin, string iname,
3608                   string suffix, string ops, vpred_ops vpred, string cstr,
3609                   list<dag> pattern=[]>
3610    : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
3611   bits<4> Qd;
3612   bits<4> Qn;
3613   bits<4> Rm;
3614
3615   let Inst{25-23} = 0b100;
3616   let Inst{22} = Qd{3};
3617   let Inst{19-17} = Qn{2-0};
3618   let Inst{15-13} = Qd{2-0};
3619   let Inst{11-9} = 0b111;
3620   let Inst{7} = Qn{3};
3621   let Inst{6} = 0b1;
3622   let Inst{4} = 0b0;
3623   let Inst{3-0} = Rm{3-0};
3624 }
3625
3626 class MVE_qDest_rSrc<string iname, string suffix, string cstr="", list<dag> pattern=[]>
3627   : MVE_qr_base<(outs MQPR:$Qd), (ins MQPR:$Qn, rGPR:$Rm),
3628           NoItinerary, iname, suffix, "$Qd, $Qn, $Rm", vpred_r, cstr,
3629            pattern>;
3630
3631 class MVE_qDestSrc_rSrc<string iname, string suffix, list<dag> pattern=[]>
3632   : MVE_qr_base<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qn, rGPR:$Rm),
3633           NoItinerary, iname, suffix, "$Qd, $Qn, $Rm", vpred_n, "$Qd = $Qd_src",
3634            pattern>;
3635
3636 class MVE_qDest_single_rSrc<string iname, string suffix, list<dag> pattern=[]>
3637   : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qd_src, rGPR:$Rm), NoItinerary, iname,
3638           suffix, "$Qd, $Rm", vpred_n, "$Qd = $Qd_src", pattern> {
3639   bits<4> Qd;
3640   bits<4> Rm;
3641
3642   let Inst{22} = Qd{3};
3643   let Inst{15-13} = Qd{2-0};
3644   let Inst{3-0} = Rm{3-0};
3645 }
3646
3647 class MVE_VADDSUB_qr<string iname, string suffix, bits<2> size,
3648                      bit bit_5, bit bit_12, bit bit_16,
3649                      bit bit_28, list<dag> pattern=[]>
3650   : MVE_qDest_rSrc<iname, suffix, "", pattern> {
3651
3652   let Inst{28} = bit_28;
3653   let Inst{21-20} = size;
3654   let Inst{16} = bit_16;
3655   let Inst{12} = bit_12;
3656   let Inst{8} = 0b1;
3657   let Inst{5} = bit_5;
3658 }
3659
3660 multiclass MVE_VADDSUB_qr_sizes<string iname, string suffix,
3661                                 bit bit_5, bit bit_12, bit bit_16,
3662                                 bit bit_28, list<dag> pattern=[]> {
3663   def "8"  : MVE_VADDSUB_qr<iname, suffix#"8",  0b00,
3664                             bit_5, bit_12, bit_16, bit_28>;
3665   def "16" : MVE_VADDSUB_qr<iname, suffix#"16", 0b01,
3666                             bit_5, bit_12, bit_16, bit_28>;
3667   def "32" : MVE_VADDSUB_qr<iname, suffix#"32", 0b10,
3668                             bit_5, bit_12, bit_16, bit_28>;
3669 }
3670
3671 defm MVE_VADD_qr_i  : MVE_VADDSUB_qr_sizes<"vadd",  "i", 0b0, 0b0, 0b1, 0b0>;
3672 defm MVE_VQADD_qr_s : MVE_VADDSUB_qr_sizes<"vqadd", "s", 0b1, 0b0, 0b0, 0b0>;
3673 defm MVE_VQADD_qr_u : MVE_VADDSUB_qr_sizes<"vqadd", "u", 0b1, 0b0, 0b0, 0b1>;
3674
3675 defm MVE_VSUB_qr_i  : MVE_VADDSUB_qr_sizes<"vsub",  "i", 0b0, 0b1, 0b1, 0b0>;
3676 defm MVE_VQSUB_qr_s : MVE_VADDSUB_qr_sizes<"vqsub", "s", 0b1, 0b1, 0b0, 0b0>;
3677 defm MVE_VQSUB_qr_u : MVE_VADDSUB_qr_sizes<"vqsub", "u", 0b1, 0b1, 0b0, 0b1>;
3678
3679 let Predicates = [HasMVEInt] in {
3680   def : Pat<(v16i8 (add (v16i8 MQPR:$val1), (v16i8 (ARMvdup GPR:$val2)))),
3681             (v16i8 (MVE_VADD_qr_i8 (v16i8 MQPR:$val1), (i32 GPR:$val2)))>;
3682   def : Pat<(v8i16 (add (v8i16 MQPR:$val1), (v8i16 (ARMvdup GPR:$val2)))),
3683             (v8i16 (MVE_VADD_qr_i16 (v8i16 MQPR:$val1), (i32 GPR:$val2)))>;
3684   def : Pat<(v4i32 (add (v4i32 MQPR:$val1), (v4i32 (ARMvdup GPR:$val2)))),
3685             (v4i32 (MVE_VADD_qr_i32 (v4i32 MQPR:$val1), (i32 GPR:$val2)))>;
3686 }
3687
3688 let Predicates = [HasMVEInt] in {
3689   def : Pat<(v16i8 (sub (v16i8 MQPR:$val1), (v16i8 (ARMvdup GPR:$val2)))),
3690             (v16i8 (MVE_VSUB_qr_i8 (v16i8 MQPR:$val1), (i32 GPR:$val2)))>;
3691   def : Pat<(v8i16 (sub (v8i16 MQPR:$val1), (v8i16 (ARMvdup GPR:$val2)))),
3692             (v8i16 (MVE_VSUB_qr_i16 (v8i16 MQPR:$val1), (i32 GPR:$val2)))>;
3693   def : Pat<(v4i32 (sub (v4i32 MQPR:$val1), (v4i32 (ARMvdup GPR:$val2)))),
3694             (v4i32 (MVE_VSUB_qr_i32 (v4i32 MQPR:$val1), (i32 GPR:$val2)))>;
3695 }
3696
3697 class MVE_VQDMULL_qr<string iname, string suffix, bit size,
3698                      bit T, string cstr="", list<dag> pattern=[]>
3699   : MVE_qDest_rSrc<iname, suffix, cstr, pattern> {
3700
3701   let Inst{28} = size;
3702   let Inst{21-20} = 0b11;
3703   let Inst{16} = 0b0;
3704   let Inst{12} = T;
3705   let Inst{8} = 0b1;
3706   let Inst{5} = 0b1;
3707 }
3708
3709 multiclass MVE_VQDMULL_qr_halves<string suffix, bit size, string cstr=""> {
3710   def bh : MVE_VQDMULL_qr<"vqdmullb", suffix, size, 0b0, cstr>;
3711   def th : MVE_VQDMULL_qr<"vqdmullt", suffix, size, 0b1, cstr>;
3712 }
3713
3714 defm MVE_VQDMULL_qr_s16 : MVE_VQDMULL_qr_halves<"s16", 0b0>;
3715 defm MVE_VQDMULL_qr_s32 : MVE_VQDMULL_qr_halves<"s32", 0b1, "@earlyclobber $Qd">;
3716
3717 class MVE_VxADDSUB_qr<string iname, string suffix,
3718                       bit bit_28, bits<2> bits_21_20, bit subtract,
3719                       list<dag> pattern=[]>
3720   : MVE_qDest_rSrc<iname, suffix, "", pattern> {
3721
3722   let Inst{28} = bit_28;
3723   let Inst{21-20} = bits_21_20;
3724   let Inst{16} = 0b0;
3725   let Inst{12} = subtract;
3726   let Inst{8} = 0b1;
3727   let Inst{5} = 0b0;
3728 }
3729
3730 def MVE_VHADD_qr_s8   : MVE_VxADDSUB_qr<"vhadd", "s8",  0b0, 0b00, 0b0>;
3731 def MVE_VHADD_qr_s16  : MVE_VxADDSUB_qr<"vhadd", "s16", 0b0, 0b01, 0b0>;
3732 def MVE_VHADD_qr_s32  : MVE_VxADDSUB_qr<"vhadd", "s32", 0b0, 0b10, 0b0>;
3733 def MVE_VHADD_qr_u8   : MVE_VxADDSUB_qr<"vhadd", "u8",  0b1, 0b00, 0b0>;
3734 def MVE_VHADD_qr_u16  : MVE_VxADDSUB_qr<"vhadd", "u16", 0b1, 0b01, 0b0>;
3735 def MVE_VHADD_qr_u32  : MVE_VxADDSUB_qr<"vhadd", "u32", 0b1, 0b10, 0b0>;
3736
3737 def MVE_VHSUB_qr_s8   : MVE_VxADDSUB_qr<"vhsub", "s8",  0b0, 0b00, 0b1>;
3738 def MVE_VHSUB_qr_s16  : MVE_VxADDSUB_qr<"vhsub", "s16", 0b0, 0b01, 0b1>;
3739 def MVE_VHSUB_qr_s32  : MVE_VxADDSUB_qr<"vhsub", "s32", 0b0, 0b10, 0b1>;
3740 def MVE_VHSUB_qr_u8   : MVE_VxADDSUB_qr<"vhsub", "u8",  0b1, 0b00, 0b1>;
3741 def MVE_VHSUB_qr_u16  : MVE_VxADDSUB_qr<"vhsub", "u16", 0b1, 0b01, 0b1>;
3742 def MVE_VHSUB_qr_u32  : MVE_VxADDSUB_qr<"vhsub", "u32", 0b1, 0b10, 0b1>;
3743
3744 let Predicates = [HasMVEFloat] in {
3745   def MVE_VADD_qr_f32 : MVE_VxADDSUB_qr<"vadd",  "f32", 0b0, 0b11, 0b0>;
3746   def MVE_VADD_qr_f16 : MVE_VxADDSUB_qr<"vadd",  "f16", 0b1, 0b11, 0b0>;
3747
3748   def MVE_VSUB_qr_f32 : MVE_VxADDSUB_qr<"vsub",  "f32", 0b0, 0b11, 0b1>;
3749   def MVE_VSUB_qr_f16 : MVE_VxADDSUB_qr<"vsub",  "f16", 0b1, 0b11, 0b1>;
3750 }
3751
3752 class MVE_VxSHL_qr<string iname, string suffix, bit U, bits<2> size,
3753                    bit bit_7, bit bit_17, list<dag> pattern=[]>
3754   : MVE_qDest_single_rSrc<iname, suffix, pattern> {
3755
3756   let Inst{28} = U;
3757   let Inst{25-23} = 0b100;
3758   let Inst{21-20} = 0b11;
3759   let Inst{19-18} = size;
3760   let Inst{17} = bit_17;
3761   let Inst{16} = 0b1;
3762   let Inst{12-8} = 0b11110;
3763   let Inst{7} = bit_7;
3764   let Inst{6-4} = 0b110;
3765 }
3766
3767 multiclass MVE_VxSHL_qr_types<string iname, bit bit_7, bit bit_17> {
3768   def s8  : MVE_VxSHL_qr<iname, "s8", 0b0, 0b00, bit_7, bit_17>;
3769   def s16 : MVE_VxSHL_qr<iname, "s16", 0b0, 0b01, bit_7, bit_17>;
3770   def s32 : MVE_VxSHL_qr<iname, "s32", 0b0, 0b10, bit_7, bit_17>;
3771   def u8  : MVE_VxSHL_qr<iname, "u8", 0b1, 0b00, bit_7, bit_17>;
3772   def u16 : MVE_VxSHL_qr<iname, "u16", 0b1, 0b01, bit_7, bit_17>;
3773   def u32 : MVE_VxSHL_qr<iname, "u32", 0b1, 0b10, bit_7, bit_17>;
3774 }
3775
3776 defm MVE_VSHL_qr   : MVE_VxSHL_qr_types<"vshl",   0b0, 0b0>;
3777 defm MVE_VRSHL_qr  : MVE_VxSHL_qr_types<"vrshl",  0b0, 0b1>;
3778 defm MVE_VQSHL_qr  : MVE_VxSHL_qr_types<"vqshl",  0b1, 0b0>;
3779 defm MVE_VQRSHL_qr : MVE_VxSHL_qr_types<"vqrshl", 0b1, 0b1>;
3780
3781 let Predicates = [HasMVEInt] in {
3782   def : Pat<(v4i32 (ARMvshlu (v4i32 MQPR:$Qm), (v4i32 (ARMvdup GPR:$Rm)))),
3783             (v4i32 (MVE_VSHL_qru32 (v4i32 MQPR:$Qm), GPR:$Rm))>;
3784   def : Pat<(v8i16 (ARMvshlu (v8i16 MQPR:$Qm), (v8i16 (ARMvdup GPR:$Rm)))),
3785             (v8i16 (MVE_VSHL_qru16 (v8i16 MQPR:$Qm), GPR:$Rm))>;
3786   def : Pat<(v16i8 (ARMvshlu (v16i8 MQPR:$Qm), (v16i8 (ARMvdup GPR:$Rm)))),
3787             (v16i8 (MVE_VSHL_qru8 (v16i8 MQPR:$Qm), GPR:$Rm))>;
3788
3789   def : Pat<(v4i32 (ARMvshls (v4i32 MQPR:$Qm), (v4i32 (ARMvdup GPR:$Rm)))),
3790             (v4i32 (MVE_VSHL_qrs32 (v4i32 MQPR:$Qm), GPR:$Rm))>;
3791   def : Pat<(v8i16 (ARMvshls (v8i16 MQPR:$Qm), (v8i16 (ARMvdup GPR:$Rm)))),
3792             (v8i16 (MVE_VSHL_qrs16 (v8i16 MQPR:$Qm), GPR:$Rm))>;
3793   def : Pat<(v16i8 (ARMvshls (v16i8 MQPR:$Qm), (v16i8 (ARMvdup GPR:$Rm)))),
3794             (v16i8 (MVE_VSHL_qrs8 (v16i8 MQPR:$Qm), GPR:$Rm))>;
3795 }
3796
3797 class MVE_VBRSR<string iname, string suffix, bits<2> size, list<dag> pattern=[]>
3798   : MVE_qDest_rSrc<iname, suffix, "", pattern> {
3799
3800   let Inst{28} = 0b1;
3801   let Inst{21-20} = size;
3802   let Inst{16} = 0b1;
3803   let Inst{12} = 0b1;
3804   let Inst{8} = 0b0;
3805   let Inst{5} = 0b1;
3806 }
3807
3808 def MVE_VBRSR8  : MVE_VBRSR<"vbrsr", "8", 0b00>;
3809 def MVE_VBRSR16 : MVE_VBRSR<"vbrsr", "16", 0b01>;
3810 def MVE_VBRSR32 : MVE_VBRSR<"vbrsr", "32", 0b10>;
3811
3812 let Predicates = [HasMVEInt] in {
3813   def : Pat<(v16i8 ( bitreverse (v16i8 MQPR:$val1))),
3814             (v16i8 ( MVE_VBRSR8 (v16i8 MQPR:$val1), (t2MOVi (i32 8)) ))>;
3815
3816   def : Pat<(v4i32 ( bitreverse (v4i32 MQPR:$val1))),
3817             (v4i32 ( MVE_VBRSR32 (v4i32 MQPR:$val1), (t2MOVi (i32 32)) ))>;
3818
3819   def : Pat<(v8i16 ( bitreverse (v8i16 MQPR:$val1))),
3820             (v8i16 ( MVE_VBRSR16 (v8i16 MQPR:$val1), (t2MOVi (i32 16)) ))>;
3821 }
3822
3823 class MVE_VMUL_qr_int<string iname, string suffix,
3824                       bits<2> size, list<dag> pattern=[]>
3825   : MVE_qDest_rSrc<iname, suffix, "", pattern> {
3826
3827   let Inst{28} = 0b0;
3828   let Inst{21-20} = size;
3829   let Inst{16} = 0b1;
3830   let Inst{12} = 0b1;
3831   let Inst{8} = 0b0;
3832   let Inst{5} = 0b1;
3833 }
3834
3835 def MVE_VMUL_qr_i8  : MVE_VMUL_qr_int<"vmul", "i8",  0b00>;
3836 def MVE_VMUL_qr_i16 : MVE_VMUL_qr_int<"vmul", "i16", 0b01>;
3837 def MVE_VMUL_qr_i32 : MVE_VMUL_qr_int<"vmul", "i32", 0b10>;
3838
3839 let Predicates = [HasMVEInt] in {
3840   def : Pat<(v16i8 (mul (v16i8 MQPR:$val1), (v16i8 (ARMvdup GPR:$val2)))),
3841             (v16i8 (MVE_VMUL_qr_i8 (v16i8 MQPR:$val1), (i32 GPR:$val2)))>;
3842   def : Pat<(v8i16 (mul (v8i16 MQPR:$val1), (v8i16 (ARMvdup GPR:$val2)))),
3843             (v8i16 (MVE_VMUL_qr_i16 (v8i16 MQPR:$val1), (i32 GPR:$val2)))>;
3844   def : Pat<(v4i32 (mul (v4i32 MQPR:$val1), (v4i32 (ARMvdup GPR:$val2)))),
3845             (v4i32 (MVE_VMUL_qr_i32 (v4i32 MQPR:$val1), (i32 GPR:$val2)))>;
3846 }
3847
3848 class MVE_VxxMUL_qr<string iname, string suffix,
3849                     bit bit_28, bits<2> bits_21_20, list<dag> pattern=[]>
3850   : MVE_qDest_rSrc<iname, suffix, "", pattern> {
3851
3852   let Inst{28} = bit_28;
3853   let Inst{21-20} = bits_21_20;
3854   let Inst{16} = 0b1;
3855   let Inst{12} = 0b0;
3856   let Inst{8} = 0b0;
3857   let Inst{5} = 0b1;
3858 }
3859
3860 def MVE_VQDMULH_qr_s8   : MVE_VxxMUL_qr<"vqdmulh",  "s8",  0b0, 0b00>;
3861 def MVE_VQDMULH_qr_s16  : MVE_VxxMUL_qr<"vqdmulh",  "s16", 0b0, 0b01>;
3862 def MVE_VQDMULH_qr_s32  : MVE_VxxMUL_qr<"vqdmulh",  "s32", 0b0, 0b10>;
3863
3864 def MVE_VQRDMULH_qr_s8  : MVE_VxxMUL_qr<"vqrdmulh", "s8",  0b1, 0b00>;
3865 def MVE_VQRDMULH_qr_s16 : MVE_VxxMUL_qr<"vqrdmulh", "s16", 0b1, 0b01>;
3866 def MVE_VQRDMULH_qr_s32 : MVE_VxxMUL_qr<"vqrdmulh", "s32", 0b1, 0b10>;
3867
3868 let Predicates = [HasMVEFloat] in {
3869   def MVE_VMUL_qr_f16   : MVE_VxxMUL_qr<"vmul", "f16", 0b1, 0b11>;
3870   def MVE_VMUL_qr_f32   : MVE_VxxMUL_qr<"vmul", "f32", 0b0, 0b11>;
3871 }
3872
3873 class MVE_VFMAMLA_qr<string iname, string suffix,
3874                      bit bit_28, bits<2> bits_21_20, bit S,
3875                      list<dag> pattern=[]>
3876   : MVE_qDestSrc_rSrc<iname, suffix, pattern> {
3877
3878   let Inst{28} = bit_28;
3879   let Inst{21-20} = bits_21_20;
3880   let Inst{16} = 0b1;
3881   let Inst{12} = S;
3882   let Inst{8} = 0b0;
3883   let Inst{5} = 0b0;
3884 }
3885
3886 def MVE_VMLA_qr_s8     : MVE_VFMAMLA_qr<"vmla",  "s8",  0b0, 0b00, 0b0>;
3887 def MVE_VMLA_qr_s16    : MVE_VFMAMLA_qr<"vmla",  "s16", 0b0, 0b01, 0b0>;
3888 def MVE_VMLA_qr_s32    : MVE_VFMAMLA_qr<"vmla",  "s32", 0b0, 0b10, 0b0>;
3889 def MVE_VMLA_qr_u8     : MVE_VFMAMLA_qr<"vmla",  "u8",  0b1, 0b00, 0b0>;
3890 def MVE_VMLA_qr_u16    : MVE_VFMAMLA_qr<"vmla",  "u16", 0b1, 0b01, 0b0>;
3891 def MVE_VMLA_qr_u32    : MVE_VFMAMLA_qr<"vmla",  "u32", 0b1, 0b10, 0b0>;
3892
3893 def MVE_VMLAS_qr_s8    : MVE_VFMAMLA_qr<"vmlas", "s8",  0b0, 0b00, 0b1>;
3894 def MVE_VMLAS_qr_s16   : MVE_VFMAMLA_qr<"vmlas", "s16", 0b0, 0b01, 0b1>;
3895 def MVE_VMLAS_qr_s32   : MVE_VFMAMLA_qr<"vmlas", "s32", 0b0, 0b10, 0b1>;
3896 def MVE_VMLAS_qr_u8    : MVE_VFMAMLA_qr<"vmlas", "u8",  0b1, 0b00, 0b1>;
3897 def MVE_VMLAS_qr_u16   : MVE_VFMAMLA_qr<"vmlas", "u16", 0b1, 0b01, 0b1>;
3898 def MVE_VMLAS_qr_u32   : MVE_VFMAMLA_qr<"vmlas", "u32", 0b1, 0b10, 0b1>;
3899
3900 let Predicates = [HasMVEInt] in {
3901   def : Pat<(v4i32 (add (v4i32 MQPR:$src1),
3902                         (v4i32 (mul (v4i32 MQPR:$src2),
3903                                     (v4i32 (ARMvdup (i32 rGPR:$x))))))),
3904             (v4i32 (MVE_VMLA_qr_u32 $src1, $src2, $x))>;
3905   def : Pat<(v8i16 (add (v8i16 MQPR:$src1),
3906                         (v8i16 (mul (v8i16 MQPR:$src2),
3907                                     (v8i16 (ARMvdup (i32 rGPR:$x))))))),
3908             (v8i16 (MVE_VMLA_qr_u16 $src1, $src2, $x))>;
3909   def : Pat<(v16i8 (add (v16i8 MQPR:$src1),
3910                         (v16i8 (mul (v16i8 MQPR:$src2),
3911                                     (v16i8 (ARMvdup (i32 rGPR:$x))))))),
3912             (v16i8 (MVE_VMLA_qr_u8 $src1, $src2, $x))>;
3913 }
3914
3915 let Predicates = [HasMVEFloat] in {
3916   def MVE_VFMA_qr_f16  : MVE_VFMAMLA_qr<"vfma",  "f16", 0b1, 0b11, 0b0>;
3917   def MVE_VFMA_qr_f32  : MVE_VFMAMLA_qr<"vfma",  "f32", 0b0, 0b11, 0b0>;
3918   def MVE_VFMA_qr_Sf16 : MVE_VFMAMLA_qr<"vfmas", "f16", 0b1, 0b11, 0b1>;
3919   def MVE_VFMA_qr_Sf32 : MVE_VFMAMLA_qr<"vfmas", "f32", 0b0, 0b11, 0b1>;
3920 }
3921
3922 class MVE_VQDMLAH_qr<string iname, string suffix, bit U, bits<2> size,
3923                      bit bit_5, bit bit_12, list<dag> pattern=[]>
3924   : MVE_qDestSrc_rSrc<iname, suffix, pattern> {
3925
3926   let Inst{28} = U;
3927   let Inst{21-20} = size;
3928   let Inst{16} = 0b0;
3929   let Inst{12} = bit_12;
3930   let Inst{8} = 0b0;
3931   let Inst{5} = bit_5;
3932 }
3933
3934 multiclass MVE_VQDMLAH_qr_types<string iname, bit bit_5, bit bit_12> {
3935   def s8  : MVE_VQDMLAH_qr<iname, "s8",  0b0, 0b00, bit_5, bit_12>;
3936   def s16 : MVE_VQDMLAH_qr<iname, "s16", 0b0, 0b01, bit_5, bit_12>;
3937   def s32 : MVE_VQDMLAH_qr<iname, "s32", 0b0, 0b10, bit_5, bit_12>;
3938 }
3939
3940 defm MVE_VQDMLAH_qr   : MVE_VQDMLAH_qr_types<"vqdmlah",   0b1, 0b0>;
3941 defm MVE_VQRDMLAH_qr  : MVE_VQDMLAH_qr_types<"vqrdmlah",  0b0, 0b0>;
3942 defm MVE_VQDMLASH_qr  : MVE_VQDMLAH_qr_types<"vqdmlash",  0b1, 0b1>;
3943 defm MVE_VQRDMLASH_qr : MVE_VQDMLAH_qr_types<"vqrdmlash", 0b0, 0b1>;
3944
3945 class MVE_VxDUP<string iname, string suffix, bits<2> size, bit bit_12,
3946               list<dag> pattern=[]>
3947   : MVE_p<(outs MQPR:$Qd, tGPREven:$Rn),
3948           (ins tGPREven:$Rn_src, MVE_VIDUP_imm:$imm), NoItinerary,
3949           iname, suffix, "$Qd, $Rn, $imm", vpred_r, "$Rn = $Rn_src",
3950           pattern> {
3951   bits<4> Qd;
3952   bits<4> Rn;
3953   bits<2> imm;
3954
3955   let Inst{28} = 0b0;
3956   let Inst{25-23} = 0b100;
3957   let Inst{22} = Qd{3};
3958   let Inst{21-20} = size;
3959   let Inst{19-17} = Rn{3-1};
3960   let Inst{16} = 0b1;
3961   let Inst{15-13} = Qd{2-0};
3962   let Inst{12} = bit_12;
3963   let Inst{11-8} = 0b1111;
3964   let Inst{7} = imm{1};
3965   let Inst{6-1} = 0b110111;
3966   let Inst{0} = imm{0};
3967 }
3968
3969 def MVE_VIDUPu8  : MVE_VxDUP<"vidup", "u8",  0b00, 0b0>;
3970 def MVE_VIDUPu16 : MVE_VxDUP<"vidup", "u16", 0b01, 0b0>;
3971 def MVE_VIDUPu32 : MVE_VxDUP<"vidup", "u32", 0b10, 0b0>;
3972
3973 def MVE_VDDUPu8  : MVE_VxDUP<"vddup", "u8",  0b00, 0b1>;
3974 def MVE_VDDUPu16 : MVE_VxDUP<"vddup", "u16", 0b01, 0b1>;
3975 def MVE_VDDUPu32 : MVE_VxDUP<"vddup", "u32", 0b10, 0b1>;
3976
3977 class MVE_VxWDUP<string iname, string suffix, bits<2> size, bit bit_12,
3978                  list<dag> pattern=[]>
3979   : MVE_p<(outs MQPR:$Qd, tGPREven:$Rn),
3980           (ins tGPREven:$Rn_src, tGPROdd:$Rm, MVE_VIDUP_imm:$imm), NoItinerary,
3981           iname, suffix, "$Qd, $Rn, $Rm, $imm", vpred_r, "$Rn = $Rn_src",
3982           pattern> {
3983   bits<4> Qd;
3984   bits<4> Rm;
3985   bits<4> Rn;
3986   bits<2> imm;
3987
3988   let Inst{28} = 0b0;
3989   let Inst{25-23} = 0b100;
3990   let Inst{22} = Qd{3};
3991   let Inst{21-20} = size;
3992   let Inst{19-17} = Rn{3-1};
3993   let Inst{16} = 0b1;
3994   let Inst{15-13} = Qd{2-0};
3995   let Inst{12} = bit_12;
3996   let Inst{11-8} = 0b1111;
3997   let Inst{7} = imm{1};
3998   let Inst{6-4} = 0b110;
3999   let Inst{3-1} = Rm{3-1};
4000   let Inst{0} = imm{0};
4001 }
4002
4003 def MVE_VIWDUPu8  : MVE_VxWDUP<"viwdup", "u8",  0b00, 0b0>;
4004 def MVE_VIWDUPu16 : MVE_VxWDUP<"viwdup", "u16", 0b01, 0b0>;
4005 def MVE_VIWDUPu32 : MVE_VxWDUP<"viwdup", "u32", 0b10, 0b0>;
4006
4007 def MVE_VDWDUPu8  : MVE_VxWDUP<"vdwdup", "u8",  0b00, 0b1>;
4008 def MVE_VDWDUPu16 : MVE_VxWDUP<"vdwdup", "u16", 0b01, 0b1>;
4009 def MVE_VDWDUPu32 : MVE_VxWDUP<"vdwdup", "u32", 0b10, 0b1>;
4010
4011 let hasSideEffects = 1 in
4012 class MVE_VCTP<string suffix, bits<2> size, list<dag> pattern=[]>
4013   : MVE_p<(outs VCCR:$P0), (ins rGPR:$Rn), NoItinerary, "vctp", suffix,
4014           "$Rn", vpred_n, "", pattern> {
4015   bits<4> Rn;
4016
4017   let Inst{28-27} = 0b10;
4018   let Inst{26-22} = 0b00000;
4019   let Inst{21-20} = size;
4020   let Inst{19-16} = Rn{3-0};
4021   let Inst{15-11} = 0b11101;
4022   let Inst{10-0}  = 0b00000000001;
4023   let Unpredictable{10-0} = 0b11111111111;
4024
4025   let Constraints = "";
4026   let DecoderMethod = "DecodeMveVCTP";
4027 }
4028
4029 def MVE_VCTP8  : MVE_VCTP<"8",  0b00>;
4030 def MVE_VCTP16 : MVE_VCTP<"16", 0b01>;
4031 def MVE_VCTP32 : MVE_VCTP<"32", 0b10>;
4032 def MVE_VCTP64 : MVE_VCTP<"64", 0b11>;
4033
4034 let Predicates = [HasMVEInt] in {
4035   def : Pat<(int_arm_vctp8 rGPR:$Rn),
4036             (v16i1 (MVE_VCTP8 rGPR:$Rn))>;
4037   def : Pat<(int_arm_vctp16 rGPR:$Rn),
4038             (v8i1 (MVE_VCTP16 rGPR:$Rn))>;
4039   def : Pat<(int_arm_vctp32 rGPR:$Rn),
4040             (v4i1 (MVE_VCTP32 rGPR:$Rn))>;
4041 }
4042
4043 // end of mve_qDest_rSrc
4044
4045 // start of coproc mov
4046
4047 class MVE_VMOV_64bit<dag oops, dag iops, bit to_qreg, string ops, string cstr>
4048   : MVE_VMOV_lane_base<oops, !con(iops, (ins MVEPairVectorIndex2:$idx,
4049                                              MVEPairVectorIndex0:$idx2)),
4050                        NoItinerary, "vmov", "", ops, cstr, []> {
4051   bits<5> Rt;
4052   bits<5> Rt2;
4053   bits<4> Qd;
4054   bit idx;
4055   bit idx2;
4056
4057   let Inst{31-23} = 0b111011000;
4058   let Inst{22} = Qd{3};
4059   let Inst{21} = 0b0;
4060   let Inst{20} = to_qreg;
4061   let Inst{19-16} = Rt2{3-0};
4062   let Inst{15-13} = Qd{2-0};
4063   let Inst{12-5} = 0b01111000;
4064   let Inst{4} = idx2;
4065   let Inst{3-0} = Rt{3-0};
4066 }
4067
4068 // The assembly syntax for these instructions mentions the vector
4069 // register name twice, e.g.
4070 //
4071 //    vmov q2[2], q2[0], r0, r1
4072 //    vmov r0, r1, q2[2], q2[0]
4073 //
4074 // which needs a bit of juggling with MC operand handling.
4075 //
4076 // For the move _into_ a vector register, the MC operand list also has
4077 // to mention the register name twice: once as the output, and once as
4078 // an extra input to represent where the unchanged half of the output
4079 // register comes from (when this instruction is used in code
4080 // generation). So we arrange that the first mention of the vector reg
4081 // in the instruction is considered by the AsmMatcher to be the output
4082 // ($Qd), and the second one is the input ($QdSrc). Binding them
4083 // together with the existing 'tie' constraint is enough to enforce at
4084 // register allocation time that they have to be the same register.
4085 //
4086 // For the move _from_ a vector register, there's no way to get round
4087 // the fact that both instances of that register name have to be
4088 // inputs. They have to be the same register again, but this time, we
4089 // can't use a tie constraint, because that has to be between an
4090 // output and an input operand. So this time, we have to arrange that
4091 // the q-reg appears just once in the MC operand list, in spite of
4092 // being mentioned twice in the asm syntax - which needs a custom
4093 // AsmMatchConverter.
4094
4095 def MVE_VMOV_q_rr : MVE_VMOV_64bit<(outs MQPR:$Qd),
4096                                    (ins MQPR:$QdSrc, rGPR:$Rt, rGPR:$Rt2),
4097                                    0b1, "$Qd$idx, $QdSrc$idx2, $Rt, $Rt2",
4098                                    "$Qd = $QdSrc"> {
4099   let DecoderMethod = "DecodeMVEVMOVDRegtoQ";
4100 }
4101
4102 def MVE_VMOV_rr_q : MVE_VMOV_64bit<(outs rGPR:$Rt, rGPR:$Rt2), (ins MQPR:$Qd),
4103                                    0b0, "$Rt, $Rt2, $Qd$idx, $Qd$idx2", ""> {
4104   let DecoderMethod = "DecodeMVEVMOVQtoDReg";
4105   let AsmMatchConverter = "cvtMVEVMOVQtoDReg";
4106 }
4107
4108 // end of coproc mov
4109
4110 // start of MVE interleaving load/store
4111
4112 // Base class for the family of interleaving/deinterleaving
4113 // load/stores with names like VLD20.8 and VST43.32.
4114 class MVE_vldst24_base<bit writeback, bit fourregs, bits<2> stage, bits<2> size,
4115                        bit load, dag Oops, dag loadIops, dag wbIops,
4116                        string iname, string ops,
4117                        string cstr, list<dag> pattern=[]>
4118   : MVE_MI<Oops, !con(loadIops, wbIops), NoItinerary, iname, ops, cstr, pattern> {
4119   bits<4> VQd;
4120   bits<4> Rn;
4121
4122   let Inst{31-22} = 0b1111110010;
4123   let Inst{21} = writeback;
4124   let Inst{20} = load;
4125   let Inst{19-16} = Rn;
4126   let Inst{15-13} = VQd{2-0};
4127   let Inst{12-9} = 0b1111;
4128   let Inst{8-7} = size;
4129   let Inst{6-5} = stage;
4130   let Inst{4-1} = 0b0000;
4131   let Inst{0} = fourregs;
4132
4133   let mayLoad = load;
4134   let mayStore = !eq(load,0);
4135 }
4136
4137 // A parameter class used to encapsulate all the ways the writeback
4138 // variants of VLD20 and friends differ from the non-writeback ones.
4139 class MVE_vldst24_writeback<bit b, dag Oo, dag Io,
4140                             string sy="", string c="", string n=""> {
4141   bit writeback = b;
4142   dag Oops = Oo;
4143   dag Iops = Io;
4144   string syntax = sy;
4145   string cstr = c;
4146   string id_suffix = n;
4147 }
4148
4149 // Another parameter class that encapsulates the differences between VLD2x
4150 // and VLD4x.
4151 class MVE_vldst24_nvecs<int n, list<int> s, bit b, RegisterOperand vl> {
4152   int nvecs = n;
4153   list<int> stages = s;
4154   bit bit0 = b;
4155   RegisterOperand VecList = vl;
4156 }
4157
4158 // A third parameter class that distinguishes VLDnn.8 from .16 from .32.
4159 class MVE_vldst24_lanesize<int i, bits<2> b> {
4160   int lanesize = i;
4161   bits<2> sizebits = b;
4162 }
4163
4164 // A base class for each direction of transfer: one for load, one for
4165 // store. I can't make these a fourth independent parametric tuple
4166 // class, because they have to take the nvecs tuple class as a
4167 // parameter, in order to find the right VecList operand type.
4168
4169 class MVE_vld24_base<MVE_vldst24_nvecs n, bits<2> pat, bits<2> size,
4170                      MVE_vldst24_writeback wb, string iname,
4171                      list<dag> pattern=[]>
4172   : MVE_vldst24_base<wb.writeback, n.bit0, pat, size, 1,
4173                      !con((outs n.VecList:$VQd), wb.Oops),
4174                      (ins n.VecList:$VQdSrc), wb.Iops,
4175                      iname, "$VQd, $Rn" # wb.syntax,
4176                      wb.cstr # ",$VQdSrc = $VQd", pattern>;
4177
4178 class MVE_vst24_base<MVE_vldst24_nvecs n, bits<2> pat, bits<2> size,
4179                      MVE_vldst24_writeback wb, string iname,
4180                      list<dag> pattern=[]>
4181   : MVE_vldst24_base<wb.writeback, n.bit0, pat, size, 0,
4182                      wb.Oops, (ins n.VecList:$VQd), wb.Iops,
4183                      iname, "$VQd, $Rn" # wb.syntax,
4184                      wb.cstr, pattern>;
4185
4186 // Actually define all the interleaving loads and stores, by a series
4187 // of nested foreaches over number of vectors (VLD2/VLD4); stage
4188 // within one of those series (VLDx0/VLDx1/VLDx2/VLDx3); size of
4189 // vector lane; writeback or no writeback.
4190 foreach n = [MVE_vldst24_nvecs<2, [0,1],     0, VecList2Q>,
4191              MVE_vldst24_nvecs<4, [0,1,2,3], 1, VecList4Q>] in
4192 foreach stage = n.stages in
4193 foreach s = [MVE_vldst24_lanesize< 8, 0b00>,
4194              MVE_vldst24_lanesize<16, 0b01>,
4195              MVE_vldst24_lanesize<32, 0b10>] in
4196 foreach wb = [MVE_vldst24_writeback<
4197                 1, (outs rGPR:$wb), (ins t2_nosp_addr_offset_none:$Rn),
4198                 "!", "$Rn.base = $wb", "_wb">,
4199               MVE_vldst24_writeback<0, (outs), (ins t2_addr_offset_none:$Rn)>] in {
4200
4201   // For each case within all of those foreaches, define the actual
4202   // instructions. The def names are made by gluing together pieces
4203   // from all the parameter classes, and will end up being things like
4204   // MVE_VLD20_8 and MVE_VST43_16_wb.
4205
4206   def "MVE_VLD" # n.nvecs # stage # "_" # s.lanesize # wb.id_suffix
4207     : MVE_vld24_base<n, stage, s.sizebits, wb,
4208                      "vld" # n.nvecs # stage # "." # s.lanesize>;
4209
4210   def "MVE_VST" # n.nvecs # stage # "_" # s.lanesize # wb.id_suffix
4211     : MVE_vst24_base<n, stage, s.sizebits, wb,
4212                      "vst" # n.nvecs # stage # "." # s.lanesize>;
4213 }
4214
4215 // end of MVE interleaving load/store
4216
4217 // start of MVE predicable load/store
4218
4219 // A parameter class for the direction of transfer.
4220 class MVE_ldst_direction<bit b, dag Oo, dag Io, string c=""> {
4221   bit load = b;
4222   dag Oops = Oo;
4223   dag Iops = Io;
4224   string cstr = c;
4225 }
4226 def MVE_ld: MVE_ldst_direction<1, (outs MQPR:$Qd), (ins), ",@earlyclobber $Qd">;
4227 def MVE_st: MVE_ldst_direction<0, (outs), (ins MQPR:$Qd)>;
4228
4229 // A parameter class for the size of memory access in a load.
4230 class MVE_memsz<bits<2> e, int s, AddrMode m, string mn, list<string> types> {
4231   bits<2> encoding = e;         // opcode bit(s) for encoding
4232   int shift = s;                // shift applied to immediate load offset
4233   AddrMode AM = m;
4234
4235   // For instruction aliases: define the complete list of type
4236   // suffixes at this size, and the canonical ones for loads and
4237   // stores.
4238   string MnemonicLetter = mn;
4239   int TypeBits = !shl(8, s);
4240   string CanonLoadSuffix = ".u" # TypeBits;
4241   string CanonStoreSuffix = "." # TypeBits;
4242   list<string> suffixes = !foreach(letter, types, "." # letter # TypeBits);
4243 }
4244
4245 // Instances of MVE_memsz.
4246 //
4247 // (memD doesn't need an AddrMode, because those are only for
4248 // contiguous loads, and memD is only used by gather/scatters.)
4249 def MVE_memB: MVE_memsz<0b00, 0, AddrModeT2_i7,   "b", ["", "u", "s"]>;
4250 def MVE_memH: MVE_memsz<0b01, 1, AddrModeT2_i7s2, "h", ["", "u", "s", "f"]>;
4251 def MVE_memW: MVE_memsz<0b10, 2, AddrModeT2_i7s4, "w", ["", "u", "s", "f"]>;
4252 def MVE_memD: MVE_memsz<0b11, 3, ?,               "d", ["", "u", "s", "f"]>;
4253
4254 // This is the base class for all the MVE loads and stores other than
4255 // the interleaving ones. All the non-interleaving loads/stores share
4256 // the characteristic that they operate on just one vector register,
4257 // so they are VPT-predicable.
4258 //
4259 // The predication operand is vpred_n, for both loads and stores. For
4260 // store instructions, the reason is obvious: if there is no output
4261 // register, there can't be a need for an input parameter giving the
4262 // output register's previous value. Load instructions also don't need
4263 // that input parameter, because unlike MVE data processing
4264 // instructions, predicated loads are defined to set the inactive
4265 // lanes of the output register to zero, instead of preserving their
4266 // input values.
4267 class MVE_VLDRSTR_base<MVE_ldst_direction dir, bit U, bit P, bit W, bit opc,
4268                        dag oops, dag iops, string asm, string suffix,
4269                        string ops, string cstr, list<dag> pattern=[]>
4270  : MVE_p<oops, iops, NoItinerary, asm, suffix, ops, vpred_n, cstr, pattern> {
4271   bits<3> Qd;
4272
4273   let Inst{28} = U;
4274   let Inst{25} = 0b0;
4275   let Inst{24} = P;
4276   let Inst{22} = 0b0;
4277   let Inst{21} = W;
4278   let Inst{20} = dir.load;
4279   let Inst{15-13} = Qd{2-0};
4280   let Inst{12} = opc;
4281   let Inst{11-9} = 0b111;
4282
4283   let mayLoad = dir.load;
4284   let mayStore = !eq(dir.load,0);
4285 }
4286
4287 // Contiguous load and store instructions. These come in two main
4288 // categories: same-size loads/stores in which 128 bits of vector
4289 // register is transferred to or from 128 bits of memory in the most
4290 // obvious way, and widening loads / narrowing stores, in which the
4291 // size of memory accessed is less than the size of a vector register,
4292 // so the load instructions sign- or zero-extend each memory value
4293 // into a wider vector lane, and the store instructions truncate
4294 // correspondingly.
4295 //
4296 // The instruction mnemonics for these two classes look reasonably
4297 // similar, but the actual encodings are different enough to need two
4298 // separate base classes.
4299
4300 // Contiguous, same size
4301 class MVE_VLDRSTR_cs<MVE_ldst_direction dir, MVE_memsz memsz, bit P, bit W,
4302                      dag oops, dag iops, string asm, string suffix,
4303                      IndexMode im, string ops, string cstr>
4304   : MVE_VLDRSTR_base<dir, 0, P, W, 1, oops, iops, asm, suffix, ops, cstr> {
4305   bits<12> addr;
4306   let Inst{23} = addr{7};
4307   let Inst{19-16} = addr{11-8};
4308   let Inst{8-7} = memsz.encoding;
4309   let Inst{6-0} = addr{6-0};
4310 }
4311
4312 // Contiguous, widening/narrowing
4313 class MVE_VLDRSTR_cw<MVE_ldst_direction dir, MVE_memsz memsz, bit U,
4314                      bit P, bit W, bits<2> size, dag oops, dag iops,
4315                      string asm, string suffix, IndexMode im,
4316                      string ops, string cstr>
4317   : MVE_VLDRSTR_base<dir, U, P, W, 0, oops, iops, asm, suffix, ops, cstr> {
4318   bits<11> addr;
4319   let Inst{23} = addr{7};
4320   let Inst{19} = memsz.encoding{0}; // enough to tell 16- from 32-bit
4321   let Inst{18-16} = addr{10-8};
4322   let Inst{8-7} = size;
4323   let Inst{6-0} = addr{6-0};
4324
4325   let IM = im;
4326 }
4327
4328 // Multiclass wrapper on each of the _cw and _cs base classes, to
4329 // generate three writeback modes (none, preindex, postindex).
4330
4331 multiclass MVE_VLDRSTR_cw_m<MVE_ldst_direction dir, MVE_memsz memsz,
4332                             string asm, string suffix, bit U, bits<2> size> {
4333   let AM = memsz.AM in {
4334     def "" : MVE_VLDRSTR_cw<
4335         dir, memsz, U, 1, 0, size,
4336         dir.Oops, !con(dir.Iops, (ins taddrmode_imm7<memsz.shift>:$addr)),
4337         asm, suffix, IndexModeNone, "$Qd, $addr", "">;
4338
4339     def _pre : MVE_VLDRSTR_cw<
4340         dir, memsz, U, 1, 1, size,
4341         !con((outs tGPR:$wb), dir.Oops),
4342         !con(dir.Iops, (ins taddrmode_imm7<memsz.shift>:$addr)),
4343         asm, suffix, IndexModePre, "$Qd, $addr!", "$addr.base = $wb"> {
4344       let DecoderMethod = "DecodeMVE_MEM_1_pre<"#memsz.shift#">";
4345     }
4346
4347     def _post : MVE_VLDRSTR_cw<
4348         dir, memsz, U, 0, 1, size,
4349         !con((outs tGPR:$wb), dir.Oops),
4350         !con(dir.Iops, (ins t_addr_offset_none:$Rn,
4351                             t2am_imm7_offset<memsz.shift>:$addr)),
4352         asm, suffix, IndexModePost, "$Qd, $Rn$addr", "$Rn.base = $wb"> {
4353       bits<4> Rn;
4354       let Inst{18-16} = Rn{2-0};
4355     }
4356   }
4357 }
4358
4359 multiclass MVE_VLDRSTR_cs_m<MVE_ldst_direction dir, MVE_memsz memsz,
4360                             string asm, string suffix> {
4361   let AM = memsz.AM in {
4362     def "" : MVE_VLDRSTR_cs<
4363         dir, memsz, 1, 0,
4364         dir.Oops, !con(dir.Iops, (ins t2addrmode_imm7<memsz.shift>:$addr)),
4365         asm, suffix, IndexModeNone, "$Qd, $addr", "">;
4366
4367     def _pre : MVE_VLDRSTR_cs<
4368         dir, memsz, 1, 1,
4369         !con((outs rGPR:$wb), dir.Oops),
4370         !con(dir.Iops, (ins t2addrmode_imm7_pre<memsz.shift>:$addr)),
4371         asm, suffix, IndexModePre, "$Qd, $addr!", "$addr.base = $wb"> {
4372       let DecoderMethod = "DecodeMVE_MEM_2_pre<"#memsz.shift#">";
4373     }
4374
4375     def _post : MVE_VLDRSTR_cs<
4376         dir, memsz, 0, 1,
4377         !con((outs rGPR:$wb), dir.Oops),
4378         // We need an !if here to select the base register class,
4379         // because it's legal to write back to SP in a load of this
4380         // type, but not in a store.
4381         !con(dir.Iops, (ins !if(dir.load, t2_addr_offset_none,
4382                                           t2_nosp_addr_offset_none):$Rn,
4383                             t2am_imm7_offset<memsz.shift>:$addr)),
4384         asm, suffix, IndexModePost, "$Qd, $Rn$addr", "$Rn.base = $wb"> {
4385       bits<4> Rn;
4386       let Inst{19-16} = Rn{3-0};
4387     }
4388   }
4389 }
4390
4391 // Now actually declare all the contiguous load/stores, via those
4392 // multiclasses. The instruction ids coming out of this are the bare
4393 // names shown in the defm, with _pre or _post appended for writeback,
4394 // e.g. MVE_VLDRBS16, MVE_VSTRB16_pre, MVE_VSTRHU16_post.
4395
4396 defm MVE_VLDRBS16: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "s16", 0, 0b01>;
4397 defm MVE_VLDRBS32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "s32", 0, 0b10>;
4398 defm MVE_VLDRBU16: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "u16", 1, 0b01>;
4399 defm MVE_VLDRBU32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "u32", 1, 0b10>;
4400 defm MVE_VLDRHS32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memH, "vldrh", "s32", 0, 0b10>;
4401 defm MVE_VLDRHU32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memH, "vldrh", "u32", 1, 0b10>;
4402
4403 defm MVE_VLDRBU8:  MVE_VLDRSTR_cs_m<MVE_ld, MVE_memB, "vldrb", "u8">;
4404 defm MVE_VLDRHU16: MVE_VLDRSTR_cs_m<MVE_ld, MVE_memH, "vldrh", "u16">;
4405 defm MVE_VLDRWU32: MVE_VLDRSTR_cs_m<MVE_ld, MVE_memW, "vldrw", "u32">;
4406
4407 defm MVE_VSTRB16:  MVE_VLDRSTR_cw_m<MVE_st, MVE_memB, "vstrb", "16",  0, 0b01>;
4408 defm MVE_VSTRB32:  MVE_VLDRSTR_cw_m<MVE_st, MVE_memB, "vstrb", "32",  0, 0b10>;
4409 defm MVE_VSTRH32:  MVE_VLDRSTR_cw_m<MVE_st, MVE_memH, "vstrh", "32",  0, 0b10>;
4410
4411 defm MVE_VSTRBU8 : MVE_VLDRSTR_cs_m<MVE_st, MVE_memB, "vstrb", "8">;
4412 defm MVE_VSTRHU16: MVE_VLDRSTR_cs_m<MVE_st, MVE_memH, "vstrh", "16">;
4413 defm MVE_VSTRWU32: MVE_VLDRSTR_cs_m<MVE_st, MVE_memW, "vstrw", "32">;
4414
4415 // Gather loads / scatter stores whose address operand is of the form
4416 // [Rn,Qm], i.e. a single GPR as the common base address, plus a
4417 // vector of offset from it. ('Load/store this sequence of elements of
4418 // the same array.')
4419 //
4420 // Like the contiguous family, these loads and stores can widen the
4421 // loaded values / truncate the stored ones, or they can just
4422 // load/store the same size of memory and vector lane. But unlike the
4423 // contiguous family, there's no particular difference in encoding
4424 // between those two cases.
4425 //
4426 // This family also comes with the option to scale the offset values
4427 // in Qm by the size of the loaded memory (i.e. to treat them as array
4428 // indices), or not to scale them (to treat them as plain byte offsets
4429 // in memory, so that perhaps the loaded values are unaligned). The
4430 // scaled instructions' address operand in assembly looks like
4431 // [Rn,Qm,UXTW #2] or similar.
4432
4433 // Base class.
4434 class MVE_VLDRSTR_rq<MVE_ldst_direction dir, MVE_memsz memsz, bit U,
4435                      bits<2> size, bit os, string asm, string suffix, int shift>
4436   : MVE_VLDRSTR_base<dir, U, 0b0, 0b0, 0, dir.Oops,
4437                      !con(dir.Iops, (ins mve_addr_rq_shift<shift>:$addr)),
4438                      asm, suffix, "$Qd, $addr", dir.cstr> {
4439   bits<7> addr;
4440   let Inst{23} = 0b1;
4441   let Inst{19-16} = addr{6-3};
4442   let Inst{8-7} = size;
4443   let Inst{6} = memsz.encoding{1};
4444   let Inst{5} = 0;
4445   let Inst{4} = memsz.encoding{0};
4446   let Inst{3-1} = addr{2-0};
4447   let Inst{0} = os;
4448 }
4449
4450 // Multiclass that defines the scaled and unscaled versions of an
4451 // instruction, when the memory size is wider than a byte. The scaled
4452 // version gets the default name like MVE_VLDRBU16_rq; the unscaled /
4453 // potentially unaligned version gets a "_u" suffix, e.g.
4454 // MVE_VLDRBU16_rq_u.
4455 multiclass MVE_VLDRSTR_rq_w<MVE_ldst_direction dir, MVE_memsz memsz,
4456                             string asm, string suffix, bit U, bits<2> size> {
4457   def _u : MVE_VLDRSTR_rq<dir, memsz, U, size, 0, asm, suffix, 0>;
4458   def "" : MVE_VLDRSTR_rq<dir, memsz, U, size, 1, asm, suffix, memsz.shift>;
4459 }
4460
4461 // Subclass of MVE_VLDRSTR_rq with the same API as that multiclass,
4462 // for use when the memory size is one byte, so there's no 'scaled'
4463 // version of the instruction at all. (This is encoded as if it were
4464 // unscaled, but named in the default way with no _u suffix.)
4465 class MVE_VLDRSTR_rq_b<MVE_ldst_direction dir, MVE_memsz memsz,
4466                        string asm, string suffix, bit U, bits<2> size>
4467   : MVE_VLDRSTR_rq<dir, memsz, U, size, 0, asm, suffix, 0>;
4468
4469 // Actually define all the loads and stores in this family.
4470
4471 def  MVE_VLDRBU8_rq : MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u8",  1,0b00>;
4472 def  MVE_VLDRBU16_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u16", 1,0b01>;
4473 def  MVE_VLDRBS16_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","s16", 0,0b01>;
4474 def  MVE_VLDRBU32_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u32", 1,0b10>;
4475 def  MVE_VLDRBS32_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","s32", 0,0b10>;
4476
4477 defm MVE_VLDRHU16_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","u16", 1,0b01>;
4478 defm MVE_VLDRHU32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","u32", 1,0b10>;
4479 defm MVE_VLDRHS32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","s32", 0,0b10>;
4480 defm MVE_VLDRWU32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memW, "vldrw","u32", 1,0b10>;
4481 defm MVE_VLDRDU64_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memD, "vldrd","u64", 1,0b11>;
4482
4483 def  MVE_VSTRB8_rq  : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","8",   0,0b00>;
4484 def  MVE_VSTRB16_rq : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","16",  0,0b01>;
4485 def  MVE_VSTRB32_rq : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","32",  0,0b10>;
4486
4487 defm MVE_VSTRH16_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memH, "vstrh","16",  0,0b01>;
4488 defm MVE_VSTRH32_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memH, "vstrh","32",  0,0b10>;
4489 defm MVE_VSTRW32_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memW, "vstrw","32",  0,0b10>;
4490 defm MVE_VSTRD64_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memD, "vstrd","64",  0,0b11>;
4491
4492 // Gather loads / scatter stores whose address operand is of the form
4493 // [Qm,#imm], i.e. a vector containing a full base address for each
4494 // loaded item, plus an immediate offset applied consistently to all
4495 // of them. ('Load/store the same field from this vector of pointers
4496 // to a structure type.')
4497 //
4498 // This family requires the vector lane size to be at least 32 bits
4499 // (so there's room for an address in each lane at all). It has no
4500 // widening/narrowing variants. But it does support preindex
4501 // writeback, in which the address vector is updated to hold the
4502 // addresses actually loaded from.
4503
4504 // Base class.
4505 class MVE_VLDRSTR_qi<MVE_ldst_direction dir, MVE_memsz memsz, bit W, dag wbops,
4506                      string asm, string wbAsm, string suffix, string cstr = "">
4507   : MVE_VLDRSTR_base<dir, 1, 1, W, 1, !con(wbops, dir.Oops),
4508                      !con(dir.Iops, (ins mve_addr_q_shift<memsz.shift>:$addr)),
4509                      asm, suffix, "$Qd, $addr" # wbAsm, cstr # dir.cstr> {
4510   bits<11> addr;
4511   let Inst{23} = addr{7};
4512   let Inst{19-17} = addr{10-8};
4513   let Inst{16} = 0;
4514   let Inst{8} = memsz.encoding{0}; // enough to distinguish 32- from 64-bit
4515   let Inst{7} = 0;
4516   let Inst{6-0} = addr{6-0};
4517 }
4518
4519 // Multiclass that generates the non-writeback and writeback variants.
4520 multiclass MVE_VLDRSTR_qi_m<MVE_ldst_direction dir, MVE_memsz memsz,
4521                             string asm, string suffix> {
4522   def ""   : MVE_VLDRSTR_qi<dir, memsz, 0, (outs),          asm, "",  suffix>;
4523   def _pre : MVE_VLDRSTR_qi<dir, memsz, 1, (outs MQPR:$wb), asm, "!", suffix,
4524                             "$addr.base = $wb"> {
4525     let DecoderMethod="DecodeMVE_MEM_3_pre<"#memsz.shift#">";
4526   }
4527 }
4528
4529 // Actual instruction definitions.
4530 defm MVE_VLDRWU32_qi: MVE_VLDRSTR_qi_m<MVE_ld, MVE_memW, "vldrw", "u32">;
4531 defm MVE_VLDRDU64_qi: MVE_VLDRSTR_qi_m<MVE_ld, MVE_memD, "vldrd", "u64">;
4532 defm MVE_VSTRW32_qi:  MVE_VLDRSTR_qi_m<MVE_st, MVE_memW, "vstrw", "32">;
4533 defm MVE_VSTRD64_qi:  MVE_VLDRSTR_qi_m<MVE_st, MVE_memD, "vstrd", "64">;
4534
4535 // Define aliases for all the instructions where memory size and
4536 // vector lane size are the same. These are mnemonic aliases, so they
4537 // apply consistently across all of the above families - contiguous
4538 // loads, and both the rq and qi types of gather/scatter.
4539 //
4540 // Rationale: As long as you're loading (for example) 16-bit memory
4541 // values into 16-bit vector lanes, you can think of them as signed or
4542 // unsigned integers, fp16 or just raw 16-bit blobs and it makes no
4543 // difference. So we permit all of vldrh.16, vldrh.u16, vldrh.s16,
4544 // vldrh.f16 and treat them all as equivalent to the canonical
4545 // spelling (which happens to be .u16 for loads, and just .16 for
4546 // stores).
4547
4548 foreach vpt_cond = ["", "t", "e"] in
4549 foreach memsz = [MVE_memB, MVE_memH, MVE_memW, MVE_memD] in
4550 foreach suffix = memsz.suffixes in {
4551
4552   // These foreaches are conceptually ifs, implemented by iterating a
4553   // dummy variable over a list with 0 or 1 elements depending on the
4554   // condition. The idea is to iterate over _nearly_ all the suffixes
4555   // in memsz.suffixes, but omit the one we want all the others to alias.
4556
4557   foreach _ = !if(!ne(suffix, memsz.CanonLoadSuffix), [1], []<int>) in
4558   def : MnemonicAlias<
4559     "vldr" # memsz.MnemonicLetter # vpt_cond # suffix,
4560     "vldr" # memsz.MnemonicLetter # vpt_cond # memsz.CanonLoadSuffix>;
4561
4562   foreach _ = !if(!ne(suffix, memsz.CanonStoreSuffix), [1], []<int>) in
4563   def : MnemonicAlias<
4564     "vstr" # memsz.MnemonicLetter # vpt_cond # suffix,
4565     "vstr" # memsz.MnemonicLetter # vpt_cond # memsz.CanonStoreSuffix>;
4566 }
4567
4568 // end of MVE predicable load/store
4569
4570 class MVE_VPT<string suffix, bits<2> size, dag iops, string asm, list<dag> pattern=[]>
4571   : MVE_MI<(outs ), iops, NoItinerary, !strconcat("vpt", "${Mk}", ".", suffix), asm, "", pattern> {
4572   bits<3> fc;
4573   bits<4> Mk;
4574   bits<3> Qn;
4575
4576   let Inst{31-23} = 0b111111100;
4577   let Inst{22} = Mk{3};
4578   let Inst{21-20} = size;
4579   let Inst{19-17} = Qn{2-0};
4580   let Inst{16} = 0b1;
4581   let Inst{15-13} = Mk{2-0};
4582   let Inst{12} = fc{2};
4583   let Inst{11-8} = 0b1111;
4584   let Inst{7} = fc{0};
4585   let Inst{4} = 0b0;
4586
4587   let Defs = [VPR];
4588 }
4589
4590 class MVE_VPTt1<string suffix, bits<2> size, dag iops>
4591   : MVE_VPT<suffix, size, iops, "$fc, $Qn, $Qm"> {
4592   bits<4> Qm;
4593   bits<4> Mk;
4594
4595   let Inst{6} = 0b0;
4596   let Inst{5} = Qm{3};
4597   let Inst{3-1} = Qm{2-0};
4598   let Inst{0} = fc{1};
4599 }
4600
4601 class MVE_VPTt1i<string suffix, bits<2> size>
4602  : MVE_VPTt1<suffix, size,
4603            (ins vpt_mask:$Mk, MQPR:$Qn, MQPR:$Qm, pred_basic_i:$fc)> {
4604   let Inst{12} = 0b0;
4605   let Inst{0} = 0b0;
4606 }
4607
4608 def MVE_VPTv4i32 : MVE_VPTt1i<"i32", 0b10>;
4609 def MVE_VPTv8i16 : MVE_VPTt1i<"i16", 0b01>;
4610 def MVE_VPTv16i8 : MVE_VPTt1i<"i8", 0b00>;
4611
4612 class MVE_VPTt1u<string suffix, bits<2> size>
4613  : MVE_VPTt1<suffix, size,
4614            (ins vpt_mask:$Mk, MQPR:$Qn, MQPR:$Qm, pred_basic_u:$fc)> {
4615   let Inst{12} = 0b0;
4616   let Inst{0} = 0b1;
4617 }
4618
4619 def MVE_VPTv4u32 : MVE_VPTt1u<"u32", 0b10>;
4620 def MVE_VPTv8u16 : MVE_VPTt1u<"u16", 0b01>;
4621 def MVE_VPTv16u8 : MVE_VPTt1u<"u8", 0b00>;
4622
4623 class MVE_VPTt1s<string suffix, bits<2> size>
4624  : MVE_VPTt1<suffix, size,
4625            (ins vpt_mask:$Mk, MQPR:$Qn, MQPR:$Qm, pred_basic_s:$fc)> {
4626   let Inst{12} = 0b1;
4627 }
4628
4629 def MVE_VPTv4s32 : MVE_VPTt1s<"s32", 0b10>;
4630 def MVE_VPTv8s16 : MVE_VPTt1s<"s16", 0b01>;
4631 def MVE_VPTv16s8 : MVE_VPTt1s<"s8", 0b00>;
4632
4633 class MVE_VPTt2<string suffix, bits<2> size, dag iops>
4634   : MVE_VPT<suffix, size, iops,
4635           "$fc, $Qn, $Rm"> {
4636   bits<4> Rm;
4637   bits<3> fc;
4638   bits<4> Mk;
4639
4640   let Inst{6} = 0b1;
4641   let Inst{5} = fc{1};
4642   let Inst{3-0} = Rm{3-0};
4643 }
4644
4645 class MVE_VPTt2i<string suffix, bits<2> size>
4646   : MVE_VPTt2<suffix, size,
4647             (ins vpt_mask:$Mk, MQPR:$Qn, GPRwithZR:$Rm, pred_basic_i:$fc)> {
4648   let Inst{12} = 0b0;
4649   let Inst{5} = 0b0;
4650 }
4651
4652 def MVE_VPTv4i32r : MVE_VPTt2i<"i32", 0b10>;
4653 def MVE_VPTv8i16r : MVE_VPTt2i<"i16", 0b01>;
4654 def MVE_VPTv16i8r : MVE_VPTt2i<"i8", 0b00>;
4655
4656 class MVE_VPTt2u<string suffix, bits<2> size>
4657   : MVE_VPTt2<suffix, size,
4658             (ins vpt_mask:$Mk, MQPR:$Qn, GPRwithZR:$Rm, pred_basic_u:$fc)> {
4659   let Inst{12} = 0b0;
4660   let Inst{5} = 0b1;
4661 }
4662
4663 def MVE_VPTv4u32r : MVE_VPTt2u<"u32", 0b10>;
4664 def MVE_VPTv8u16r : MVE_VPTt2u<"u16", 0b01>;
4665 def MVE_VPTv16u8r : MVE_VPTt2u<"u8", 0b00>;
4666
4667 class MVE_VPTt2s<string suffix, bits<2> size>
4668   : MVE_VPTt2<suffix, size,
4669             (ins vpt_mask:$Mk, MQPR:$Qn, GPRwithZR:$Rm, pred_basic_s:$fc)> {
4670   let Inst{12} = 0b1;
4671 }
4672
4673 def MVE_VPTv4s32r : MVE_VPTt2s<"s32", 0b10>;
4674 def MVE_VPTv8s16r : MVE_VPTt2s<"s16", 0b01>;
4675 def MVE_VPTv16s8r : MVE_VPTt2s<"s8", 0b00>;
4676
4677
4678 class MVE_VPTf<string suffix, bit size, dag iops, string asm, list<dag> pattern=[]>
4679   : MVE_MI<(outs ), iops, NoItinerary, !strconcat("vpt", "${Mk}", ".", suffix), asm,
4680             "", pattern> {
4681   bits<3> fc;
4682   bits<4> Mk;
4683   bits<3> Qn;
4684
4685   let Inst{31-29} = 0b111;
4686   let Inst{28} = size;
4687   let Inst{27-23} = 0b11100;
4688   let Inst{22} = Mk{3};
4689   let Inst{21-20} = 0b11;
4690   let Inst{19-17} = Qn{2-0};
4691   let Inst{16} = 0b1;
4692   let Inst{15-13} = Mk{2-0};
4693   let Inst{12} = fc{2};
4694   let Inst{11-8} = 0b1111;
4695   let Inst{7} = fc{0};
4696   let Inst{4} = 0b0;
4697
4698   let Defs = [VPR];
4699   let Predicates = [HasMVEFloat];
4700 }
4701
4702 class MVE_VPTft1<string suffix, bit size>
4703   : MVE_VPTf<suffix, size, (ins vpt_mask:$Mk, MQPR:$Qn, MQPR:$Qm, pred_basic_fp:$fc),
4704           "$fc, $Qn, $Qm"> {
4705   bits<3> fc;
4706   bits<4> Qm;
4707
4708   let Inst{6} = 0b0;
4709   let Inst{5} = Qm{3};
4710   let Inst{3-1} = Qm{2-0};
4711   let Inst{0} = fc{1};
4712 }
4713
4714 def MVE_VPTv4f32         : MVE_VPTft1<"f32", 0b0>;
4715 def MVE_VPTv8f16         : MVE_VPTft1<"f16", 0b1>;
4716
4717 class MVE_VPTft2<string suffix, bit size>
4718   : MVE_VPTf<suffix, size, (ins vpt_mask:$Mk, MQPR:$Qn, GPRwithZR:$Rm, pred_basic_fp:$fc),
4719           "$fc, $Qn, $Rm"> {
4720   bits<3> fc;
4721   bits<4> Rm;
4722
4723   let Inst{6} = 0b1;
4724   let Inst{5} = fc{1};
4725   let Inst{3-0} = Rm{3-0};
4726 }
4727
4728 def MVE_VPTv4f32r        : MVE_VPTft2<"f32", 0b0>;
4729 def MVE_VPTv8f16r        : MVE_VPTft2<"f16", 0b1>;
4730
4731 def MVE_VPST : MVE_MI<(outs ), (ins vpt_mask:$Mk), NoItinerary,
4732        !strconcat("vpst", "${Mk}"), "", "", []> {
4733   bits<4> Mk;
4734
4735   let Inst{31-23} = 0b111111100;
4736   let Inst{22} = Mk{3};
4737   let Inst{21-16} = 0b110001;
4738   let Inst{15-13} = Mk{2-0};
4739   let Inst{12-0} = 0b0111101001101;
4740   let Unpredictable{12} = 0b1;
4741   let Unpredictable{7} = 0b1;
4742   let Unpredictable{5} = 0b1;
4743
4744   let Defs = [VPR];
4745 }
4746
4747 def MVE_VPSEL : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), NoItinerary,
4748                       "vpsel", "", "$Qd, $Qn, $Qm", vpred_n, "", []> {
4749   bits<4> Qn;
4750   bits<4> Qd;
4751   bits<4> Qm;
4752
4753   let Inst{28} = 0b1;
4754   let Inst{25-23} = 0b100;
4755   let Inst{22} = Qd{3};
4756   let Inst{21-20} = 0b11;
4757   let Inst{19-17} = Qn{2-0};
4758   let Inst{16} = 0b1;
4759   let Inst{15-13} = Qd{2-0};
4760   let Inst{12-9} = 0b0111;
4761   let Inst{8} = 0b1;
4762   let Inst{7} = Qn{3};
4763   let Inst{6} = 0b0;
4764   let Inst{5} = Qm{3};
4765   let Inst{4} = 0b0;
4766   let Inst{3-1} = Qm{2-0};
4767   let Inst{0} = 0b1;
4768 }
4769
4770 foreach suffix = ["s8", "s16", "s32", "u8", "u16", "u32",
4771                   "i8", "i16", "i32",       "f16", "f32"] in
4772 def : MVEInstAlias<"vpsel${vp}." # suffix # "\t$Qd, $Qn, $Qm",
4773                    (MVE_VPSEL MQPR:$Qd, MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
4774
4775 let Predicates = [HasMVEInt] in {
4776   def : Pat<(v16i8 (vselect (v16i1 VCCR:$pred), (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))),
4777             (v16i8 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0, VCCR:$pred))>;
4778   def : Pat<(v8i16 (vselect (v8i1 VCCR:$pred), (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))),
4779             (v8i16 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0, VCCR:$pred))>;
4780   def : Pat<(v4i32 (vselect (v4i1 VCCR:$pred), (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))),
4781             (v4i32 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0, VCCR:$pred))>;
4782
4783   def : Pat<(v8f16 (vselect (v8i1 VCCR:$pred), (v8f16 MQPR:$v1), (v8f16 MQPR:$v2))),
4784             (v8f16 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0, VCCR:$pred))>;
4785   def : Pat<(v4f32 (vselect (v4i1 VCCR:$pred), (v4f32 MQPR:$v1), (v4f32 MQPR:$v2))),
4786             (v4f32 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0, VCCR:$pred))>;
4787
4788   def : Pat<(v16i8 (vselect (v16i8 MQPR:$pred), (v16i8 MQPR:$v1), (v16i8 MQPR:$v2))),
4789             (v16i8 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0,
4790                               (MVE_VCMPi8 (v16i8 MQPR:$pred), (MVE_VMOVimmi8 0), 1)))>;
4791   def : Pat<(v8i16 (vselect (v8i16 MQPR:$pred), (v8i16 MQPR:$v1), (v8i16 MQPR:$v2))),
4792             (v8i16 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0,
4793                               (MVE_VCMPi16 (v8i16 MQPR:$pred), (MVE_VMOVimmi16 0), 1)))>;
4794   def : Pat<(v4i32 (vselect (v4i32 MQPR:$pred), (v4i32 MQPR:$v1), (v4i32 MQPR:$v2))),
4795             (v4i32 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0,
4796                               (MVE_VCMPi32 (v4i32 MQPR:$pred), (MVE_VMOVimmi32 0), 1)))>;
4797
4798   def : Pat<(v8f16 (vselect (v8i16 MQPR:$pred), (v8f16 MQPR:$v1), (v8f16 MQPR:$v2))),
4799             (v8f16 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0,
4800                               (MVE_VCMPi16 (v8i16 MQPR:$pred), (MVE_VMOVimmi16 0), 1)))>;
4801   def : Pat<(v4f32 (vselect (v4i32 MQPR:$pred), (v4f32 MQPR:$v1), (v4f32 MQPR:$v2))),
4802             (v4f32 (MVE_VPSEL MQPR:$v1, MQPR:$v2, 0,
4803                               (MVE_VCMPi32 (v4i32 MQPR:$pred), (MVE_VMOVimmi32 0), 1)))>;
4804
4805   // Pred <-> Int
4806   def : Pat<(v16i8 (zext  (v16i1 VCCR:$pred))),
4807             (v16i8 (MVE_VPSEL (MVE_VMOVimmi8 1), (MVE_VMOVimmi8 0), 0, VCCR:$pred))>;
4808   def : Pat<(v8i16 (zext  (v8i1  VCCR:$pred))),
4809             (v8i16 (MVE_VPSEL (MVE_VMOVimmi16 1), (MVE_VMOVimmi16 0), 0, VCCR:$pred))>;
4810   def : Pat<(v4i32 (zext  (v4i1  VCCR:$pred))),
4811             (v4i32 (MVE_VPSEL (MVE_VMOVimmi32 1), (MVE_VMOVimmi32 0), 0, VCCR:$pred))>;
4812
4813   def : Pat<(v16i8 (sext  (v16i1 VCCR:$pred))),
4814             (v16i8 (MVE_VPSEL (MVE_VMOVimmi8 255), (MVE_VMOVimmi8 0), 0, VCCR:$pred))>;
4815   def : Pat<(v8i16 (sext  (v8i1  VCCR:$pred))),
4816             (v8i16 (MVE_VPSEL (MVE_VMOVimmi8 255), (MVE_VMOVimmi16 0), 0, VCCR:$pred))>;
4817   def : Pat<(v4i32 (sext  (v4i1  VCCR:$pred))),
4818             (v4i32 (MVE_VPSEL (MVE_VMOVimmi8 255), (MVE_VMOVimmi32 0), 0, VCCR:$pred))>;
4819
4820   def : Pat<(v16i8 (anyext  (v16i1 VCCR:$pred))),
4821             (v16i8 (MVE_VPSEL (MVE_VMOVimmi8 1), (MVE_VMOVimmi8 0), 0, VCCR:$pred))>;
4822   def : Pat<(v8i16 (anyext  (v8i1  VCCR:$pred))),
4823             (v8i16 (MVE_VPSEL (MVE_VMOVimmi16 1), (MVE_VMOVimmi16 0), 0, VCCR:$pred))>;
4824   def : Pat<(v4i32 (anyext  (v4i1  VCCR:$pred))),
4825             (v4i32 (MVE_VPSEL (MVE_VMOVimmi32 1), (MVE_VMOVimmi32 0), 0, VCCR:$pred))>;
4826
4827   def : Pat<(v16i1 (trunc (v16i8 MQPR:$v1))),
4828             (v16i1 (MVE_VCMPi32r (v16i8 MQPR:$v1), ZR, 1))>;
4829   def : Pat<(v8i1 (trunc (v8i16  MQPR:$v1))),
4830             (v8i1 (MVE_VCMPi32r (v8i16 MQPR:$v1), ZR, 1))>;
4831   def : Pat<(v4i1 (trunc (v4i32  MQPR:$v1))),
4832             (v4i1 (MVE_VCMPi32r (v4i32 MQPR:$v1), ZR, 1))>;
4833 }
4834
4835 let Predicates = [HasMVEFloat] in {
4836   // Pred <-> Float
4837   // 112 is 1.0 in float
4838   def : Pat<(v4f32 (uint_to_fp (v4i1 VCCR:$pred))),
4839             (v4f32 (MVE_VPSEL (v4f32 (MVE_VMOVimmf32 112)), (v4f32 (MVE_VMOVimmi32 0)), 0, VCCR:$pred))>;
4840   // 2620 in 1.0 in half
4841   def : Pat<(v8f16 (uint_to_fp (v8i1 VCCR:$pred))),
4842             (v8f16 (MVE_VPSEL (v8f16 (MVE_VMOVimmi16 2620)), (v8f16 (MVE_VMOVimmi16 0)), 0, VCCR:$pred))>;
4843   // 240 is -1.0 in float
4844   def : Pat<(v4f32 (sint_to_fp (v4i1 VCCR:$pred))),
4845             (v4f32 (MVE_VPSEL (v4f32 (MVE_VMOVimmf32 240)), (v4f32 (MVE_VMOVimmi32 0)), 0, VCCR:$pred))>;
4846   // 2748 is -1.0 in half
4847   def : Pat<(v8f16 (sint_to_fp (v8i1 VCCR:$pred))),
4848             (v8f16 (MVE_VPSEL (v8f16 (MVE_VMOVimmi16 2748)), (v8f16 (MVE_VMOVimmi16 0)), 0, VCCR:$pred))>;
4849
4850   def : Pat<(v4i1 (fp_to_uint (v4f32 MQPR:$v1))),
4851             (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), ZR, 1))>;
4852   def : Pat<(v8i1 (fp_to_uint (v8f16 MQPR:$v1))),
4853             (v8i1 (MVE_VCMPf16r (v8f16 MQPR:$v1), ZR, 1))>;
4854   def : Pat<(v4i1 (fp_to_sint (v4f32 MQPR:$v1))),
4855             (v4i1 (MVE_VCMPf32r (v4f32 MQPR:$v1), ZR, 1))>;
4856   def : Pat<(v8i1 (fp_to_sint (v8f16 MQPR:$v1))),
4857             (v8i1 (MVE_VCMPf16r (v8f16 MQPR:$v1), ZR, 1))>;
4858 }
4859
4860 def MVE_VPNOT : MVE_p<(outs VCCR:$P0), (ins VCCR:$P0_in), NoItinerary,
4861                       "vpnot", "", "", vpred_n, "", []> {
4862   let Inst{31-0} = 0b11111110001100010000111101001101;
4863   let Unpredictable{19-17} = 0b111;
4864   let Unpredictable{12} = 0b1;
4865   let Unpredictable{7} = 0b1;
4866   let Unpredictable{5} = 0b1;
4867
4868   let Constraints = "";
4869   let DecoderMethod = "DecodeMVEVPNOT";
4870 }
4871
4872 let Predicates = [HasMVEInt] in {
4873   def : Pat<(v4i1 (xor (v4i1 VCCR:$pred), (v4i1 (predicate_cast (i32 65535))))),
4874             (v4i1 (MVE_VPNOT (v4i1 VCCR:$pred)))>;
4875   def : Pat<(v8i1 (xor (v8i1 VCCR:$pred), (v8i1 (predicate_cast (i32 65535))))),
4876             (v8i1 (MVE_VPNOT (v8i1 VCCR:$pred)))>;
4877   def : Pat<(v16i1 (xor (v16i1 VCCR:$pred), (v16i1 (predicate_cast (i32 65535))))),
4878             (v16i1 (MVE_VPNOT (v16i1 VCCR:$pred)))>;
4879 }
4880
4881
4882 class MVE_loltp_start<dag iops, string asm, string ops, bits<2> size>
4883   : t2LOL<(outs GPRlr:$LR), iops, asm, ops> {
4884   bits<4> Rn;
4885   let Predicates = [HasMVEInt];
4886   let Inst{22} = 0b0;
4887   let Inst{21-20} = size;
4888   let Inst{19-16} = Rn{3-0};
4889   let Inst{12} = 0b0;
4890 }
4891
4892 class MVE_DLSTP<string asm, bits<2> size>
4893   : MVE_loltp_start<(ins rGPR:$Rn), asm, "$LR, $Rn", size> {
4894   let Inst{13} = 0b1;
4895   let Inst{11-1} = 0b00000000000;
4896   let Unpredictable{10-1} = 0b1111111111;
4897 }
4898
4899 class MVE_WLSTP<string asm, bits<2> size>
4900   : MVE_loltp_start<(ins rGPR:$Rn, wlslabel_u11:$label),
4901                     asm, "$LR, $Rn, $label", size> {
4902   bits<11> label;
4903   let Inst{13} = 0b0;
4904   let Inst{11} = label{0};
4905   let Inst{10-1} = label{10-1};
4906 }
4907
4908 def MVE_DLSTP_8  : MVE_DLSTP<"dlstp.8",  0b00>;
4909 def MVE_DLSTP_16 : MVE_DLSTP<"dlstp.16", 0b01>;
4910 def MVE_DLSTP_32 : MVE_DLSTP<"dlstp.32", 0b10>;
4911 def MVE_DLSTP_64 : MVE_DLSTP<"dlstp.64", 0b11>;
4912
4913 def MVE_WLSTP_8  : MVE_WLSTP<"wlstp.8",  0b00>;
4914 def MVE_WLSTP_16 : MVE_WLSTP<"wlstp.16", 0b01>;
4915 def MVE_WLSTP_32 : MVE_WLSTP<"wlstp.32", 0b10>;
4916 def MVE_WLSTP_64 : MVE_WLSTP<"wlstp.64", 0b11>;
4917
4918 class MVE_loltp_end<dag oops, dag iops, string asm, string ops>
4919   : t2LOL<oops, iops, asm, ops> {
4920   let Predicates = [HasMVEInt];
4921   let Inst{22-21} = 0b00;
4922   let Inst{19-16} = 0b1111;
4923   let Inst{12} = 0b0;
4924 }
4925
4926 def MVE_LETP : MVE_loltp_end<(outs GPRlr:$LRout),
4927                              (ins GPRlr:$LRin, lelabel_u11:$label),
4928                              "letp", "$LRin, $label"> {
4929   bits<11> label;
4930   let Inst{20} = 0b1;
4931   let Inst{13} = 0b0;
4932   let Inst{11} = label{0};
4933   let Inst{10-1} = label{10-1};
4934 }
4935
4936 def MVE_LCTP : MVE_loltp_end<(outs), (ins pred:$p), "lctp${p}", ""> {
4937   let Inst{20} = 0b0;
4938   let Inst{13} = 0b1;
4939   let Inst{11-1} = 0b00000000000;
4940   let Unpredictable{21-20} = 0b11;
4941   let Unpredictable{11-1} = 0b11111111111;
4942 }
4943
4944
4945 //===----------------------------------------------------------------------===//
4946 // Patterns
4947 //===----------------------------------------------------------------------===//
4948
4949 class MVE_vector_store_typed<ValueType Ty, Instruction RegImmInst,
4950                              PatFrag StoreKind, int shift>
4951   : Pat<(StoreKind (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr),
4952         (RegImmInst (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr)>;
4953 class MVE_vector_maskedstore_typed<ValueType Ty, Instruction RegImmInst,
4954                                    PatFrag StoreKind, int shift>
4955   : Pat<(StoreKind (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr, VCCR:$pred),
4956         (RegImmInst (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr, (i32 1), VCCR:$pred)>;
4957
4958 multiclass MVE_vector_store<Instruction RegImmInst, PatFrag StoreKind,
4959                             int shift> {
4960   def : MVE_vector_store_typed<v16i8, RegImmInst, StoreKind, shift>;
4961   def : MVE_vector_store_typed<v8i16, RegImmInst, StoreKind, shift>;
4962   def : MVE_vector_store_typed<v8f16, RegImmInst, StoreKind, shift>;
4963   def : MVE_vector_store_typed<v4i32, RegImmInst, StoreKind, shift>;
4964   def : MVE_vector_store_typed<v4f32, RegImmInst, StoreKind, shift>;
4965   def : MVE_vector_store_typed<v2i64, RegImmInst, StoreKind, shift>;
4966   def : MVE_vector_store_typed<v2f64, RegImmInst, StoreKind, shift>;
4967 }
4968
4969 class MVE_vector_load_typed<ValueType Ty, Instruction RegImmInst,
4970                             PatFrag LoadKind, int shift>
4971   : Pat<(Ty (LoadKind t2addrmode_imm7<shift>:$addr)),
4972         (Ty (RegImmInst t2addrmode_imm7<shift>:$addr))>;
4973 class MVE_vector_maskedload_typed<ValueType Ty, Instruction RegImmInst,
4974                                   PatFrag LoadKind, int shift>
4975   : Pat<(Ty (LoadKind t2addrmode_imm7<shift>:$addr, VCCR:$pred, (Ty NEONimmAllZerosV))),
4976         (Ty (RegImmInst t2addrmode_imm7<shift>:$addr, (i32 1), VCCR:$pred))>;
4977
4978 multiclass MVE_vector_load<Instruction RegImmInst, PatFrag LoadKind,
4979                            int shift> {
4980   def : MVE_vector_load_typed<v16i8, RegImmInst, LoadKind, shift>;
4981   def : MVE_vector_load_typed<v8i16, RegImmInst, LoadKind, shift>;
4982   def : MVE_vector_load_typed<v8f16, RegImmInst, LoadKind, shift>;
4983   def : MVE_vector_load_typed<v4i32, RegImmInst, LoadKind, shift>;
4984   def : MVE_vector_load_typed<v4f32, RegImmInst, LoadKind, shift>;
4985   def : MVE_vector_load_typed<v2i64, RegImmInst, LoadKind, shift>;
4986   def : MVE_vector_load_typed<v2f64, RegImmInst, LoadKind, shift>;
4987 }
4988
4989 class MVE_vector_offset_store_typed<ValueType Ty, Instruction Opcode,
4990                                     PatFrag StoreKind, int shift>
4991   : Pat<(StoreKind (Ty MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<shift>:$addr),
4992         (Opcode MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<shift>:$addr)>;
4993
4994 multiclass MVE_vector_offset_store<Instruction RegImmInst, PatFrag StoreKind,
4995                                    int shift> {
4996   def : MVE_vector_offset_store_typed<v16i8, RegImmInst, StoreKind, shift>;
4997   def : MVE_vector_offset_store_typed<v8i16, RegImmInst, StoreKind, shift>;
4998   def : MVE_vector_offset_store_typed<v8f16, RegImmInst, StoreKind, shift>;
4999   def : MVE_vector_offset_store_typed<v4i32, RegImmInst, StoreKind, shift>;
5000   def : MVE_vector_offset_store_typed<v4f32, RegImmInst, StoreKind, shift>;
5001   def : MVE_vector_offset_store_typed<v2i64, RegImmInst, StoreKind, shift>;
5002   def : MVE_vector_offset_store_typed<v2f64, RegImmInst, StoreKind, shift>;
5003 }
5004
5005 def aligned32_pre_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
5006                                   (pre_store node:$val, node:$ptr, node:$offset), [{
5007   return cast<StoreSDNode>(N)->getAlignment() >= 4;
5008 }]>;
5009 def aligned32_post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
5010                                    (post_store node:$val, node:$ptr, node:$offset), [{
5011   return cast<StoreSDNode>(N)->getAlignment() >= 4;
5012 }]>;
5013 def aligned16_pre_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
5014                                   (pre_store node:$val, node:$ptr, node:$offset), [{
5015   return cast<StoreSDNode>(N)->getAlignment() >= 2;
5016 }]>;
5017 def aligned16_post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
5018                                    (post_store node:$val, node:$ptr, node:$offset), [{
5019   return cast<StoreSDNode>(N)->getAlignment() >= 2;
5020 }]>;
5021
5022 def alignedmaskedload32 : PatFrag<(ops node:$ptr, node:$pred, node:$passthru),
5023                                   (masked_ld node:$ptr, node:$pred, node:$passthru), [{
5024   return cast<MaskedLoadSDNode>(N)->getAlignment() >= 4;
5025 }]>;
5026 def alignedmaskedload16 : PatFrag<(ops node:$ptr, node:$pred, node:$passthru),
5027                                   (masked_ld node:$ptr, node:$pred, node:$passthru), [{
5028   return cast<MaskedLoadSDNode>(N)->getAlignment() >= 2;
5029 }]>;
5030 def maskedload : PatFrag<(ops node:$ptr, node:$pred, node:$passthru),
5031                          (masked_ld node:$ptr, node:$pred, node:$passthru)>;
5032
5033 def alignedmaskedstore32 : PatFrag<(ops node:$val, node:$ptr, node:$pred),
5034                                    (masked_st node:$val, node:$ptr, node:$pred), [{
5035   return cast<MaskedStoreSDNode>(N)->getAlignment() >= 4;
5036 }]>;
5037 def alignedmaskedstore16 : PatFrag<(ops node:$val, node:$ptr, node:$pred),
5038                                    (masked_st node:$val, node:$ptr, node:$pred), [{
5039   return cast<MaskedStoreSDNode>(N)->getAlignment() >= 2;
5040 }]>;
5041 def maskedstore : PatFrag<(ops node:$val, node:$ptr, node:$pred),
5042                           (masked_st node:$val, node:$ptr, node:$pred)>;
5043
5044 let Predicates = [HasMVEInt, IsLE] in {
5045   // Stores
5046   defm : MVE_vector_store<MVE_VSTRBU8, byte_alignedstore, 0>;
5047   defm : MVE_vector_store<MVE_VSTRHU16, hword_alignedstore, 1>;
5048   defm : MVE_vector_store<MVE_VSTRWU32, alignedstore32, 2>;
5049
5050   // Loads
5051   defm : MVE_vector_load<MVE_VLDRBU8, byte_alignedload, 0>;
5052   defm : MVE_vector_load<MVE_VLDRHU16, hword_alignedload, 1>;
5053   defm : MVE_vector_load<MVE_VLDRWU32, alignedload32, 2>;
5054
5055   // Pre/post inc stores
5056   defm : MVE_vector_offset_store<MVE_VSTRBU8_pre, pre_store, 0>;
5057   defm : MVE_vector_offset_store<MVE_VSTRBU8_post, post_store, 0>;
5058   defm : MVE_vector_offset_store<MVE_VSTRHU16_pre, aligned16_pre_store, 1>;
5059   defm : MVE_vector_offset_store<MVE_VSTRHU16_post, aligned16_post_store, 1>;
5060   defm : MVE_vector_offset_store<MVE_VSTRWU32_pre, aligned32_pre_store, 2>;
5061   defm : MVE_vector_offset_store<MVE_VSTRWU32_post, aligned32_post_store, 2>;
5062
5063   // Unaligned masked stores (aligned are below)
5064   def : Pat<(maskedstore (v4i32 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5065             (MVE_VSTRBU8 MQPR:$val, t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5066   def : Pat<(maskedstore (v4f32 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5067             (MVE_VSTRBU8 MQPR:$val, t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5068   def : Pat<(maskedstore (v8i16 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5069             (MVE_VSTRBU8 MQPR:$val, t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5070   def : Pat<(maskedstore (v8f16 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5071             (MVE_VSTRBU8 MQPR:$val, t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5072
5073   // Unaligned masked loads
5074   def : Pat<(v4i32 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v4i32 NEONimmAllZerosV))),
5075             (v4i32 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred))>;
5076   def : Pat<(v4f32 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v4f32 NEONimmAllZerosV))),
5077             (v4f32 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred))>;
5078   def : Pat<(v8i16 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v8i16 NEONimmAllZerosV))),
5079             (v8i16 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred))>;
5080   def : Pat<(v8f16 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v8f16 NEONimmAllZerosV))),
5081             (v8f16 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred))>;
5082 }
5083
5084 let Predicates = [HasMVEInt, IsBE] in {
5085   // Aligned Stores
5086   def : MVE_vector_store_typed<v16i8, MVE_VSTRBU8, store, 0>;
5087   def : MVE_vector_store_typed<v8i16, MVE_VSTRHU16, alignedstore16, 1>;
5088   def : MVE_vector_store_typed<v8f16, MVE_VSTRHU16, alignedstore16, 1>;
5089   def : MVE_vector_store_typed<v4i32, MVE_VSTRWU32, alignedstore32, 2>;
5090   def : MVE_vector_store_typed<v4f32, MVE_VSTRWU32, alignedstore32, 2>;
5091
5092   // Aligned Loads
5093   def : MVE_vector_load_typed<v16i8, MVE_VLDRBU8, load, 0>;
5094   def : MVE_vector_load_typed<v8i16, MVE_VLDRHU16, alignedload16, 1>;
5095   def : MVE_vector_load_typed<v8f16, MVE_VLDRHU16, alignedload16, 1>;
5096   def : MVE_vector_load_typed<v4i32, MVE_VLDRWU32, alignedload32, 2>;
5097   def : MVE_vector_load_typed<v4f32, MVE_VLDRWU32, alignedload32, 2>;
5098
5099   // Other unaligned loads/stores need to go though a VREV
5100   def : Pat<(v2f64 (load t2addrmode_imm7<0>:$addr)),
5101             (v2f64 (MVE_VREV64_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5102   def : Pat<(v2i64 (load t2addrmode_imm7<0>:$addr)),
5103             (v2i64 (MVE_VREV64_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5104   def : Pat<(v4i32 (load t2addrmode_imm7<0>:$addr)),
5105             (v4i32 (MVE_VREV32_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5106   def : Pat<(v4f32 (load t2addrmode_imm7<0>:$addr)),
5107             (v4f32 (MVE_VREV32_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5108   def : Pat<(v8i16 (load t2addrmode_imm7<0>:$addr)),
5109             (v8i16 (MVE_VREV16_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5110   def : Pat<(v8f16 (load t2addrmode_imm7<0>:$addr)),
5111             (v8f16 (MVE_VREV16_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr)))>;
5112   def : Pat<(store (v2f64 MQPR:$val), t2addrmode_imm7<0>:$addr),
5113             (MVE_VSTRBU8 (MVE_VREV64_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5114   def : Pat<(store (v2i64 MQPR:$val), t2addrmode_imm7<0>:$addr),
5115             (MVE_VSTRBU8 (MVE_VREV64_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5116   def : Pat<(store (v4i32 MQPR:$val), t2addrmode_imm7<0>:$addr),
5117             (MVE_VSTRBU8 (MVE_VREV32_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5118   def : Pat<(store (v4f32 MQPR:$val), t2addrmode_imm7<0>:$addr),
5119             (MVE_VSTRBU8 (MVE_VREV32_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5120   def : Pat<(store (v8i16 MQPR:$val), t2addrmode_imm7<0>:$addr),
5121             (MVE_VSTRBU8 (MVE_VREV16_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5122   def : Pat<(store (v8f16 MQPR:$val), t2addrmode_imm7<0>:$addr),
5123             (MVE_VSTRBU8 (MVE_VREV16_8 MQPR:$val), t2addrmode_imm7<0>:$addr)>;
5124
5125   // Pre/Post inc stores
5126   def : MVE_vector_offset_store_typed<v16i8, MVE_VSTRBU8_pre, pre_store, 0>;
5127   def : MVE_vector_offset_store_typed<v16i8, MVE_VSTRBU8_post, post_store, 0>;
5128   def : MVE_vector_offset_store_typed<v8i16, MVE_VSTRHU16_pre, aligned16_pre_store, 1>;
5129   def : MVE_vector_offset_store_typed<v8i16, MVE_VSTRHU16_post, aligned16_post_store, 1>;
5130   def : MVE_vector_offset_store_typed<v8f16, MVE_VSTRHU16_pre, aligned16_pre_store, 1>;
5131   def : MVE_vector_offset_store_typed<v8f16, MVE_VSTRHU16_post, aligned16_post_store, 1>;
5132   def : MVE_vector_offset_store_typed<v4i32, MVE_VSTRWU32_pre, aligned32_pre_store, 2>;
5133   def : MVE_vector_offset_store_typed<v4i32, MVE_VSTRWU32_post, aligned32_post_store, 2>;
5134   def : MVE_vector_offset_store_typed<v4f32, MVE_VSTRWU32_pre, aligned32_pre_store, 2>;
5135   def : MVE_vector_offset_store_typed<v4f32, MVE_VSTRWU32_post, aligned32_post_store, 2>;
5136
5137   // Unaligned masked stores (aligned are below)
5138   def : Pat<(maskedstore (v4i32 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5139             (MVE_VSTRBU8 (MVE_VREV32_8 MQPR:$val), t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5140   def : Pat<(maskedstore (v4f32 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5141             (MVE_VSTRBU8 (MVE_VREV32_8 MQPR:$val), t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5142   def : Pat<(maskedstore (v8i16 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5143             (MVE_VSTRBU8 (MVE_VREV16_8 MQPR:$val), t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5144   def : Pat<(maskedstore (v8f16 MQPR:$val), t2addrmode_imm7<0>:$addr, VCCR:$pred),
5145             (MVE_VSTRBU8 (MVE_VREV16_8 MQPR:$val), t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)>;
5146   // Unaligned masked loads
5147   def : Pat<(v4i32 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v4i32 NEONimmAllZerosV))),
5148             (v4i32 (MVE_VREV32_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)))>;
5149   def : Pat<(v4f32 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v4f32 NEONimmAllZerosV))),
5150             (v4f32 (MVE_VREV32_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)))>;
5151   def : Pat<(v8i16 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v8i16 NEONimmAllZerosV))),
5152             (v8i16 (MVE_VREV16_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)))>;
5153   def : Pat<(v8f16 (maskedload t2addrmode_imm7<0>:$addr, VCCR:$pred, (v8f16 NEONimmAllZerosV))),
5154             (v8f16 (MVE_VREV16_8 (MVE_VLDRBU8 t2addrmode_imm7<0>:$addr, (i32 1), VCCR:$pred)))>;
5155 }
5156
5157 let Predicates = [HasMVEInt] in {
5158   // Aligned masked store, shared between LE and BE
5159   def : MVE_vector_maskedstore_typed<v16i8, MVE_VSTRBU8, maskedstore, 0>;
5160   def : MVE_vector_maskedstore_typed<v8i16, MVE_VSTRHU16, alignedmaskedstore16, 1>;
5161   def : MVE_vector_maskedstore_typed<v8f16, MVE_VSTRHU16, alignedmaskedstore16, 1>;
5162   def : MVE_vector_maskedstore_typed<v4i32, MVE_VSTRWU32, alignedmaskedstore32, 2>;
5163   def : MVE_vector_maskedstore_typed<v4f32, MVE_VSTRWU32, alignedmaskedstore32, 2>;
5164   // Aligned masked loads
5165   def : MVE_vector_maskedload_typed<v16i8, MVE_VLDRBU8, maskedload, 0>;
5166   def : MVE_vector_maskedload_typed<v8i16, MVE_VLDRHU16, alignedmaskedload16, 1>;
5167   def : MVE_vector_maskedload_typed<v8f16, MVE_VLDRHU16, alignedmaskedload16, 1>;
5168   def : MVE_vector_maskedload_typed<v4i32, MVE_VLDRWU32, alignedmaskedload32, 2>;
5169   def : MVE_vector_maskedload_typed<v4f32, MVE_VLDRWU32, alignedmaskedload32, 2>;
5170 }
5171
5172 // Widening/Narrowing Loads/Stores
5173
5174 let MinAlignment = 2 in {
5175   def truncstorevi16_align2 : PatFrag<(ops node:$val, node:$ptr),
5176                                       (truncstorevi16 node:$val, node:$ptr)>;
5177   def post_truncstvi16_align2 : PatFrag<(ops node:$val, node:$base, node:$offset),
5178                                         (post_truncstvi16 node:$val, node:$base, node:$offset)>;
5179   def pre_truncstvi16_align2 : PatFrag<(ops node:$val, node:$base, node:$offset),
5180                                        (pre_truncstvi16 node:$val, node:$base, node:$offset)>;
5181 }
5182
5183 let Predicates = [HasMVEInt] in {
5184   def : Pat<(truncstorevi8 (v8i16 MQPR:$val), taddrmode_imm7<0>:$addr),
5185             (MVE_VSTRB16 MQPR:$val, taddrmode_imm7<0>:$addr)>;
5186   def : Pat<(truncstorevi8 (v4i32 MQPR:$val), taddrmode_imm7<0>:$addr),
5187             (MVE_VSTRB32 MQPR:$val, taddrmode_imm7<0>:$addr)>;
5188   def : Pat<(truncstorevi16_align2 (v4i32 MQPR:$val), taddrmode_imm7<1>:$addr),
5189             (MVE_VSTRH32 MQPR:$val, taddrmode_imm7<1>:$addr)>;
5190
5191   def : Pat<(post_truncstvi8 (v8i16 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<0>:$addr),
5192             (MVE_VSTRB16_post MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<0>:$addr)>;
5193   def : Pat<(post_truncstvi8 (v4i32 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<0>:$addr),
5194             (MVE_VSTRB32_post MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<0>:$addr)>;
5195   def : Pat<(post_truncstvi16_align2 (v4i32 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<1>:$addr),
5196             (MVE_VSTRH32_post MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<1>:$addr)>;
5197
5198   def : Pat<(pre_truncstvi8 (v8i16 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<0>:$addr),
5199             (MVE_VSTRB16_pre MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<0>:$addr)>;
5200   def : Pat<(pre_truncstvi8 (v4i32 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<0>:$addr),
5201             (MVE_VSTRB32_pre MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<0>:$addr)>;
5202   def : Pat<(pre_truncstvi16_align2 (v4i32 MQPR:$Rt), tGPR:$Rn, t2am_imm7_offset<1>:$addr),
5203             (MVE_VSTRH32_pre MQPR:$Rt, tGPR:$Rn, t2am_imm7_offset<1>:$addr)>;
5204 }
5205
5206
5207 let MinAlignment = 2 in {
5208   def extloadvi16_align2  : PatFrag<(ops node:$ptr), (extloadvi16 node:$ptr)>;
5209   def sextloadvi16_align2 : PatFrag<(ops node:$ptr), (sextloadvi16 node:$ptr)>;
5210   def zextloadvi16_align2 : PatFrag<(ops node:$ptr), (zextloadvi16 node:$ptr)>;
5211 }
5212
5213 multiclass MVEExtLoad<string DestLanes, string DestElemBits,
5214                       string SrcElemBits, string SrcElemType,
5215                       string Align, Operand am> {
5216   def _Any : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
5217                    (!cast<PatFrag>("extloadvi"  # SrcElemBits # Align) am:$addr)),
5218                  (!cast<Instruction>("MVE_VLDR" # SrcElemType # "U" # DestElemBits)
5219                    am:$addr)>;
5220   def _Z   : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
5221                    (!cast<PatFrag>("zextloadvi"  # SrcElemBits # Align) am:$addr)),
5222                  (!cast<Instruction>("MVE_VLDR" # SrcElemType # "U" # DestElemBits)
5223                    am:$addr)>;
5224   def _S   : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
5225                    (!cast<PatFrag>("sextloadvi"  # SrcElemBits # Align) am:$addr)),
5226                  (!cast<Instruction>("MVE_VLDR" # SrcElemType # "S" # DestElemBits)
5227                    am:$addr)>;
5228 }
5229
5230 let Predicates = [HasMVEInt] in {
5231   defm : MVEExtLoad<"4", "32", "8",  "B", "", taddrmode_imm7<0>>;
5232   defm : MVEExtLoad<"8", "16", "8",  "B", "", taddrmode_imm7<0>>;
5233   defm : MVEExtLoad<"4", "32", "16", "H", "_align2", taddrmode_imm7<1>>;
5234 }
5235
5236
5237 // Bit convert patterns
5238
5239 let Predicates = [HasMVEInt] in {
5240   def : Pat<(v2f64 (bitconvert (v2i64 MQPR:$src))), (v2f64 MQPR:$src)>;
5241   def : Pat<(v2i64 (bitconvert (v2f64 MQPR:$src))), (v2i64 MQPR:$src)>;
5242
5243   def : Pat<(v4i32 (bitconvert (v4f32 MQPR:$src))), (v4i32 MQPR:$src)>;
5244   def : Pat<(v4f32 (bitconvert (v4i32 MQPR:$src))), (v4f32 MQPR:$src)>;
5245
5246   def : Pat<(v8i16 (bitconvert (v8f16 MQPR:$src))), (v8i16  MQPR:$src)>;
5247   def : Pat<(v8f16 (bitconvert (v8i16 MQPR:$src))), (v8f16  MQPR:$src)>;
5248 }
5249
5250 let Predicates = [IsLE,HasMVEInt] in {
5251   def : Pat<(v2f64 (bitconvert (v4f32 MQPR:$src))), (v2f64 MQPR:$src)>;
5252   def : Pat<(v2f64 (bitconvert (v4i32 MQPR:$src))), (v2f64 MQPR:$src)>;
5253   def : Pat<(v2f64 (bitconvert (v8f16 MQPR:$src))), (v2f64 MQPR:$src)>;
5254   def : Pat<(v2f64 (bitconvert (v8i16 MQPR:$src))), (v2f64 MQPR:$src)>;
5255   def : Pat<(v2f64 (bitconvert (v16i8 MQPR:$src))), (v2f64 MQPR:$src)>;
5256
5257   def : Pat<(v2i64 (bitconvert (v4f32 MQPR:$src))), (v2i64 MQPR:$src)>;
5258   def : Pat<(v2i64 (bitconvert (v4i32 MQPR:$src))), (v2i64 MQPR:$src)>;
5259   def : Pat<(v2i64 (bitconvert (v8f16 MQPR:$src))), (v2i64 MQPR:$src)>;
5260   def : Pat<(v2i64 (bitconvert (v8i16 MQPR:$src))), (v2i64 MQPR:$src)>;
5261   def : Pat<(v2i64 (bitconvert (v16i8 MQPR:$src))), (v2i64 MQPR:$src)>;
5262
5263   def : Pat<(v4f32 (bitconvert (v2f64 MQPR:$src))), (v4f32 MQPR:$src)>;
5264   def : Pat<(v4f32 (bitconvert (v2i64 MQPR:$src))), (v4f32 MQPR:$src)>;
5265   def : Pat<(v4f32 (bitconvert (v8f16 MQPR:$src))), (v4f32 MQPR:$src)>;
5266   def : Pat<(v4f32 (bitconvert (v8i16 MQPR:$src))), (v4f32 MQPR:$src)>;
5267   def : Pat<(v4f32 (bitconvert (v16i8 MQPR:$src))), (v4f32 MQPR:$src)>;
5268
5269   def : Pat<(v4i32 (bitconvert (v2f64 MQPR:$src))), (v4i32 MQPR:$src)>;
5270   def : Pat<(v4i32 (bitconvert (v2i64 MQPR:$src))), (v4i32 MQPR:$src)>;
5271   def : Pat<(v4i32 (bitconvert (v8f16 MQPR:$src))), (v4i32 MQPR:$src)>;
5272   def : Pat<(v4i32 (bitconvert (v8i16 MQPR:$src))), (v4i32 MQPR:$src)>;
5273   def : Pat<(v4i32 (bitconvert (v16i8 MQPR:$src))), (v4i32 MQPR:$src)>;
5274
5275   def : Pat<(v8f16 (bitconvert (v2f64 MQPR:$src))), (v8f16 MQPR:$src)>;
5276   def : Pat<(v8f16 (bitconvert (v2i64 MQPR:$src))), (v8f16 MQPR:$src)>;
5277   def : Pat<(v8f16 (bitconvert (v4f32 MQPR:$src))), (v8f16 MQPR:$src)>;
5278   def : Pat<(v8f16 (bitconvert (v4i32 MQPR:$src))), (v8f16 MQPR:$src)>;
5279   def : Pat<(v8f16 (bitconvert (v16i8 MQPR:$src))), (v8f16 MQPR:$src)>;
5280
5281   def : Pat<(v8i16 (bitconvert (v2f64 MQPR:$src))), (v8i16 MQPR:$src)>;
5282   def : Pat<(v8i16 (bitconvert (v2i64 MQPR:$src))), (v8i16 MQPR:$src)>;
5283   def : Pat<(v8i16 (bitconvert (v4f32 MQPR:$src))), (v8i16 MQPR:$src)>;
5284   def : Pat<(v8i16 (bitconvert (v4i32 MQPR:$src))), (v8i16 MQPR:$src)>;
5285   def : Pat<(v8i16 (bitconvert (v16i8 MQPR:$src))), (v8i16 MQPR:$src)>;
5286
5287   def : Pat<(v16i8 (bitconvert (v2f64 MQPR:$src))), (v16i8 MQPR:$src)>;
5288   def : Pat<(v16i8 (bitconvert (v2i64 MQPR:$src))), (v16i8 MQPR:$src)>;
5289   def : Pat<(v16i8 (bitconvert (v4f32 MQPR:$src))), (v16i8 MQPR:$src)>;
5290   def : Pat<(v16i8 (bitconvert (v4i32 MQPR:$src))), (v16i8 MQPR:$src)>;
5291   def : Pat<(v16i8 (bitconvert (v8f16 MQPR:$src))), (v16i8 MQPR:$src)>;
5292   def : Pat<(v16i8 (bitconvert (v8i16 MQPR:$src))), (v16i8 MQPR:$src)>;
5293 }
5294
5295 let Predicates = [IsBE,HasMVEInt] in {
5296   def : Pat<(v2f64 (bitconvert (v4f32 MQPR:$src))), (v2f64 (MVE_VREV64_32 MQPR:$src))>;
5297   def : Pat<(v2f64 (bitconvert (v4i32 MQPR:$src))), (v2f64 (MVE_VREV64_32 MQPR:$src))>;
5298   def : Pat<(v2f64 (bitconvert (v8f16 MQPR:$src))), (v2f64 (MVE_VREV64_16 MQPR:$src))>;
5299   def : Pat<(v2f64 (bitconvert (v8i16 MQPR:$src))), (v2f64 (MVE_VREV64_16 MQPR:$src))>;
5300   def : Pat<(v2f64 (bitconvert (v16i8 MQPR:$src))), (v2f64 (MVE_VREV64_8 MQPR:$src))>;
5301
5302   def : Pat<(v2i64 (bitconvert (v4f32 MQPR:$src))), (v2i64 (MVE_VREV64_32 MQPR:$src))>;
5303   def : Pat<(v2i64 (bitconvert (v4i32 MQPR:$src))), (v2i64 (MVE_VREV64_32 MQPR:$src))>;
5304   def : Pat<(v2i64 (bitconvert (v8f16 MQPR:$src))), (v2i64 (MVE_VREV64_16 MQPR:$src))>;
5305   def : Pat<(v2i64 (bitconvert (v8i16 MQPR:$src))), (v2i64 (MVE_VREV64_16 MQPR:$src))>;
5306   def : Pat<(v2i64 (bitconvert (v16i8 MQPR:$src))), (v2i64 (MVE_VREV64_8 MQPR:$src))>;
5307
5308   def : Pat<(v4f32 (bitconvert (v2f64 MQPR:$src))), (v4f32 (MVE_VREV64_32 MQPR:$src))>;
5309   def : Pat<(v4f32 (bitconvert (v2i64 MQPR:$src))), (v4f32 (MVE_VREV64_32 MQPR:$src))>;
5310   def : Pat<(v4f32 (bitconvert (v8f16 MQPR:$src))), (v4f32 (MVE_VREV32_16 MQPR:$src))>;
5311   def : Pat<(v4f32 (bitconvert (v8i16 MQPR:$src))), (v4f32 (MVE_VREV32_16 MQPR:$src))>;
5312   def : Pat<(v4f32 (bitconvert (v16i8 MQPR:$src))), (v4f32 (MVE_VREV32_8 MQPR:$src))>;
5313
5314   def : Pat<(v4i32 (bitconvert (v2f64 MQPR:$src))), (v4i32 (MVE_VREV64_32 MQPR:$src))>;
5315   def : Pat<(v4i32 (bitconvert (v2i64 MQPR:$src))), (v4i32 (MVE_VREV64_32 MQPR:$src))>;
5316   def : Pat<(v4i32 (bitconvert (v8f16 MQPR:$src))), (v4i32 (MVE_VREV32_16 MQPR:$src))>;
5317   def : Pat<(v4i32 (bitconvert (v8i16 MQPR:$src))), (v4i32 (MVE_VREV32_16 MQPR:$src))>;
5318   def : Pat<(v4i32 (bitconvert (v16i8 MQPR:$src))), (v4i32 (MVE_VREV32_8 MQPR:$src))>;
5319
5320   def : Pat<(v8f16 (bitconvert (v2f64 MQPR:$src))), (v8f16 (MVE_VREV64_16 MQPR:$src))>;
5321   def : Pat<(v8f16 (bitconvert (v2i64 MQPR:$src))), (v8f16 (MVE_VREV64_16 MQPR:$src))>;
5322   def : Pat<(v8f16 (bitconvert (v4f32 MQPR:$src))), (v8f16 (MVE_VREV32_16 MQPR:$src))>;
5323   def : Pat<(v8f16 (bitconvert (v4i32 MQPR:$src))), (v8f16 (MVE_VREV32_16 MQPR:$src))>;
5324   def : Pat<(v8f16 (bitconvert (v16i8 MQPR:$src))), (v8f16 (MVE_VREV16_8 MQPR:$src))>;
5325
5326   def : Pat<(v8i16 (bitconvert (v2f64 MQPR:$src))), (v8i16 (MVE_VREV64_16 MQPR:$src))>;
5327   def : Pat<(v8i16 (bitconvert (v2i64 MQPR:$src))), (v8i16 (MVE_VREV64_16 MQPR:$src))>;
5328   def : Pat<(v8i16 (bitconvert (v4f32 MQPR:$src))), (v8i16 (MVE_VREV32_16 MQPR:$src))>;
5329   def : Pat<(v8i16 (bitconvert (v4i32 MQPR:$src))), (v8i16 (MVE_VREV32_16 MQPR:$src))>;
5330   def : Pat<(v8i16 (bitconvert (v16i8 MQPR:$src))), (v8i16 (MVE_VREV16_8 MQPR:$src))>;
5331
5332   def : Pat<(v16i8 (bitconvert (v2f64 MQPR:$src))), (v16i8 (MVE_VREV64_8 MQPR:$src))>;
5333   def : Pat<(v16i8 (bitconvert (v2i64 MQPR:$src))), (v16i8 (MVE_VREV64_8 MQPR:$src))>;
5334   def : Pat<(v16i8 (bitconvert (v4f32 MQPR:$src))), (v16i8 (MVE_VREV32_8 MQPR:$src))>;
5335   def : Pat<(v16i8 (bitconvert (v4i32 MQPR:$src))), (v16i8 (MVE_VREV32_8 MQPR:$src))>;
5336   def : Pat<(v16i8 (bitconvert (v8f16 MQPR:$src))), (v16i8 (MVE_VREV16_8 MQPR:$src))>;
5337   def : Pat<(v16i8 (bitconvert (v8i16 MQPR:$src))), (v16i8 (MVE_VREV16_8 MQPR:$src))>;
5338 }