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