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