lib/Target/AArch64/SVEInstrFormats.td

   1 //=-- SVEInstrFormats.td -  AArch64 SVE Instruction classes -*- 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 // AArch64 Scalable Vector Extension (SVE) Instruction Class Definitions.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 def SVEPatternOperand : AsmOperandClass {
  14   let Name = "SVEPattern";
  15   let ParserMethod = "tryParseSVEPattern";
  16   let PredicateMethod = "isSVEPattern";
  17   let RenderMethod = "addImmOperands";
  18   let DiagnosticType = "InvalidSVEPattern";
  19 }
  20
  21 def sve_pred_enum : Operand<i32>, ImmLeaf<i32, [{
  22   return (((uint32_t)Imm) < 32);
  23   }]> {
  24
  25   let PrintMethod = "printSVEPattern";
  26   let ParserMatchClass = SVEPatternOperand;
  27 }
  28
  29 def SVEPrefetchOperand : AsmOperandClass {
  30   let Name = "SVEPrefetch";
  31   let ParserMethod = "tryParsePrefetch<true>";
  32   let PredicateMethod = "isPrefetch";
  33   let RenderMethod = "addPrefetchOperands";
  34 }
  35
  36 def sve_prfop : Operand<i32>, ImmLeaf<i32, [{
  37     return (((uint32_t)Imm) <= 15);
  38   }]> {
  39   let PrintMethod = "printPrefetchOp<true>";
  40   let ParserMatchClass = SVEPrefetchOperand;
  41 }
  42
  43 class SVELogicalImmOperand<int Width> : AsmOperandClass {
  44   let Name = "SVELogicalImm" # Width;
  45   let DiagnosticType = "LogicalSecondSource";
  46   let PredicateMethod = "isLogicalImm<int" # Width # "_t>";
  47   let RenderMethod = "addLogicalImmOperands<int" # Width # "_t>";
  48 }
  49
  50 def sve_logical_imm8 : Operand<i64> {
  51   let ParserMatchClass = SVELogicalImmOperand<8>;
  52   let PrintMethod = "printLogicalImm<int8_t>";
  53
  54   let MCOperandPredicate = [{
  55     if (!MCOp.isImm())
  56       return false;
  57     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
  58     return AArch64_AM::isSVEMaskOfIdenticalElements<int8_t>(Val);
  59   }];
  60 }
  61
  62 def sve_logical_imm16 : Operand<i64> {
  63   let ParserMatchClass = SVELogicalImmOperand<16>;
  64   let PrintMethod = "printLogicalImm<int16_t>";
  65
  66   let MCOperandPredicate = [{
  67     if (!MCOp.isImm())
  68       return false;
  69     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
  70     return AArch64_AM::isSVEMaskOfIdenticalElements<int16_t>(Val);
  71   }];
  72 }
  73
  74 def sve_logical_imm32 : Operand<i64> {
  75   let ParserMatchClass = SVELogicalImmOperand<32>;
  76   let PrintMethod = "printLogicalImm<int32_t>";
  77
  78   let MCOperandPredicate = [{
  79     if (!MCOp.isImm())
  80       return false;
  81     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
  82     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val);
  83   }];
  84 }
  85
  86 class SVEPreferredLogicalImmOperand<int Width> : AsmOperandClass {
  87   let Name = "SVEPreferredLogicalImm" # Width;
  88   let PredicateMethod = "isSVEPreferredLogicalImm<int" # Width # "_t>";
  89   let RenderMethod = "addLogicalImmOperands<int" # Width # "_t>";
  90 }
  91
  92 def sve_preferred_logical_imm16 : Operand<i64> {
  93   let ParserMatchClass = SVEPreferredLogicalImmOperand<16>;
  94   let PrintMethod = "printSVELogicalImm<int16_t>";
  95
  96   let MCOperandPredicate = [{
  97     if (!MCOp.isImm())
  98       return false;
  99     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
 100     return AArch64_AM::isSVEMaskOfIdenticalElements<int16_t>(Val) &&
 101            AArch64_AM::isSVEMoveMaskPreferredLogicalImmediate(Val);
 102   }];
 103 }
 104
 105 def sve_preferred_logical_imm32 : Operand<i64> {
 106   let ParserMatchClass =  SVEPreferredLogicalImmOperand<32>;
 107   let PrintMethod = "printSVELogicalImm<int32_t>";
 108
 109   let MCOperandPredicate = [{
 110     if (!MCOp.isImm())
 111       return false;
 112     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
 113     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val) &&
 114            AArch64_AM::isSVEMoveMaskPreferredLogicalImmediate(Val);
 115   }];
 116 }
 117
 118 def sve_preferred_logical_imm64 : Operand<i64> {
 119   let ParserMatchClass = SVEPreferredLogicalImmOperand<64>;
 120   let PrintMethod = "printSVELogicalImm<int64_t>";
 121
 122   let MCOperandPredicate = [{
 123     if (!MCOp.isImm())
 124       return false;
 125     int64_t Val = AArch64_AM::decodeLogicalImmediate(MCOp.getImm(), 64);
 126     return AArch64_AM::isSVEMaskOfIdenticalElements<int64_t>(Val) &&
 127            AArch64_AM::isSVEMoveMaskPreferredLogicalImmediate(Val);
 128   }];
 129 }
 130
 131 class SVELogicalImmNotOperand<int Width> : AsmOperandClass {
 132   let Name = "SVELogicalImm" # Width # "Not";
 133   let DiagnosticType = "LogicalSecondSource";
 134   let PredicateMethod = "isLogicalImm<int" # Width # "_t>";
 135   let RenderMethod = "addLogicalImmNotOperands<int" # Width # "_t>";
 136 }
 137
 138 def sve_logical_imm8_not : Operand<i64> {
 139   let ParserMatchClass = SVELogicalImmNotOperand<8>;
 140 }
 141
 142 def sve_logical_imm16_not : Operand<i64> {
 143   let ParserMatchClass = SVELogicalImmNotOperand<16>;
 144 }
 145
 146 def sve_logical_imm32_not : Operand<i64> {
 147   let ParserMatchClass = SVELogicalImmNotOperand<32>;
 148 }
 149
 150 class SVEShiftedImmOperand<int ElementWidth, string Infix, string Predicate>
 151     : AsmOperandClass {
 152   let Name = "SVE" # Infix # "Imm" # ElementWidth;
 153   let DiagnosticType = "Invalid" # Name;
 154   let RenderMethod = "addImmWithOptionalShiftOperands<8>";
 155   let ParserMethod = "tryParseImmWithOptionalShift";
 156   let PredicateMethod = Predicate;
 157 }
 158
 159 def SVECpyImmOperand8  : SVEShiftedImmOperand<8,  "Cpy", "isSVECpyImm<int8_t>">;
 160 def SVECpyImmOperand16 : SVEShiftedImmOperand<16, "Cpy", "isSVECpyImm<int16_t>">;
 161 def SVECpyImmOperand32 : SVEShiftedImmOperand<32, "Cpy", "isSVECpyImm<int32_t>">;
 162 def SVECpyImmOperand64 : SVEShiftedImmOperand<64, "Cpy", "isSVECpyImm<int64_t>">;
 163
 164 def SVEAddSubImmOperand8  : SVEShiftedImmOperand<8,  "AddSub", "isSVEAddSubImm<int8_t>">;
 165 def SVEAddSubImmOperand16 : SVEShiftedImmOperand<16, "AddSub", "isSVEAddSubImm<int16_t>">;
 166 def SVEAddSubImmOperand32 : SVEShiftedImmOperand<32, "AddSub", "isSVEAddSubImm<int32_t>">;
 167 def SVEAddSubImmOperand64 : SVEShiftedImmOperand<64, "AddSub", "isSVEAddSubImm<int64_t>">;
 168
 169 class imm8_opt_lsl<int ElementWidth, string printType,
 170                    AsmOperandClass OpndClass, code Predicate>
 171     : Operand<i32>, ImmLeaf<i32, Predicate> {
 172   let EncoderMethod = "getImm8OptLsl";
 173   let DecoderMethod = "DecodeImm8OptLsl<" # ElementWidth # ">";
 174   let PrintMethod = "printImm8OptLsl<" # printType # ">";
 175   let ParserMatchClass = OpndClass;
 176   let MIOperandInfo = (ops i32imm, i32imm);
 177 }
 178
 179 def cpy_imm8_opt_lsl_i8  : imm8_opt_lsl<8,  "int8_t",  SVECpyImmOperand8,  [{
 180   return AArch64_AM::isSVECpyImm<int8_t>(Imm);
 181 }]>;
 182 def cpy_imm8_opt_lsl_i16 : imm8_opt_lsl<16, "int16_t", SVECpyImmOperand16, [{
 183   return AArch64_AM::isSVECpyImm<int16_t>(Imm);
 184 }]>;
 185 def cpy_imm8_opt_lsl_i32 : imm8_opt_lsl<32, "int32_t", SVECpyImmOperand32, [{
 186   return AArch64_AM::isSVECpyImm<int32_t>(Imm);
 187 }]>;
 188 def cpy_imm8_opt_lsl_i64 : imm8_opt_lsl<64, "int64_t", SVECpyImmOperand64, [{
 189   return AArch64_AM::isSVECpyImm<int64_t>(Imm);
 190 }]>;
 191
 192 def addsub_imm8_opt_lsl_i8  : imm8_opt_lsl<8,  "uint8_t",  SVEAddSubImmOperand8,  [{
 193   return AArch64_AM::isSVEAddSubImm<int8_t>(Imm);
 194 }]>;
 195 def addsub_imm8_opt_lsl_i16 : imm8_opt_lsl<16, "uint16_t", SVEAddSubImmOperand16, [{
 196   return AArch64_AM::isSVEAddSubImm<int16_t>(Imm);
 197 }]>;
 198 def addsub_imm8_opt_lsl_i32 : imm8_opt_lsl<32, "uint32_t", SVEAddSubImmOperand32, [{
 199   return AArch64_AM::isSVEAddSubImm<int32_t>(Imm);
 200 }]>;
 201 def addsub_imm8_opt_lsl_i64 : imm8_opt_lsl<64, "uint64_t", SVEAddSubImmOperand64, [{
 202   return AArch64_AM::isSVEAddSubImm<int64_t>(Imm);
 203 }]>;
 204
 205 class SVEExactFPImm<string Suffix, string ValA, string ValB> : AsmOperandClass {
 206   let Name = "SVEExactFPImmOperand" # Suffix;
 207   let DiagnosticType = "Invalid" # Name;
 208   let ParserMethod = "tryParseFPImm<false>";
 209   let PredicateMethod = "isExactFPImm<" # ValA # ", " # ValB # ">";
 210   let RenderMethod = "addExactFPImmOperands<" # ValA # ", " # ValB # ">";
 211 }
 212
 213 class SVEExactFPImmOperand<string Suffix, string ValA, string ValB> : Operand<i32> {
 214   let PrintMethod = "printExactFPImm<" # ValA # ", " # ValB # ">";
 215   let ParserMatchClass = SVEExactFPImm<Suffix, ValA, ValB>;
 216 }
 217
 218 def sve_fpimm_half_one
 219     : SVEExactFPImmOperand<"HalfOne", "AArch64ExactFPImm::half",
 220                            "AArch64ExactFPImm::one">;
 221 def sve_fpimm_half_two
 222     : SVEExactFPImmOperand<"HalfTwo", "AArch64ExactFPImm::half",
 223                            "AArch64ExactFPImm::two">;
 224 def sve_fpimm_zero_one
 225     : SVEExactFPImmOperand<"ZeroOne", "AArch64ExactFPImm::zero",
 226                            "AArch64ExactFPImm::one">;
 227
 228 def sve_incdec_imm : Operand<i32>, ImmLeaf<i32, [{
 229   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 17);
 230 }]> {
 231   let ParserMatchClass = Imm1_16Operand;
 232   let EncoderMethod = "getSVEIncDecImm";
 233   let DecoderMethod = "DecodeSVEIncDecImm";
 234 }
 235
 236 //===----------------------------------------------------------------------===//
 237 // SVE PTrue - These are used extensively throughout the pattern matching so
 238 //             it's important we define them first.
 239 //===----------------------------------------------------------------------===//
 240
 241 class sve_int_ptrue<bits<2> sz8_64, bits<3> opc, string asm, PPRRegOp pprty>
 242 : I<(outs pprty:$Pd), (ins sve_pred_enum:$pattern),
 243   asm, "\t$Pd, $pattern",
 244   "",
 245   []>, Sched<[]> {
 246   bits<4> Pd;
 247   bits<5> pattern;
 248   let Inst{31-24} = 0b00100101;
 249   let Inst{23-22} = sz8_64;
 250   let Inst{21-19} = 0b011;
 251   let Inst{18-17} = opc{2-1};
 252   let Inst{16}    = opc{0};
 253   let Inst{15-10} = 0b111000;
 254   let Inst{9-5}   = pattern;
 255   let Inst{4}     = 0b0;
 256   let Inst{3-0}   = Pd;
 257
 258   let Defs = !if(!eq (opc{0}, 1), [NZCV], []);
 259 }
 260
 261 multiclass sve_int_ptrue<bits<3> opc, string asm> {
 262   def _B : sve_int_ptrue<0b00, opc, asm, PPR8>;
 263   def _H : sve_int_ptrue<0b01, opc, asm, PPR16>;
 264   def _S : sve_int_ptrue<0b10, opc, asm, PPR32>;
 265   def _D : sve_int_ptrue<0b11, opc, asm, PPR64>;
 266
 267   def : InstAlias<asm # "\t$Pd",
 268                   (!cast<Instruction>(NAME # _B) PPR8:$Pd, 0b11111), 1>;
 269   def : InstAlias<asm # "\t$Pd",
 270                   (!cast<Instruction>(NAME # _H) PPR16:$Pd, 0b11111), 1>;
 271   def : InstAlias<asm # "\t$Pd",
 272                   (!cast<Instruction>(NAME # _S) PPR32:$Pd, 0b11111), 1>;
 273   def : InstAlias<asm # "\t$Pd",
 274                   (!cast<Instruction>(NAME # _D) PPR64:$Pd, 0b11111), 1>;
 275 }
 276
 277 let Predicates = [HasSVE] in {
 278   defm PTRUE  : sve_int_ptrue<0b000, "ptrue">;
 279   defm PTRUES : sve_int_ptrue<0b001, "ptrues">;
 280 }
 281
 282 //===----------------------------------------------------------------------===//
 283 // SVE pattern match helpers.
 284 //===----------------------------------------------------------------------===//
 285
 286 class SVE_1_Op_Pat<ValueType vtd, SDPatternOperator op, ValueType vt1,
 287                    Instruction inst>
 288 : Pat<(vtd (op vt1:$Op1)),
 289       (inst $Op1)>;
 290
 291 class SVE_3_Op_Pat<ValueType vtd, SDPatternOperator op, ValueType vt1,
 292                    ValueType vt2, ValueType vt3, Instruction inst>
 293 : Pat<(vtd (op vt1:$Op1, vt2:$Op2, vt3:$Op3)),
 294       (inst $Op1, $Op2, $Op3)>;
 295
 296 //===----------------------------------------------------------------------===//
 297 // SVE Predicate Misc Group
 298 //===----------------------------------------------------------------------===//
 299
 300 class sve_int_pfalse<bits<6> opc, string asm>
 301 : I<(outs PPR8:$Pd), (ins),
 302   asm, "\t$Pd",
 303   "",
 304   []>, Sched<[]> {
 305   bits<4> Pd;
 306   let Inst{31-24} = 0b00100101;
 307   let Inst{23-22} = opc{5-4};
 308   let Inst{21-19} = 0b011;
 309   let Inst{18-16} = opc{3-1};
 310   let Inst{15-10} = 0b111001;
 311   let Inst{9}     = opc{0};
 312   let Inst{8-4}   = 0b00000;
 313   let Inst{3-0}   = Pd;
 314 }
 315
 316 class sve_int_ptest<bits<6> opc, string asm>
 317 : I<(outs), (ins PPRAny:$Pg, PPR8:$Pn),
 318   asm, "\t$Pg, $Pn",
 319   "",
 320   []>, Sched<[]> {
 321   bits<4> Pg;
 322   bits<4> Pn;
 323   let Inst{31-24} = 0b00100101;
 324   let Inst{23-22} = opc{5-4};
 325   let Inst{21-19} = 0b010;
 326   let Inst{18-16} = opc{3-1};
 327   let Inst{15-14} = 0b11;
 328   let Inst{13-10} = Pg;
 329   let Inst{9}     = opc{0};
 330   let Inst{8-5}   = Pn;
 331   let Inst{4-0}   = 0b00000;
 332
 333   let Defs = [NZCV];
 334 }
 335
 336 class sve_int_pfirst_next<bits<2> sz8_64, bits<5> opc, string asm,
 337                           PPRRegOp pprty>
 338 : I<(outs pprty:$Pdn), (ins PPRAny:$Pg, pprty:$_Pdn),
 339   asm, "\t$Pdn, $Pg, $_Pdn",
 340   "",
 341   []>, Sched<[]> {
 342   bits<4> Pdn;
 343   bits<4> Pg;
 344   let Inst{31-24} = 0b00100101;
 345   let Inst{23-22} = sz8_64;
 346   let Inst{21-19} = 0b011;
 347   let Inst{18-16} = opc{4-2};
 348   let Inst{15-11} = 0b11000;
 349   let Inst{10-9}  = opc{1-0};
 350   let Inst{8-5}   = Pg;
 351   let Inst{4}     = 0;
 352   let Inst{3-0}   = Pdn;
 353
 354   let Constraints = "$Pdn = $_Pdn";
 355   let Defs = [NZCV];
 356 }
 357
 358 multiclass sve_int_pfirst<bits<5> opc, string asm> {
 359   def : sve_int_pfirst_next<0b01, opc, asm, PPR8>;
 360 }
 361
 362 multiclass sve_int_pnext<bits<5> opc, string asm> {
 363   def _B : sve_int_pfirst_next<0b00, opc, asm, PPR8>;
 364   def _H : sve_int_pfirst_next<0b01, opc, asm, PPR16>;
 365   def _S : sve_int_pfirst_next<0b10, opc, asm, PPR32>;
 366   def _D : sve_int_pfirst_next<0b11, opc, asm, PPR64>;
 367 }
 368
 369 //===----------------------------------------------------------------------===//
 370 // SVE Predicate Count Group
 371 //===----------------------------------------------------------------------===//
 372
 373 class sve_int_count_r<bits<2> sz8_64, bits<5> opc, string asm,
 374                       RegisterOperand dty, PPRRegOp pprty, RegisterOperand sty>
 375 : I<(outs dty:$Rdn), (ins pprty:$Pg, sty:$_Rdn),
 376   asm, "\t$Rdn, $Pg",
 377   "",
 378   []>, Sched<[]> {
 379   bits<5> Rdn;
 380   bits<4> Pg;
 381   let Inst{31-24} = 0b00100101;
 382   let Inst{23-22} = sz8_64;
 383   let Inst{21-19} = 0b101;
 384   let Inst{18-16} = opc{4-2};
 385   let Inst{15-11} = 0b10001;
 386   let Inst{10-9}  = opc{1-0};
 387   let Inst{8-5}   = Pg;
 388   let Inst{4-0}   = Rdn;
 389
 390   // Signed 32bit forms require their GPR operand printed.
 391   let AsmString = !if(!eq(opc{4,2-0}, 0b0000),
 392                       !strconcat(asm, "\t$Rdn, $Pg, $_Rdn"),
 393                       !strconcat(asm, "\t$Rdn, $Pg"));
 394   let Constraints = "$Rdn = $_Rdn";
 395 }
 396
 397 multiclass sve_int_count_r_s32<bits<5> opc, string asm> {
 398   def _B : sve_int_count_r<0b00, opc, asm, GPR64z, PPR8, GPR64as32>;
 399   def _H : sve_int_count_r<0b01, opc, asm, GPR64z, PPR16, GPR64as32>;
 400   def _S : sve_int_count_r<0b10, opc, asm, GPR64z, PPR32, GPR64as32>;
 401   def _D : sve_int_count_r<0b11, opc, asm, GPR64z, PPR64, GPR64as32>;
 402 }
 403
 404 multiclass sve_int_count_r_u32<bits<5> opc, string asm> {
 405   def _B : sve_int_count_r<0b00, opc, asm, GPR32z, PPR8, GPR32z>;
 406   def _H : sve_int_count_r<0b01, opc, asm, GPR32z, PPR16, GPR32z>;
 407   def _S : sve_int_count_r<0b10, opc, asm, GPR32z, PPR32, GPR32z>;
 408   def _D : sve_int_count_r<0b11, opc, asm, GPR32z, PPR64, GPR32z>;
 409 }
 410
 411 multiclass sve_int_count_r_x64<bits<5> opc, string asm> {
 412   def _B : sve_int_count_r<0b00, opc, asm, GPR64z, PPR8, GPR64z>;
 413   def _H : sve_int_count_r<0b01, opc, asm, GPR64z, PPR16, GPR64z>;
 414   def _S : sve_int_count_r<0b10, opc, asm, GPR64z, PPR32, GPR64z>;
 415   def _D : sve_int_count_r<0b11, opc, asm, GPR64z, PPR64, GPR64z>;
 416 }
 417
 418 class sve_int_count_v<bits<2> sz8_64, bits<5> opc, string asm,
 419                       ZPRRegOp zprty, PPRRegOp pprty>
 420 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, pprty:$Pm),
 421   asm, "\t$Zdn, $Pm",
 422   "",
 423   []>, Sched<[]> {
 424   bits<4> Pm;
 425   bits<5> Zdn;
 426   let Inst{31-24} = 0b00100101;
 427   let Inst{23-22} = sz8_64;
 428   let Inst{21-19} = 0b101;
 429   let Inst{18-16} = opc{4-2};
 430   let Inst{15-11} = 0b10000;
 431   let Inst{10-9}  = opc{1-0};
 432   let Inst{8-5}   = Pm;
 433   let Inst{4-0}   = Zdn;
 434
 435   let Constraints = "$Zdn = $_Zdn";
 436   let DestructiveInstType = Destructive;
 437   let ElementSize = ElementSizeNone;
 438 }
 439
 440 multiclass sve_int_count_v<bits<5> opc, string asm> {
 441   def _H : sve_int_count_v<0b01, opc, asm, ZPR16, PPR16>;
 442   def _S : sve_int_count_v<0b10, opc, asm, ZPR32, PPR32>;
 443   def _D : sve_int_count_v<0b11, opc, asm, ZPR64, PPR64>;
 444
 445   def : InstAlias<asm # "\t$Zdn, $Pm",
 446                  (!cast<Instruction>(NAME # "_H") ZPR16:$Zdn, PPRAny:$Pm), 0>;
 447   def : InstAlias<asm # "\t$Zdn, $Pm",
 448                  (!cast<Instruction>(NAME # "_S") ZPR32:$Zdn, PPRAny:$Pm), 0>;
 449   def : InstAlias<asm # "\t$Zdn, $Pm",
 450                   (!cast<Instruction>(NAME # "_D") ZPR64:$Zdn, PPRAny:$Pm), 0>;
 451 }
 452
 453 class sve_int_pcount_pred<bits<2> sz8_64, bits<4> opc, string asm,
 454                           PPRRegOp pprty>
 455 : I<(outs GPR64:$Rd), (ins PPRAny:$Pg, pprty:$Pn),
 456   asm, "\t$Rd, $Pg, $Pn",
 457   "",
 458   []>, Sched<[]> {
 459   bits<4> Pg;
 460   bits<4> Pn;
 461   bits<5> Rd;
 462   let Inst{31-24} = 0b00100101;
 463   let Inst{23-22} = sz8_64;
 464   let Inst{21-19} = 0b100;
 465   let Inst{18-16} = opc{3-1};
 466   let Inst{15-14} = 0b10;
 467   let Inst{13-10} = Pg;
 468   let Inst{9}     = opc{0};
 469   let Inst{8-5}   = Pn;
 470   let Inst{4-0}   = Rd;
 471 }
 472
 473 multiclass sve_int_pcount_pred<bits<4> opc, string asm> {
 474   def _B : sve_int_pcount_pred<0b00, opc, asm, PPR8>;
 475   def _H : sve_int_pcount_pred<0b01, opc, asm, PPR16>;
 476   def _S : sve_int_pcount_pred<0b10, opc, asm, PPR32>;
 477   def _D : sve_int_pcount_pred<0b11, opc, asm, PPR64>;
 478 }
 479
 480 //===----------------------------------------------------------------------===//
 481 // SVE Element Count Group
 482 //===----------------------------------------------------------------------===//
 483
 484 class sve_int_count<bits<3> opc, string asm>
 485 : I<(outs GPR64:$Rd), (ins sve_pred_enum:$pattern, sve_incdec_imm:$imm4),
 486   asm, "\t$Rd, $pattern, mul $imm4",
 487   "",
 488   []>, Sched<[]> {
 489   bits<5> Rd;
 490   bits<4> imm4;
 491   bits<5> pattern;
 492   let Inst{31-24} = 0b00000100;
 493   let Inst{23-22} = opc{2-1};
 494   let Inst{21-20} = 0b10;
 495   let Inst{19-16} = imm4;
 496   let Inst{15-11} = 0b11100;
 497   let Inst{10}    = opc{0};
 498   let Inst{9-5}   = pattern;
 499   let Inst{4-0}   = Rd;
 500 }
 501
 502 multiclass sve_int_count<bits<3> opc, string asm> {
 503   def NAME : sve_int_count<opc, asm>;
 504
 505   def : InstAlias<asm # "\t$Rd, $pattern",
 506                   (!cast<Instruction>(NAME) GPR64:$Rd, sve_pred_enum:$pattern, 1), 1>;
 507   def : InstAlias<asm # "\t$Rd",
 508                   (!cast<Instruction>(NAME) GPR64:$Rd, 0b11111, 1), 2>;
 509 }
 510
 511 class sve_int_countvlv<bits<5> opc, string asm, ZPRRegOp zprty>
 512 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, sve_pred_enum:$pattern, sve_incdec_imm:$imm4),
 513   asm, "\t$Zdn, $pattern, mul $imm4",
 514   "",
 515   []>, Sched<[]> {
 516   bits<5> Zdn;
 517   bits<5> pattern;
 518   bits<4> imm4;
 519   let Inst{31-24} = 0b00000100;
 520   let Inst{23-22} = opc{4-3};
 521   let Inst{21}    = 0b1;
 522   let Inst{20}    = opc{2};
 523   let Inst{19-16} = imm4;
 524   let Inst{15-12} = 0b1100;
 525   let Inst{11-10} = opc{1-0};
 526   let Inst{9-5}   = pattern;
 527   let Inst{4-0}   = Zdn;
 528
 529   let Constraints = "$Zdn = $_Zdn";
 530   let DestructiveInstType = Destructive;
 531   let ElementSize = ElementSizeNone;
 532 }
 533
 534 multiclass sve_int_countvlv<bits<5> opc, string asm, ZPRRegOp zprty> {
 535   def NAME : sve_int_countvlv<opc, asm, zprty>;
 536
 537   def : InstAlias<asm # "\t$Zdn, $pattern",
 538                   (!cast<Instruction>(NAME) zprty:$Zdn, sve_pred_enum:$pattern, 1), 1>;
 539   def : InstAlias<asm # "\t$Zdn",
 540                   (!cast<Instruction>(NAME) zprty:$Zdn, 0b11111, 1), 2>;
 541 }
 542
 543 class sve_int_pred_pattern_a<bits<3> opc, string asm>
 544 : I<(outs GPR64:$Rdn), (ins GPR64:$_Rdn, sve_pred_enum:$pattern, sve_incdec_imm:$imm4),
 545   asm, "\t$Rdn, $pattern, mul $imm4",
 546   "",
 547   []>, Sched<[]> {
 548   bits<5> Rdn;
 549   bits<5> pattern;
 550   bits<4> imm4;
 551   let Inst{31-24} = 0b00000100;
 552   let Inst{23-22} = opc{2-1};
 553   let Inst{21-20} = 0b11;
 554   let Inst{19-16} = imm4;
 555   let Inst{15-11} = 0b11100;
 556   let Inst{10}    = opc{0};
 557   let Inst{9-5}   = pattern;
 558   let Inst{4-0}   = Rdn;
 559
 560   let Constraints = "$Rdn = $_Rdn";
 561 }
 562
 563 multiclass sve_int_pred_pattern_a<bits<3> opc, string asm> {
 564   def NAME : sve_int_pred_pattern_a<opc, asm>;
 565
 566   def : InstAlias<asm # "\t$Rdn, $pattern",
 567                   (!cast<Instruction>(NAME) GPR64:$Rdn, sve_pred_enum:$pattern, 1), 1>;
 568   def : InstAlias<asm # "\t$Rdn",
 569                   (!cast<Instruction>(NAME) GPR64:$Rdn, 0b11111, 1), 2>;
 570 }
 571
 572 class sve_int_pred_pattern_b<bits<5> opc, string asm, RegisterOperand dt,
 573                              RegisterOperand st>
 574 : I<(outs dt:$Rdn), (ins st:$_Rdn, sve_pred_enum:$pattern, sve_incdec_imm:$imm4),
 575   asm, "\t$Rdn, $pattern, mul $imm4",
 576   "",
 577   []>, Sched<[]> {
 578   bits<5> Rdn;
 579   bits<5> pattern;
 580   bits<4> imm4;
 581   let Inst{31-24} = 0b00000100;
 582   let Inst{23-22} = opc{4-3};
 583   let Inst{21}    = 0b1;
 584   let Inst{20}    = opc{2};
 585   let Inst{19-16} = imm4;
 586   let Inst{15-12} = 0b1111;
 587   let Inst{11-10} = opc{1-0};
 588   let Inst{9-5}   = pattern;
 589   let Inst{4-0}   = Rdn;
 590
 591   // Signed 32bit forms require their GPR operand printed.
 592   let AsmString = !if(!eq(opc{2,0}, 0b00),
 593                       !strconcat(asm, "\t$Rdn, $_Rdn, $pattern, mul $imm4"),
 594                       !strconcat(asm, "\t$Rdn, $pattern, mul $imm4"));
 595
 596   let Constraints = "$Rdn = $_Rdn";
 597 }
 598
 599 multiclass sve_int_pred_pattern_b_s32<bits<5> opc, string asm> {
 600   def NAME : sve_int_pred_pattern_b<opc, asm, GPR64z, GPR64as32>;
 601
 602   def : InstAlias<asm # "\t$Rd, $Rn, $pattern",
 603                   (!cast<Instruction>(NAME) GPR64z:$Rd, GPR64as32:$Rn, sve_pred_enum:$pattern, 1), 1>;
 604   def : InstAlias<asm # "\t$Rd, $Rn",
 605                   (!cast<Instruction>(NAME) GPR64z:$Rd, GPR64as32:$Rn, 0b11111, 1), 2>;
 606 }
 607
 608 multiclass sve_int_pred_pattern_b_u32<bits<5> opc, string asm> {
 609   def NAME : sve_int_pred_pattern_b<opc, asm, GPR32z, GPR32z>;
 610
 611   def : InstAlias<asm # "\t$Rdn, $pattern",
 612                   (!cast<Instruction>(NAME) GPR32z:$Rdn, sve_pred_enum:$pattern, 1), 1>;
 613   def : InstAlias<asm # "\t$Rdn",
 614                   (!cast<Instruction>(NAME) GPR32z:$Rdn, 0b11111, 1), 2>;
 615 }
 616
 617 multiclass sve_int_pred_pattern_b_x64<bits<5> opc, string asm> {
 618   def NAME : sve_int_pred_pattern_b<opc, asm, GPR64z, GPR64z>;
 619
 620   def : InstAlias<asm # "\t$Rdn, $pattern",
 621                   (!cast<Instruction>(NAME) GPR64z:$Rdn, sve_pred_enum:$pattern, 1), 1>;
 622   def : InstAlias<asm # "\t$Rdn",
 623                   (!cast<Instruction>(NAME) GPR64z:$Rdn, 0b11111, 1), 2>;
 624 }
 625
 626
 627 //===----------------------------------------------------------------------===//
 628 // SVE Permute - Cross Lane Group
 629 //===----------------------------------------------------------------------===//
 630
 631 class sve_int_perm_dup_r<bits<2> sz8_64, string asm, ZPRRegOp zprty,
 632                          RegisterClass srcRegType>
 633 : I<(outs zprty:$Zd), (ins srcRegType:$Rn),
 634   asm, "\t$Zd, $Rn",
 635   "",
 636   []>, Sched<[]> {
 637   bits<5> Rn;
 638   bits<5> Zd;
 639   let Inst{31-24} = 0b00000101;
 640   let Inst{23-22} = sz8_64;
 641   let Inst{21-10} = 0b100000001110;
 642   let Inst{9-5}   = Rn;
 643   let Inst{4-0}   = Zd;
 644 }
 645
 646 multiclass sve_int_perm_dup_r<string asm> {
 647   def _B : sve_int_perm_dup_r<0b00, asm, ZPR8, GPR32sp>;
 648   def _H : sve_int_perm_dup_r<0b01, asm, ZPR16, GPR32sp>;
 649   def _S : sve_int_perm_dup_r<0b10, asm, ZPR32, GPR32sp>;
 650   def _D : sve_int_perm_dup_r<0b11, asm, ZPR64, GPR64sp>;
 651
 652   def : InstAlias<"mov $Zd, $Rn",
 653                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, GPR32sp:$Rn), 1>;
 654   def : InstAlias<"mov $Zd, $Rn",
 655                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, GPR32sp:$Rn), 1>;
 656   def : InstAlias<"mov $Zd, $Rn",
 657                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, GPR32sp:$Rn), 1>;
 658   def : InstAlias<"mov $Zd, $Rn",
 659                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, GPR64sp:$Rn), 1>;
 660 }
 661
 662 class sve_int_perm_dup_i<bits<5> tsz, Operand immtype, string asm,
 663                          ZPRRegOp zprty>
 664 : I<(outs zprty:$Zd), (ins zprty:$Zn, immtype:$idx),
 665   asm, "\t$Zd, $Zn$idx",
 666   "",
 667   []>, Sched<[]> {
 668   bits<5> Zd;
 669   bits<5> Zn;
 670   bits<7> idx;
 671   let Inst{31-24} = 0b00000101;
 672   let Inst{23-22} = {?,?}; // imm3h
 673   let Inst{21}    = 0b1;
 674   let Inst{20-16} = tsz;
 675   let Inst{15-10} = 0b001000;
 676   let Inst{9-5}   = Zn;
 677   let Inst{4-0}   = Zd;
 678 }
 679
 680 multiclass sve_int_perm_dup_i<string asm> {
 681   def _B : sve_int_perm_dup_i<{?,?,?,?,1}, sve_elm_idx_extdup_b, asm, ZPR8> {
 682     let Inst{23-22} = idx{5-4};
 683     let Inst{20-17} = idx{3-0};
 684   }
 685   def _H : sve_int_perm_dup_i<{?,?,?,1,0}, sve_elm_idx_extdup_h, asm, ZPR16> {
 686     let Inst{23-22} = idx{4-3};
 687     let Inst{20-18} = idx{2-0};
 688   }
 689   def _S : sve_int_perm_dup_i<{?,?,1,0,0}, sve_elm_idx_extdup_s, asm, ZPR32> {
 690     let Inst{23-22} = idx{3-2};
 691     let Inst{20-19}    = idx{1-0};
 692   }
 693   def _D : sve_int_perm_dup_i<{?,1,0,0,0}, sve_elm_idx_extdup_d, asm, ZPR64> {
 694     let Inst{23-22} = idx{2-1};
 695     let Inst{20}    = idx{0};
 696   }
 697   def _Q : sve_int_perm_dup_i<{1,0,0,0,0}, sve_elm_idx_extdup_q, asm, ZPR128> {
 698     let Inst{23-22} = idx{1-0};
 699   }
 700
 701   def : InstAlias<"mov $Zd, $Zn$idx",
 702                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, ZPR8:$Zn, sve_elm_idx_extdup_b:$idx), 1>;
 703   def : InstAlias<"mov $Zd, $Zn$idx",
 704                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, ZPR16:$Zn, sve_elm_idx_extdup_h:$idx), 1>;
 705   def : InstAlias<"mov $Zd, $Zn$idx",
 706                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, ZPR32:$Zn, sve_elm_idx_extdup_s:$idx), 1>;
 707   def : InstAlias<"mov $Zd, $Zn$idx",
 708                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, ZPR64:$Zn, sve_elm_idx_extdup_d:$idx), 1>;
 709   def : InstAlias<"mov $Zd, $Zn$idx",
 710                   (!cast<Instruction>(NAME # _Q) ZPR128:$Zd, ZPR128:$Zn, sve_elm_idx_extdup_q:$idx), 1>;
 711   def : InstAlias<"mov $Zd, $Bn",
 712                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, FPR8asZPR:$Bn, 0), 2>;
 713   def : InstAlias<"mov $Zd, $Hn",
 714                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, FPR16asZPR:$Hn, 0), 2>;
 715   def : InstAlias<"mov $Zd, $Sn",
 716                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, FPR32asZPR:$Sn, 0), 2>;
 717   def : InstAlias<"mov $Zd, $Dn",
 718                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, FPR64asZPR:$Dn, 0), 2>;
 719   def : InstAlias<"mov $Zd, $Qn",
 720                   (!cast<Instruction>(NAME # _Q) ZPR128:$Zd, FPR128asZPR:$Qn, 0), 2>;
 721 }
 722
 723 class sve_int_perm_tbl<bits<2> sz8_64, bits<2> opc, string asm,
 724                        ZPRRegOp zprty, RegisterOperand VecList>
 725 : I<(outs zprty:$Zd), (ins VecList:$Zn, zprty:$Zm),
 726   asm, "\t$Zd, $Zn, $Zm",
 727   "",
 728   []>, Sched<[]> {
 729   bits<5> Zd;
 730   bits<5> Zm;
 731   bits<5> Zn;
 732   let Inst{31-24} = 0b00000101;
 733   let Inst{23-22} = sz8_64;
 734   let Inst{21}    = 0b1;
 735   let Inst{20-16} = Zm;
 736   let Inst{15-13} = 0b001;
 737   let Inst{12-11} = opc;
 738   let Inst{10}    = 0b0;
 739   let Inst{9-5}   = Zn;
 740   let Inst{4-0}   = Zd;
 741 }
 742
 743 multiclass sve_int_perm_tbl<string asm> {
 744   def _B : sve_int_perm_tbl<0b00, 0b10, asm, ZPR8,  Z_b>;
 745   def _H : sve_int_perm_tbl<0b01, 0b10, asm, ZPR16, Z_h>;
 746   def _S : sve_int_perm_tbl<0b10, 0b10, asm, ZPR32, Z_s>;
 747   def _D : sve_int_perm_tbl<0b11, 0b10, asm, ZPR64, Z_d>;
 748
 749   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
 750                  (!cast<Instruction>(NAME # _B) ZPR8:$Zd, ZPR8:$Zn, ZPR8:$Zm), 0>;
 751   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
 752                  (!cast<Instruction>(NAME # _H) ZPR16:$Zd, ZPR16:$Zn, ZPR16:$Zm), 0>;
 753   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
 754                  (!cast<Instruction>(NAME # _S) ZPR32:$Zd, ZPR32:$Zn, ZPR32:$Zm), 0>;
 755   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
 756                  (!cast<Instruction>(NAME # _D) ZPR64:$Zd, ZPR64:$Zn, ZPR64:$Zm), 0>;
 757 }
 758
 759 multiclass sve2_int_perm_tbl<string asm> {
 760   def _B : sve_int_perm_tbl<0b00, 0b01, asm, ZPR8,  ZZ_b>;
 761   def _H : sve_int_perm_tbl<0b01, 0b01, asm, ZPR16, ZZ_h>;
 762   def _S : sve_int_perm_tbl<0b10, 0b01, asm, ZPR32, ZZ_s>;
 763   def _D : sve_int_perm_tbl<0b11, 0b01, asm, ZPR64, ZZ_d>;
 764 }
 765
 766 class sve2_int_perm_tbx<bits<2> sz8_64, string asm, ZPRRegOp zprty>
 767 : I<(outs zprty:$Zd), (ins zprty:$_Zd, zprty:$Zn, zprty:$Zm),
 768   asm, "\t$Zd, $Zn, $Zm",
 769   "",
 770   []>, Sched<[]> {
 771   bits<5> Zd;
 772   bits<5> Zm;
 773   bits<5> Zn;
 774   let Inst{31-24} = 0b00000101;
 775   let Inst{23-22} = sz8_64;
 776   let Inst{21}    = 0b1;
 777   let Inst{20-16} = Zm;
 778   let Inst{15-10} = 0b001011;
 779   let Inst{9-5}   = Zn;
 780   let Inst{4-0}   = Zd;
 781
 782   let Constraints = "$Zd = $_Zd";
 783 }
 784
 785 multiclass sve2_int_perm_tbx<string asm> {
 786   def _B : sve2_int_perm_tbx<0b00, asm, ZPR8>;
 787   def _H : sve2_int_perm_tbx<0b01, asm, ZPR16>;
 788   def _S : sve2_int_perm_tbx<0b10, asm, ZPR32>;
 789   def _D : sve2_int_perm_tbx<0b11, asm, ZPR64>;
 790 }
 791
 792 class sve_int_perm_reverse_z<bits<2> sz8_64, string asm, ZPRRegOp zprty>
 793 : I<(outs zprty:$Zd), (ins zprty:$Zn),
 794   asm, "\t$Zd, $Zn",
 795   "",
 796   []>, Sched<[]> {
 797   bits<5> Zd;
 798   bits<5> Zn;
 799   let Inst{31-24} = 0b00000101;
 800   let Inst{23-22} = sz8_64;
 801   let Inst{21-10} = 0b111000001110;
 802   let Inst{9-5}   = Zn;
 803   let Inst{4-0}   = Zd;
 804 }
 805
 806 multiclass sve_int_perm_reverse_z<string asm> {
 807   def _B : sve_int_perm_reverse_z<0b00, asm, ZPR8>;
 808   def _H : sve_int_perm_reverse_z<0b01, asm, ZPR16>;
 809   def _S : sve_int_perm_reverse_z<0b10, asm, ZPR32>;
 810   def _D : sve_int_perm_reverse_z<0b11, asm, ZPR64>;
 811 }
 812
 813 class sve_int_perm_reverse_p<bits<2> sz8_64, string asm, PPRRegOp pprty>
 814 : I<(outs pprty:$Pd), (ins pprty:$Pn),
 815   asm, "\t$Pd, $Pn",
 816   "",
 817   []>, Sched<[]> {
 818   bits<4> Pd;
 819   bits<4> Pn;
 820   let Inst{31-24} = 0b00000101;
 821   let Inst{23-22} = sz8_64;
 822   let Inst{21-9}  = 0b1101000100000;
 823   let Inst{8-5}   = Pn;
 824   let Inst{4}     = 0b0;
 825   let Inst{3-0}   = Pd;
 826 }
 827
 828 multiclass sve_int_perm_reverse_p<string asm> {
 829   def _B : sve_int_perm_reverse_p<0b00, asm, PPR8>;
 830   def _H : sve_int_perm_reverse_p<0b01, asm, PPR16>;
 831   def _S : sve_int_perm_reverse_p<0b10, asm, PPR32>;
 832   def _D : sve_int_perm_reverse_p<0b11, asm, PPR64>;
 833 }
 834
 835 class sve_int_perm_unpk<bits<2> sz16_64, bits<2> opc, string asm,
 836                         ZPRRegOp zprty1, ZPRRegOp zprty2>
 837 : I<(outs zprty1:$Zd), (ins zprty2:$Zn),
 838   asm, "\t$Zd, $Zn",
 839   "", []>, Sched<[]> {
 840   bits<5> Zd;
 841   bits<5> Zn;
 842   let Inst{31-24} = 0b00000101;
 843   let Inst{23-22} = sz16_64;
 844   let Inst{21-18} = 0b1100;
 845   let Inst{17-16} = opc;
 846   let Inst{15-10} = 0b001110;
 847   let Inst{9-5}   = Zn;
 848   let Inst{4-0}   = Zd;
 849 }
 850
 851 multiclass sve_int_perm_unpk<bits<2> opc, string asm> {
 852   def _H : sve_int_perm_unpk<0b01, opc, asm, ZPR16, ZPR8>;
 853   def _S : sve_int_perm_unpk<0b10, opc, asm, ZPR32, ZPR16>;
 854   def _D : sve_int_perm_unpk<0b11, opc, asm, ZPR64, ZPR32>;
 855 }
 856
 857 class sve_int_perm_insrs<bits<2> sz8_64, string asm, ZPRRegOp zprty,
 858                          RegisterClass srcRegType>
 859 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, srcRegType:$Rm),
 860   asm, "\t$Zdn, $Rm",
 861   "",
 862   []>, Sched<[]> {
 863   bits<5> Rm;
 864   bits<5> Zdn;
 865   let Inst{31-24} = 0b00000101;
 866   let Inst{23-22} = sz8_64;
 867   let Inst{21-10} = 0b100100001110;
 868   let Inst{9-5}   = Rm;
 869   let Inst{4-0}   = Zdn;
 870
 871   let Constraints = "$Zdn = $_Zdn";
 872   let DestructiveInstType = Destructive;
 873   let ElementSize = ElementSizeNone;
 874 }
 875
 876 multiclass sve_int_perm_insrs<string asm> {
 877   def _B : sve_int_perm_insrs<0b00, asm, ZPR8, GPR32>;
 878   def _H : sve_int_perm_insrs<0b01, asm, ZPR16, GPR32>;
 879   def _S : sve_int_perm_insrs<0b10, asm, ZPR32, GPR32>;
 880   def _D : sve_int_perm_insrs<0b11, asm, ZPR64, GPR64>;
 881 }
 882
 883 class sve_int_perm_insrv<bits<2> sz8_64, string asm, ZPRRegOp zprty,
 884                          RegisterClass srcRegType>
 885 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, srcRegType:$Vm),
 886   asm, "\t$Zdn, $Vm",
 887   "",
 888   []>, Sched<[]> {
 889   bits<5> Vm;
 890   bits<5> Zdn;
 891   let Inst{31-24} = 0b00000101;
 892   let Inst{23-22} = sz8_64;
 893   let Inst{21-10} = 0b110100001110;
 894   let Inst{9-5}   = Vm;
 895   let Inst{4-0}   = Zdn;
 896
 897   let Constraints = "$Zdn = $_Zdn";
 898   let DestructiveInstType = Destructive;
 899   let ElementSize = ElementSizeNone;
 900 }
 901
 902 multiclass sve_int_perm_insrv<string asm> {
 903   def _B : sve_int_perm_insrv<0b00, asm, ZPR8, FPR8>;
 904   def _H : sve_int_perm_insrv<0b01, asm, ZPR16, FPR16>;
 905   def _S : sve_int_perm_insrv<0b10, asm, ZPR32, FPR32>;
 906   def _D : sve_int_perm_insrv<0b11, asm, ZPR64, FPR64>;
 907 }
 908
 909 //===----------------------------------------------------------------------===//
 910 // SVE Permute - Extract Group
 911 //===----------------------------------------------------------------------===//
 912
 913 class sve_int_perm_extract_i<string asm>
 914 : I<(outs ZPR8:$Zdn), (ins ZPR8:$_Zdn, ZPR8:$Zm, imm0_255:$imm8),
 915   asm, "\t$Zdn, $_Zdn, $Zm, $imm8",
 916   "", []>, Sched<[]> {
 917   bits<5> Zdn;
 918   bits<5> Zm;
 919   bits<8> imm8;
 920   let Inst{31-21} = 0b00000101001;
 921   let Inst{20-16} = imm8{7-3};
 922   let Inst{15-13} = 0b000;
 923   let Inst{12-10} = imm8{2-0};
 924   let Inst{9-5}   = Zm;
 925   let Inst{4-0}   = Zdn;
 926
 927   let Constraints = "$Zdn = $_Zdn";
 928   let DestructiveInstType = Destructive;
 929   let ElementSize = ElementSizeNone;
 930 }
 931
 932 class sve2_int_perm_extract_i_cons<string asm>
 933 : I<(outs ZPR8:$Zd), (ins ZZ_b:$Zn, imm0_255:$imm8),
 934   asm, "\t$Zd, $Zn, $imm8",
 935   "", []>, Sched<[]> {
 936   bits<5> Zd;
 937   bits<5> Zn;
 938   bits<8> imm8;
 939   let Inst{31-21} = 0b00000101011;
 940   let Inst{20-16} = imm8{7-3};
 941   let Inst{15-13} = 0b000;
 942   let Inst{12-10} = imm8{2-0};
 943   let Inst{9-5}   = Zn;
 944   let Inst{4-0}   = Zd;
 945 }
 946
 947 //===----------------------------------------------------------------------===//
 948 // SVE Vector Select Group
 949 //===----------------------------------------------------------------------===//
 950
 951 class sve_int_sel_vvv<bits<2> sz8_64, string asm, ZPRRegOp zprty>
 952 : I<(outs zprty:$Zd), (ins PPRAny:$Pg, zprty:$Zn, zprty:$Zm),
 953   asm, "\t$Zd, $Pg, $Zn, $Zm",
 954   "",
 955   []>, Sched<[]> {
 956   bits<4> Pg;
 957   bits<5> Zd;
 958   bits<5> Zm;
 959   bits<5> Zn;
 960   let Inst{31-24} = 0b00000101;
 961   let Inst{23-22} = sz8_64;
 962   let Inst{21}    = 0b1;
 963   let Inst{20-16} = Zm;
 964   let Inst{15-14} = 0b11;
 965   let Inst{13-10} = Pg;
 966   let Inst{9-5}   = Zn;
 967   let Inst{4-0}   = Zd;
 968 }
 969
 970 multiclass sve_int_sel_vvv<string asm> {
 971   def _B : sve_int_sel_vvv<0b00, asm, ZPR8>;
 972   def _H : sve_int_sel_vvv<0b01, asm, ZPR16>;
 973   def _S : sve_int_sel_vvv<0b10, asm, ZPR32>;
 974   def _D : sve_int_sel_vvv<0b11, asm, ZPR64>;
 975
 976   def : InstAlias<"mov $Zd, $Pg/m, $Zn",
 977                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, PPRAny:$Pg, ZPR8:$Zn, ZPR8:$Zd), 1>;
 978   def : InstAlias<"mov $Zd, $Pg/m, $Zn",
 979                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPRAny:$Pg, ZPR16:$Zn, ZPR16:$Zd), 1>;
 980   def : InstAlias<"mov $Zd, $Pg/m, $Zn",
 981                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPRAny:$Pg, ZPR32:$Zn, ZPR32:$Zd), 1>;
 982   def : InstAlias<"mov $Zd, $Pg/m, $Zn",
 983                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPRAny:$Pg, ZPR64:$Zn, ZPR64:$Zd), 1>;
 984 }
 985
 986
 987 //===----------------------------------------------------------------------===//
 988 // SVE Predicate Logical Operations Group
 989 //===----------------------------------------------------------------------===//
 990
 991 class sve_int_pred_log<bits<4> opc, string asm>
 992 : I<(outs PPR8:$Pd), (ins PPRAny:$Pg, PPR8:$Pn, PPR8:$Pm),
 993   asm, "\t$Pd, $Pg/z, $Pn, $Pm",
 994   "",
 995   []>, Sched<[]> {
 996   bits<4> Pd;
 997   bits<4> Pg;
 998   bits<4> Pm;
 999   bits<4> Pn;
1000   let Inst{31-24} = 0b00100101;
1001   let Inst{23-22} = opc{3-2};
1002   let Inst{21-20} = 0b00;
1003   let Inst{19-16} = Pm;
1004   let Inst{15-14} = 0b01;
1005   let Inst{13-10} = Pg;
1006   let Inst{9}     = opc{1};
1007   let Inst{8-5}   = Pn;
1008   let Inst{4}     = opc{0};
1009   let Inst{3-0}   = Pd;
1010
1011   // SEL has no predication qualifier.
1012   let AsmString = !if(!eq(opc, 0b0011),
1013                       !strconcat(asm, "\t$Pd, $Pg, $Pn, $Pm"),
1014                       !strconcat(asm, "\t$Pd, $Pg/z, $Pn, $Pm"));
1015
1016   let Defs = !if(!eq (opc{2}, 1), [NZCV], []);
1017 }
1018
1019
1020 //===----------------------------------------------------------------------===//
1021 // SVE Logical Mask Immediate Group
1022 //===----------------------------------------------------------------------===//
1023
1024 class sve_int_log_imm<bits<2> opc, string asm>
1025 : I<(outs ZPR64:$Zdn), (ins ZPR64:$_Zdn, logical_imm64:$imms13),
1026   asm, "\t$Zdn, $_Zdn, $imms13",
1027   "", []>, Sched<[]> {
1028   bits<5> Zdn;
1029   bits<13> imms13;
1030   let Inst{31-24} = 0b00000101;
1031   let Inst{23-22} = opc;
1032   let Inst{21-18} = 0b0000;
1033   let Inst{17-5}  = imms13;
1034   let Inst{4-0}   = Zdn;
1035
1036   let Constraints = "$Zdn = $_Zdn";
1037   let DecoderMethod = "DecodeSVELogicalImmInstruction";
1038   let DestructiveInstType = Destructive;
1039   let ElementSize = ElementSizeNone;
1040 }
1041
1042 multiclass sve_int_log_imm<bits<2> opc, string asm, string alias> {
1043   def NAME : sve_int_log_imm<opc, asm>;
1044
1045   def : InstAlias<asm # "\t$Zdn, $Zdn, $imm",
1046                   (!cast<Instruction>(NAME) ZPR8:$Zdn, sve_logical_imm8:$imm), 4>;
1047   def : InstAlias<asm # "\t$Zdn, $Zdn, $imm",
1048                   (!cast<Instruction>(NAME) ZPR16:$Zdn, sve_logical_imm16:$imm), 3>;
1049   def : InstAlias<asm # "\t$Zdn, $Zdn, $imm",
1050                   (!cast<Instruction>(NAME) ZPR32:$Zdn, sve_logical_imm32:$imm), 2>;
1051
1052   def : InstAlias<alias # "\t$Zdn, $Zdn, $imm",
1053                   (!cast<Instruction>(NAME) ZPR8:$Zdn, sve_logical_imm8_not:$imm), 0>;
1054   def : InstAlias<alias # "\t$Zdn, $Zdn, $imm",
1055                   (!cast<Instruction>(NAME) ZPR16:$Zdn, sve_logical_imm16_not:$imm), 0>;
1056   def : InstAlias<alias # "\t$Zdn, $Zdn, $imm",
1057                   (!cast<Instruction>(NAME) ZPR32:$Zdn, sve_logical_imm32_not:$imm), 0>;
1058   def : InstAlias<alias # "\t$Zdn, $Zdn, $imm",
1059                   (!cast<Instruction>(NAME) ZPR64:$Zdn, logical_imm64_not:$imm), 0>;
1060 }
1061
1062 class sve_int_dup_mask_imm<string asm>
1063 : I<(outs ZPR64:$Zd), (ins logical_imm64:$imms),
1064   asm, "\t$Zd, $imms",
1065   "",
1066   []>, Sched<[]> {
1067   bits<5> Zd;
1068   bits<13> imms;
1069   let Inst{31-18} = 0b00000101110000;
1070   let Inst{17-5} = imms;
1071   let Inst{4-0} = Zd;
1072
1073   let isReMaterializable = 1;
1074   let DecoderMethod = "DecodeSVELogicalImmInstruction";
1075 }
1076
1077 multiclass sve_int_dup_mask_imm<string asm> {
1078   def NAME : sve_int_dup_mask_imm<asm>;
1079
1080   def : InstAlias<"dupm $Zd, $imm",
1081                   (!cast<Instruction>(NAME) ZPR8:$Zd, sve_logical_imm8:$imm), 4>;
1082   def : InstAlias<"dupm $Zd, $imm",
1083                   (!cast<Instruction>(NAME) ZPR16:$Zd, sve_logical_imm16:$imm), 3>;
1084   def : InstAlias<"dupm $Zd, $imm",
1085                   (!cast<Instruction>(NAME) ZPR32:$Zd, sve_logical_imm32:$imm), 2>;
1086
1087   // All Zd.b forms have a CPY/DUP equivalent, hence no byte alias here.
1088   def : InstAlias<"mov $Zd, $imm",
1089                   (!cast<Instruction>(NAME) ZPR16:$Zd, sve_preferred_logical_imm16:$imm), 7>;
1090   def : InstAlias<"mov $Zd, $imm",
1091                   (!cast<Instruction>(NAME) ZPR32:$Zd, sve_preferred_logical_imm32:$imm), 6>;
1092   def : InstAlias<"mov $Zd, $imm",
1093                   (!cast<Instruction>(NAME) ZPR64:$Zd, sve_preferred_logical_imm64:$imm), 5>;
1094 }
1095
1096 //===----------------------------------------------------------------------===//
1097 // SVE Integer Arithmetic -  Unpredicated Group.
1098 //===----------------------------------------------------------------------===//
1099
1100 class sve_int_bin_cons_arit_0<bits<2> sz8_64, bits<3> opc, string asm,
1101                               ZPRRegOp zprty>
1102 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty:$Zm),
1103   asm, "\t$Zd, $Zn, $Zm",
1104   "", []>, Sched<[]> {
1105   bits<5> Zd;
1106   bits<5> Zm;
1107   bits<5> Zn;
1108   let Inst{31-24} = 0b00000100;
1109   let Inst{23-22} = sz8_64;
1110   let Inst{21}    = 0b1;
1111   let Inst{20-16} = Zm;
1112   let Inst{15-13} = 0b000;
1113   let Inst{12-10} = opc;
1114   let Inst{9-5}   = Zn;
1115   let Inst{4-0}   = Zd;
1116 }
1117
1118 multiclass sve_int_bin_cons_arit_0<bits<3> opc, string asm> {
1119   def _B : sve_int_bin_cons_arit_0<0b00, opc, asm, ZPR8>;
1120   def _H : sve_int_bin_cons_arit_0<0b01, opc, asm, ZPR16>;
1121   def _S : sve_int_bin_cons_arit_0<0b10, opc, asm, ZPR32>;
1122   def _D : sve_int_bin_cons_arit_0<0b11, opc, asm, ZPR64>;
1123 }
1124
1125 //===----------------------------------------------------------------------===//
1126 // SVE Floating Point Arithmetic - Predicated Group
1127 //===----------------------------------------------------------------------===//
1128
1129 class sve_fp_2op_i_p_zds<bits<2> sz, bits<3> opc, string asm,
1130                          ZPRRegOp zprty,
1131                          Operand imm_ty>
1132 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, imm_ty:$i1),
1133   asm, "\t$Zdn, $Pg/m, $_Zdn, $i1",
1134   "",
1135   []>, Sched<[]> {
1136   bits<3> Pg;
1137   bits<5> Zdn;
1138   bit i1;
1139   let Inst{31-24} = 0b01100101;
1140   let Inst{23-22} = sz;
1141   let Inst{21-19} = 0b011;
1142   let Inst{18-16} = opc;
1143   let Inst{15-13} = 0b100;
1144   let Inst{12-10} = Pg;
1145   let Inst{9-6}   = 0b0000;
1146   let Inst{5}     = i1;
1147   let Inst{4-0}   = Zdn;
1148
1149   let Constraints = "$Zdn = $_Zdn";
1150   let DestructiveInstType = Destructive;
1151   let ElementSize = zprty.ElementSize;
1152 }
1153
1154 multiclass sve_fp_2op_i_p_zds<bits<3> opc, string asm, Operand imm_ty> {
1155   def _H : sve_fp_2op_i_p_zds<0b01, opc, asm, ZPR16, imm_ty>;
1156   def _S : sve_fp_2op_i_p_zds<0b10, opc, asm, ZPR32, imm_ty>;
1157   def _D : sve_fp_2op_i_p_zds<0b11, opc, asm, ZPR64, imm_ty>;
1158 }
1159
1160 class sve_fp_2op_p_zds<bits<2> sz, bits<4> opc, string asm,
1161                        ZPRRegOp zprty>
1162 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
1163   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm",
1164   "",
1165   []>, Sched<[]> {
1166   bits<3> Pg;
1167   bits<5> Zdn;
1168   bits<5> Zm;
1169   let Inst{31-24} = 0b01100101;
1170   let Inst{23-22} = sz;
1171   let Inst{21-20} = 0b00;
1172   let Inst{19-16} = opc;
1173   let Inst{15-13} = 0b100;
1174   let Inst{12-10} = Pg;
1175   let Inst{9-5}   = Zm;
1176   let Inst{4-0}   = Zdn;
1177
1178   let Constraints = "$Zdn = $_Zdn";
1179   let DestructiveInstType = Destructive;
1180   let ElementSize = zprty.ElementSize;
1181 }
1182
1183 multiclass sve_fp_2op_p_zds<bits<4> opc, string asm> {
1184   def _H : sve_fp_2op_p_zds<0b01, opc, asm, ZPR16>;
1185   def _S : sve_fp_2op_p_zds<0b10, opc, asm, ZPR32>;
1186   def _D : sve_fp_2op_p_zds<0b11, opc, asm, ZPR64>;
1187 }
1188
1189 class sve_fp_ftmad<bits<2> sz, string asm, ZPRRegOp zprty>
1190 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, zprty:$Zm, imm0_7:$imm3),
1191   asm, "\t$Zdn, $_Zdn, $Zm, $imm3",
1192   "",
1193   []>, Sched<[]> {
1194   bits<5> Zdn;
1195   bits<5> Zm;
1196   bits<3> imm3;
1197   let Inst{31-24} = 0b01100101;
1198   let Inst{23-22} = sz;
1199   let Inst{21-19} = 0b010;
1200   let Inst{18-16} = imm3;
1201   let Inst{15-10} = 0b100000;
1202   let Inst{9-5}   = Zm;
1203   let Inst{4-0}   = Zdn;
1204
1205   let Constraints = "$Zdn = $_Zdn";
1206   let DestructiveInstType = Destructive;
1207   let ElementSize = ElementSizeNone;
1208 }
1209
1210 multiclass sve_fp_ftmad<string asm> {
1211   def _H : sve_fp_ftmad<0b01, asm, ZPR16>;
1212   def _S : sve_fp_ftmad<0b10, asm, ZPR32>;
1213   def _D : sve_fp_ftmad<0b11, asm, ZPR64>;
1214 }
1215
1216
1217 //===----------------------------------------------------------------------===//
1218 // SVE Floating Point Arithmetic - Unpredicated Group
1219 //===----------------------------------------------------------------------===//
1220
1221 class sve_fp_3op_u_zd<bits<2> sz, bits<3> opc, string asm,
1222                       ZPRRegOp zprty,
1223                       ValueType vt, ValueType vt2, SDPatternOperator op>
1224 : I<(outs zprty:$Zd), (ins  zprty:$Zn, zprty:$Zm),
1225   asm, "\t$Zd, $Zn, $Zm",
1226   "",
1227   [(set (vt zprty:$Zd), (op (vt zprty:$Zn), (vt2 zprty:$Zm)))]>, Sched<[]> {
1228   bits<5> Zd;
1229   bits<5> Zm;
1230   bits<5> Zn;
1231   let Inst{31-24} = 0b01100101;
1232   let Inst{23-22} = sz;
1233   let Inst{21}    = 0b0;
1234   let Inst{20-16} = Zm;
1235   let Inst{15-13} = 0b000;
1236   let Inst{12-10} = opc;
1237   let Inst{9-5}   = Zn;
1238   let Inst{4-0}   = Zd;
1239 }
1240
1241 multiclass sve_fp_3op_u_zd<bits<3> opc, string asm, SDPatternOperator op> {
1242   def _H : sve_fp_3op_u_zd<0b01, opc, asm, ZPR16, nxv8f16, nxv8f16, op>;
1243   def _S : sve_fp_3op_u_zd<0b10, opc, asm, ZPR32, nxv4f32, nxv4f32, op>;
1244   def _D : sve_fp_3op_u_zd<0b11, opc, asm, ZPR64, nxv2f64, nxv2f64, op>;
1245 }
1246
1247 //===----------------------------------------------------------------------===//
1248 // SVE Floating Point Fused Multiply-Add Group
1249 //===----------------------------------------------------------------------===//
1250
1251 class sve_fp_3op_p_zds_a<bits<2> sz, bits<2> opc, string asm, ZPRRegOp zprty>
1252 : I<(outs zprty:$Zda), (ins PPR3bAny:$Pg, zprty:$_Zda, zprty:$Zn, zprty:$Zm),
1253   asm, "\t$Zda, $Pg/m, $Zn, $Zm",
1254   "",
1255   []>, Sched<[]> {
1256   bits<3> Pg;
1257   bits<5> Zda;
1258   bits<5> Zm;
1259   bits<5> Zn;
1260   let Inst{31-24} = 0b01100101;
1261   let Inst{23-22} = sz;
1262   let Inst{21}    = 0b1;
1263   let Inst{20-16} = Zm;
1264   let Inst{15}    = 0b0;
1265   let Inst{14-13} = opc;
1266   let Inst{12-10} = Pg;
1267   let Inst{9-5}   = Zn;
1268   let Inst{4-0}   = Zda;
1269
1270   let Constraints = "$Zda = $_Zda";
1271   let DestructiveInstType = Destructive;
1272   let ElementSize = zprty.ElementSize;
1273 }
1274
1275 multiclass sve_fp_3op_p_zds_a<bits<2> opc, string asm> {
1276   def _H : sve_fp_3op_p_zds_a<0b01, opc, asm, ZPR16>;
1277   def _S : sve_fp_3op_p_zds_a<0b10, opc, asm, ZPR32>;
1278   def _D : sve_fp_3op_p_zds_a<0b11, opc, asm, ZPR64>;
1279 }
1280
1281 class sve_fp_3op_p_zds_b<bits<2> sz, bits<2> opc, string asm,
1282                          ZPRRegOp zprty>
1283 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm, zprty:$Za),
1284   asm, "\t$Zdn, $Pg/m, $Zm, $Za",
1285   "",
1286   []>, Sched<[]> {
1287   bits<3> Pg;
1288   bits<5> Za;
1289   bits<5> Zdn;
1290   bits<5> Zm;
1291   let Inst{31-24} = 0b01100101;
1292   let Inst{23-22} = sz;
1293   let Inst{21}    = 0b1;
1294   let Inst{20-16} = Za;
1295   let Inst{15}    = 0b1;
1296   let Inst{14-13} = opc;
1297   let Inst{12-10} = Pg;
1298   let Inst{9-5}   = Zm;
1299   let Inst{4-0}   = Zdn;
1300
1301   let Constraints = "$Zdn = $_Zdn";
1302   let DestructiveInstType = Destructive;
1303   let ElementSize = zprty.ElementSize;
1304 }
1305
1306 multiclass sve_fp_3op_p_zds_b<bits<2> opc, string asm> {
1307   def _H : sve_fp_3op_p_zds_b<0b01, opc, asm, ZPR16>;
1308   def _S : sve_fp_3op_p_zds_b<0b10, opc, asm, ZPR32>;
1309   def _D : sve_fp_3op_p_zds_b<0b11, opc, asm, ZPR64>;
1310 }
1311
1312 //===----------------------------------------------------------------------===//
1313 // SVE Floating Point Multiply-Add - Indexed Group
1314 //===----------------------------------------------------------------------===//
1315
1316 class sve_fp_fma_by_indexed_elem<bits<2> sz, bit opc, string asm,
1317                                  ZPRRegOp zprty1,
1318                                  ZPRRegOp zprty2, Operand itype>
1319 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty1:$Zn, zprty2:$Zm, itype:$iop),
1320   asm, "\t$Zda, $Zn, $Zm$iop", "", []>, Sched<[]> {
1321   bits<5> Zda;
1322   bits<5> Zn;
1323   let Inst{31-24} = 0b01100100;
1324   let Inst{23-22} = sz;
1325   let Inst{21}    = 0b1;
1326   let Inst{15-11} = 0;
1327   let Inst{10}    = opc;
1328   let Inst{9-5}   = Zn;
1329   let Inst{4-0}   = Zda;
1330
1331   let Constraints = "$Zda = $_Zda";
1332   let DestructiveInstType = Destructive;
1333   let ElementSize = ElementSizeNone;
1334 }
1335
1336 multiclass sve_fp_fma_by_indexed_elem<bit opc, string asm> {
1337   def _H : sve_fp_fma_by_indexed_elem<{0, ?}, opc, asm, ZPR16, ZPR3b16, VectorIndexH> {
1338     bits<3> Zm;
1339     bits<3> iop;
1340     let Inst{22} = iop{2};
1341     let Inst{20-19} = iop{1-0};
1342     let Inst{18-16} = Zm;
1343   }
1344   def _S : sve_fp_fma_by_indexed_elem<0b10, opc, asm, ZPR32, ZPR3b32, VectorIndexS> {
1345     bits<3> Zm;
1346     bits<2> iop;
1347     let Inst{20-19} = iop;
1348     let Inst{18-16} = Zm;
1349   }
1350   def _D : sve_fp_fma_by_indexed_elem<0b11, opc, asm, ZPR64, ZPR4b64, VectorIndexD> {
1351     bits<4> Zm;
1352     bit iop;
1353     let Inst{20} = iop;
1354     let Inst{19-16} = Zm;
1355   }
1356 }
1357
1358
1359 //===----------------------------------------------------------------------===//
1360 // SVE Floating Point Multiply - Indexed Group
1361 //===----------------------------------------------------------------------===//
1362
1363 class sve_fp_fmul_by_indexed_elem<bits<2> sz, string asm, ZPRRegOp zprty,
1364                                       ZPRRegOp zprty2, Operand itype>
1365 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty2:$Zm, itype:$iop),
1366   asm, "\t$Zd, $Zn, $Zm$iop", "", []>, Sched<[]> {
1367   bits<5> Zd;
1368   bits<5> Zn;
1369   let Inst{31-24} = 0b01100100;
1370   let Inst{23-22} = sz;
1371   let Inst{21}    = 0b1;
1372   let Inst{15-10} = 0b001000;
1373   let Inst{9-5}   = Zn;
1374   let Inst{4-0}   = Zd;
1375 }
1376
1377 multiclass sve_fp_fmul_by_indexed_elem<string asm> {
1378   def _H : sve_fp_fmul_by_indexed_elem<{0, ?}, asm, ZPR16, ZPR3b16, VectorIndexH> {
1379     bits<3> Zm;
1380     bits<3> iop;
1381     let Inst{22} = iop{2};
1382     let Inst{20-19} = iop{1-0};
1383     let Inst{18-16} = Zm;
1384   }
1385   def _S : sve_fp_fmul_by_indexed_elem<0b10, asm, ZPR32, ZPR3b32, VectorIndexS> {
1386     bits<3> Zm;
1387     bits<2> iop;
1388     let Inst{20-19} = iop;
1389     let Inst{18-16} = Zm;
1390   }
1391   def _D : sve_fp_fmul_by_indexed_elem<0b11, asm, ZPR64, ZPR4b64, VectorIndexD> {
1392     bits<4> Zm;
1393     bit iop;
1394     let Inst{20} = iop;
1395     let Inst{19-16} = Zm;
1396   }
1397 }
1398
1399 //===----------------------------------------------------------------------===//
1400 // SVE Floating Point Complex Multiply-Add Group
1401 //===----------------------------------------------------------------------===//
1402
1403 class sve_fp_fcmla<bits<2> sz, string asm, ZPRRegOp zprty>
1404 : I<(outs zprty:$Zda), (ins PPR3bAny:$Pg, zprty:$_Zda, zprty:$Zn, zprty:$Zm,
1405                         complexrotateop:$imm),
1406   asm, "\t$Zda, $Pg/m, $Zn, $Zm, $imm",
1407   "", []>, Sched<[]> {
1408   bits<5> Zda;
1409   bits<3> Pg;
1410   bits<5> Zn;
1411   bits<5> Zm;
1412   bits<2> imm;
1413   let Inst{31-24} = 0b01100100;
1414   let Inst{23-22} = sz;
1415   let Inst{21}    = 0;
1416   let Inst{20-16} = Zm;
1417   let Inst{15}    = 0;
1418   let Inst{14-13} = imm;
1419   let Inst{12-10} = Pg;
1420   let Inst{9-5}   = Zn;
1421   let Inst{4-0}   = Zda;
1422
1423   let Constraints = "$Zda = $_Zda";
1424   let DestructiveInstType = Destructive;
1425   let ElementSize = zprty.ElementSize;
1426 }
1427
1428 multiclass sve_fp_fcmla<string asm> {
1429   def _H : sve_fp_fcmla<0b01, asm, ZPR16>;
1430   def _S : sve_fp_fcmla<0b10, asm, ZPR32>;
1431   def _D : sve_fp_fcmla<0b11, asm, ZPR64>;
1432 }
1433
1434 //===----------------------------------------------------------------------===//
1435 // SVE Floating Point Complex Multiply-Add - Indexed Group
1436 //===----------------------------------------------------------------------===//
1437
1438 class sve_fp_fcmla_by_indexed_elem<bits<2> sz, string asm,
1439                                    ZPRRegOp zprty,
1440                                    ZPRRegOp zprty2, Operand itype>
1441 : I<(outs zprty:$Zda), (ins zprty:$_Zda, zprty:$Zn, zprty2:$Zm, itype:$iop,
1442                         complexrotateop:$imm),
1443   asm, "\t$Zda, $Zn, $Zm$iop, $imm",
1444   "", []>, Sched<[]> {
1445   bits<5> Zda;
1446   bits<5> Zn;
1447   bits<2> imm;
1448   let Inst{31-24} = 0b01100100;
1449   let Inst{23-22} = sz;
1450   let Inst{21}    = 0b1;
1451   let Inst{15-12} = 0b0001;
1452   let Inst{11-10} = imm;
1453   let Inst{9-5}   = Zn;
1454   let Inst{4-0}   = Zda;
1455
1456   let Constraints = "$Zda = $_Zda";
1457   let DestructiveInstType = Destructive;
1458   let ElementSize = ElementSizeNone;
1459 }
1460
1461 multiclass sve_fp_fcmla_by_indexed_elem<string asm> {
1462   def _H : sve_fp_fcmla_by_indexed_elem<0b10, asm, ZPR16, ZPR3b16, VectorIndexS> {
1463     bits<3> Zm;
1464     bits<2> iop;
1465     let Inst{20-19} = iop;
1466     let Inst{18-16} = Zm;
1467   }
1468   def _S : sve_fp_fcmla_by_indexed_elem<0b11, asm, ZPR32, ZPR4b32, VectorIndexD> {
1469     bits<4> Zm;
1470     bits<1> iop;
1471     let Inst{20} = iop;
1472     let Inst{19-16} = Zm;
1473   }
1474 }
1475
1476 //===----------------------------------------------------------------------===//
1477 // SVE Floating Point Complex Addition Group
1478 //===----------------------------------------------------------------------===//
1479
1480 class sve_fp_fcadd<bits<2> sz, string asm, ZPRRegOp zprty>
1481 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm,
1482                         complexrotateopodd:$imm),
1483   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm, $imm",
1484   "",
1485   []>, Sched<[]> {
1486   bits<5> Zdn;
1487   bits<5> Zm;
1488   bits<3> Pg;
1489   bit imm;
1490   let Inst{31-24} = 0b01100100;
1491   let Inst{23-22} = sz;
1492   let Inst{21-17} = 0;
1493   let Inst{16}    = imm;
1494   let Inst{15-13} = 0b100;
1495   let Inst{12-10} = Pg;
1496   let Inst{9-5}   = Zm;
1497   let Inst{4-0}   = Zdn;
1498
1499   let Constraints = "$Zdn = $_Zdn";
1500   let DestructiveInstType = Destructive;
1501   let ElementSize = zprty.ElementSize;
1502 }
1503
1504 multiclass sve_fp_fcadd<string asm> {
1505   def _H : sve_fp_fcadd<0b01, asm, ZPR16>;
1506   def _S : sve_fp_fcadd<0b10, asm, ZPR32>;
1507   def _D : sve_fp_fcadd<0b11, asm, ZPR64>;
1508 }
1509
1510 //===----------------------------------------------------------------------===//
1511 // SVE2 Floating Point Convert Group
1512 //===----------------------------------------------------------------------===//
1513
1514 class sve2_fp_convert_precision<bits<4> opc, string asm,
1515                                 ZPRRegOp zprty1, ZPRRegOp zprty2>
1516 : I<(outs zprty1:$Zd), (ins zprty1:$_Zd, PPR3bAny:$Pg, zprty2:$Zn),
1517   asm, "\t$Zd, $Pg/m, $Zn",
1518   "",
1519   []>, Sched<[]> {
1520   bits<5> Zd;
1521   bits<5> Zn;
1522   bits<3> Pg;
1523   let Inst{31-24} = 0b01100100;
1524   let Inst{23-22} = opc{3-2};
1525   let Inst{21-18} = 0b0010;
1526   let Inst{17-16} = opc{1-0};
1527   let Inst{15-13} = 0b101;
1528   let Inst{12-10} = Pg;
1529   let Inst{9-5}   = Zn;
1530   let Inst{4-0}   = Zd;
1531
1532   let Constraints = "$Zd = $_Zd";
1533 }
1534
1535 multiclass sve2_fp_convert_down_narrow<string asm> {
1536   def _StoH : sve2_fp_convert_precision<0b1000, asm, ZPR16, ZPR32>;
1537   def _DtoS : sve2_fp_convert_precision<0b1110, asm, ZPR32, ZPR64>;
1538 }
1539
1540 multiclass sve2_fp_convert_up_long<string asm> {
1541   def _HtoS : sve2_fp_convert_precision<0b1001, asm, ZPR32, ZPR16>;
1542   def _StoD : sve2_fp_convert_precision<0b1111, asm, ZPR64, ZPR32>;
1543 }
1544
1545 multiclass sve2_fp_convert_down_odd_rounding<string asm> {
1546   def _DtoS : sve2_fp_convert_precision<0b0010, asm, ZPR32, ZPR64>;
1547 }
1548
1549 //===----------------------------------------------------------------------===//
1550 // SVE2 Floating Point Pairwise Group
1551 //===----------------------------------------------------------------------===//
1552
1553 class sve2_fp_pairwise_pred<bits<2> sz, bits<3> opc, string asm,
1554                             ZPRRegOp zprty>
1555 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
1556   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm",
1557   "",
1558   []>, Sched<[]> {
1559   bits<3> Pg;
1560   bits<5> Zm;
1561   bits<5> Zdn;
1562   let Inst{31-24} = 0b01100100;
1563   let Inst{23-22} = sz;
1564   let Inst{21-19} = 0b010;
1565   let Inst{18-16} = opc;
1566   let Inst{15-13} = 0b100;
1567   let Inst{12-10} = Pg;
1568   let Inst{9-5}   = Zm;
1569   let Inst{4-0}   = Zdn;
1570
1571   let Constraints = "$Zdn = $_Zdn";
1572   let DestructiveInstType = Destructive;
1573   let ElementSize = zprty.ElementSize;
1574 }
1575
1576 multiclass sve2_fp_pairwise_pred<bits<3> opc, string asm> {
1577   def _H : sve2_fp_pairwise_pred<0b01, opc, asm, ZPR16>;
1578   def _S : sve2_fp_pairwise_pred<0b10, opc, asm, ZPR32>;
1579   def _D : sve2_fp_pairwise_pred<0b11, opc, asm, ZPR64>;
1580 }
1581
1582 //===----------------------------------------------------------------------===//
1583 // SVE2 Floating Point Widening Multiply-Add - Indexed Group
1584 //===----------------------------------------------------------------------===//
1585
1586 class sve2_fp_mla_long_by_indexed_elem<bits<2> opc, string asm>
1587 : I<(outs ZPR32:$Zda), (ins ZPR32:$_Zda, ZPR16:$Zn, ZPR3b16:$Zm,
1588                         VectorIndexH:$iop),
1589   asm, "\t$Zda, $Zn, $Zm$iop",
1590   "",
1591   []>, Sched<[]> {
1592   bits<5> Zda;
1593   bits<5> Zn;
1594   bits<3> Zm;
1595   bits<3> iop;
1596   let Inst{31-21} = 0b01100100101;
1597   let Inst{20-19} = iop{2-1};
1598   let Inst{18-16} = Zm;
1599   let Inst{15-14} = 0b01;
1600   let Inst{13}    = opc{1};
1601   let Inst{12}    = 0b0;
1602   let Inst{11}    = iop{0};
1603   let Inst{10}    = opc{0};
1604   let Inst{9-5}   = Zn;
1605   let Inst{4-0}   = Zda;
1606
1607   let Constraints = "$Zda = $_Zda";
1608   let DestructiveInstType = Destructive;
1609   let ElementSize = ElementSizeNone;
1610 }
1611
1612 //===----------------------------------------------------------------------===//
1613 // SVE2 Floating Point Widening Multiply-Add Group
1614 //===----------------------------------------------------------------------===//
1615
1616 class sve2_fp_mla_long<bits<2> opc, string asm>
1617 : I<(outs ZPR32:$Zda), (ins ZPR32:$_Zda, ZPR16:$Zn, ZPR16:$Zm),
1618   asm, "\t$Zda, $Zn, $Zm",
1619   "",
1620   []>, Sched<[]> {
1621   bits<5> Zda;
1622   bits<5> Zn;
1623   bits<5> Zm;
1624   let Inst{31-21} = 0b01100100101;
1625   let Inst{20-16} = Zm;
1626   let Inst{15-14} = 0b10;
1627   let Inst{13}    = opc{1};
1628   let Inst{12-11} = 0b00;
1629   let Inst{10}    = opc{0};
1630   let Inst{9-5}   = Zn;
1631   let Inst{4-0}   = Zda;
1632
1633   let Constraints = "$Zda = $_Zda";
1634   let DestructiveInstType = Destructive;
1635   let ElementSize = ElementSizeNone;
1636 }
1637
1638 //===----------------------------------------------------------------------===//
1639 // SVE Stack Allocation Group
1640 //===----------------------------------------------------------------------===//
1641
1642 class sve_int_arith_vl<bit opc, string asm>
1643 : I<(outs GPR64sp:$Rd), (ins GPR64sp:$Rn, simm6_32b:$imm6),
1644   asm, "\t$Rd, $Rn, $imm6",
1645   "",
1646   []>, Sched<[]> {
1647   bits<5> Rd;
1648   bits<5> Rn;
1649   bits<6> imm6;
1650   let Inst{31-23} = 0b000001000;
1651   let Inst{22}    = opc;
1652   let Inst{21}    = 0b1;
1653   let Inst{20-16} = Rn;
1654   let Inst{15-11} = 0b01010;
1655   let Inst{10-5}  = imm6;
1656   let Inst{4-0}   = Rd;
1657 }
1658
1659 class sve_int_read_vl_a<bit op, bits<5> opc2, string asm>
1660 : I<(outs GPR64:$Rd), (ins simm6_32b:$imm6),
1661   asm, "\t$Rd, $imm6",
1662   "",
1663   []>, Sched<[]> {
1664   bits<5> Rd;
1665   bits<6> imm6;
1666   let Inst{31-23} = 0b000001001;
1667   let Inst{22}    = op;
1668   let Inst{21}    = 0b1;
1669   let Inst{20-16} = opc2{4-0};
1670   let Inst{15-11} = 0b01010;
1671   let Inst{10-5}  = imm6;
1672   let Inst{4-0}   = Rd;
1673 }
1674
1675 //===----------------------------------------------------------------------===//
1676 // SVE Permute - In Lane Group
1677 //===----------------------------------------------------------------------===//
1678
1679 class sve_int_perm_bin_perm_zz<bits<3> opc, bits<2> sz8_64, string asm,
1680                                ZPRRegOp zprty>
1681 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty:$Zm),
1682   asm, "\t$Zd, $Zn, $Zm",
1683   "",
1684   []>, Sched<[]> {
1685   bits<5> Zd;
1686   bits<5> Zm;
1687   bits<5> Zn;
1688   let Inst{31-24} = 0b00000101;
1689   let Inst{23-22} = sz8_64;
1690   let Inst{21}    = 0b1;
1691   let Inst{20-16} = Zm;
1692   let Inst{15-13} = 0b011;
1693   let Inst{12-10} = opc;
1694   let Inst{9-5}   = Zn;
1695   let Inst{4-0}   = Zd;
1696 }
1697
1698 multiclass sve_int_perm_bin_perm_zz<bits<3> opc, string asm> {
1699   def _B : sve_int_perm_bin_perm_zz<opc, 0b00, asm, ZPR8>;
1700   def _H : sve_int_perm_bin_perm_zz<opc, 0b01, asm, ZPR16>;
1701   def _S : sve_int_perm_bin_perm_zz<opc, 0b10, asm, ZPR32>;
1702   def _D : sve_int_perm_bin_perm_zz<opc, 0b11, asm, ZPR64>;
1703 }
1704
1705 //===----------------------------------------------------------------------===//
1706 // SVE Floating Point Unary Operations Group
1707 //===----------------------------------------------------------------------===//
1708
1709 class sve_fp_2op_p_zd<bits<7> opc, string asm, RegisterOperand i_zprtype,
1710                       RegisterOperand o_zprtype, ElementSizeEnum size>
1711 : I<(outs o_zprtype:$Zd), (ins i_zprtype:$_Zd, PPR3bAny:$Pg, i_zprtype:$Zn),
1712   asm, "\t$Zd, $Pg/m, $Zn",
1713   "",
1714   []>, Sched<[]> {
1715   bits<3> Pg;
1716   bits<5> Zd;
1717   bits<5> Zn;
1718   let Inst{31-24} = 0b01100101;
1719   let Inst{23-22} = opc{6-5};
1720   let Inst{21}    = 0b0;
1721   let Inst{20-16} = opc{4-0};
1722   let Inst{15-13} = 0b101;
1723   let Inst{12-10} = Pg;
1724   let Inst{9-5}   = Zn;
1725   let Inst{4-0}   = Zd;
1726
1727   let Constraints = "$Zd = $_Zd";
1728   let DestructiveInstType = Destructive;
1729   let ElementSize = size;
1730 }
1731
1732 multiclass sve_fp_2op_p_zd_HSD<bits<5> opc, string asm> {
1733   def _H : sve_fp_2op_p_zd<{ 0b01, opc }, asm, ZPR16, ZPR16, ElementSizeH>;
1734   def _S : sve_fp_2op_p_zd<{ 0b10, opc }, asm, ZPR32, ZPR32, ElementSizeS>;
1735   def _D : sve_fp_2op_p_zd<{ 0b11, opc }, asm, ZPR64, ZPR64, ElementSizeD>;
1736 }
1737
1738 multiclass sve2_fp_flogb<string asm> {
1739   def _H : sve_fp_2op_p_zd<0b0011010, asm, ZPR16, ZPR16, ElementSizeH>;
1740   def _S : sve_fp_2op_p_zd<0b0011100, asm, ZPR32, ZPR32, ElementSizeS>;
1741   def _D : sve_fp_2op_p_zd<0b0011110, asm, ZPR64, ZPR64, ElementSizeD>;
1742 }
1743
1744 //===----------------------------------------------------------------------===//
1745 // SVE Floating Point Unary Operations - Unpredicated Group
1746 //===----------------------------------------------------------------------===//
1747
1748 class sve_fp_2op_u_zd<bits<2> sz, bits<3> opc, string asm,
1749                       ZPRRegOp zprty>
1750 : I<(outs zprty:$Zd), (ins zprty:$Zn),
1751   asm, "\t$Zd, $Zn",
1752   "",
1753   []>, Sched<[]> {
1754   bits<5> Zd;
1755   bits<5> Zn;
1756   let Inst{31-24} = 0b01100101;
1757   let Inst{23-22} = sz;
1758   let Inst{21-19} = 0b001;
1759   let Inst{18-16} = opc;
1760   let Inst{15-10} = 0b001100;
1761   let Inst{9-5}   = Zn;
1762   let Inst{4-0}   = Zd;
1763 }
1764
1765 multiclass sve_fp_2op_u_zd<bits<3> opc, string asm> {
1766   def _H : sve_fp_2op_u_zd<0b01, opc, asm, ZPR16>;
1767   def _S : sve_fp_2op_u_zd<0b10, opc, asm, ZPR32>;
1768   def _D : sve_fp_2op_u_zd<0b11, opc, asm, ZPR64>;
1769 }
1770
1771 //===----------------------------------------------------------------------===//
1772 // SVE Integer Arithmetic - Binary Predicated Group
1773 //===----------------------------------------------------------------------===//
1774
1775 class sve_int_bin_pred_arit_log<bits<2> sz8_64, bits<2> fmt, bits<3> opc,
1776                                 string asm, ZPRRegOp zprty>
1777 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
1778   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm", "", []>, Sched<[]> {
1779   bits<3> Pg;
1780   bits<5> Zdn;
1781   bits<5> Zm;
1782   let Inst{31-24} = 0b00000100;
1783   let Inst{23-22} = sz8_64;
1784   let Inst{21}    = 0b0;
1785   let Inst{20-19} = fmt;
1786   let Inst{18-16} = opc;
1787   let Inst{15-13} = 0b000;
1788   let Inst{12-10} = Pg;
1789   let Inst{9-5}   = Zm;
1790   let Inst{4-0}   = Zdn;
1791
1792   let Constraints = "$Zdn = $_Zdn";
1793   let DestructiveInstType = Destructive;
1794   let ElementSize = zprty.ElementSize;
1795 }
1796
1797 multiclass sve_int_bin_pred_log<bits<3> opc, string asm> {
1798   def _B : sve_int_bin_pred_arit_log<0b00, 0b11, opc, asm, ZPR8>;
1799   def _H : sve_int_bin_pred_arit_log<0b01, 0b11, opc, asm, ZPR16>;
1800   def _S : sve_int_bin_pred_arit_log<0b10, 0b11, opc, asm, ZPR32>;
1801   def _D : sve_int_bin_pred_arit_log<0b11, 0b11, opc, asm, ZPR64>;
1802 }
1803
1804 multiclass sve_int_bin_pred_arit_0<bits<3> opc, string asm> {
1805   def _B : sve_int_bin_pred_arit_log<0b00, 0b00, opc, asm, ZPR8>;
1806   def _H : sve_int_bin_pred_arit_log<0b01, 0b00, opc, asm, ZPR16>;
1807   def _S : sve_int_bin_pred_arit_log<0b10, 0b00, opc, asm, ZPR32>;
1808   def _D : sve_int_bin_pred_arit_log<0b11, 0b00, opc, asm, ZPR64>;
1809 }
1810
1811 multiclass sve_int_bin_pred_arit_1<bits<3> opc, string asm> {
1812   def _B : sve_int_bin_pred_arit_log<0b00, 0b01, opc, asm, ZPR8>;
1813   def _H : sve_int_bin_pred_arit_log<0b01, 0b01, opc, asm, ZPR16>;
1814   def _S : sve_int_bin_pred_arit_log<0b10, 0b01, opc, asm, ZPR32>;
1815   def _D : sve_int_bin_pred_arit_log<0b11, 0b01, opc, asm, ZPR64>;
1816 }
1817
1818 multiclass sve_int_bin_pred_arit_2<bits<3> opc, string asm> {
1819   def _B : sve_int_bin_pred_arit_log<0b00, 0b10, opc, asm, ZPR8>;
1820   def _H : sve_int_bin_pred_arit_log<0b01, 0b10, opc, asm, ZPR16>;
1821   def _S : sve_int_bin_pred_arit_log<0b10, 0b10, opc, asm, ZPR32>;
1822   def _D : sve_int_bin_pred_arit_log<0b11, 0b10, opc, asm, ZPR64>;
1823 }
1824
1825 // Special case for divides which are not defined for 8b/16b elements.
1826 multiclass sve_int_bin_pred_arit_2_div<bits<3> opc, string asm> {
1827   def _S : sve_int_bin_pred_arit_log<0b10, 0b10, opc, asm, ZPR32>;
1828   def _D : sve_int_bin_pred_arit_log<0b11, 0b10, opc, asm, ZPR64>;
1829 }
1830
1831 //===----------------------------------------------------------------------===//
1832 // SVE Integer Multiply-Add Group
1833 //===----------------------------------------------------------------------===//
1834
1835 class sve_int_mladdsub_vvv_pred<bits<2> sz8_64, bits<1> opc, string asm,
1836                                 ZPRRegOp zprty>
1837 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm, zprty:$Za),
1838   asm, "\t$Zdn, $Pg/m, $Zm, $Za",
1839   "",
1840   []>, Sched<[]> {
1841   bits<3> Pg;
1842   bits<5> Zdn;
1843   bits<5> Za;
1844   bits<5> Zm;
1845   let Inst{31-24} = 0b00000100;
1846   let Inst{23-22} = sz8_64;
1847   let Inst{21}    = 0b0;
1848   let Inst{20-16} = Zm;
1849   let Inst{15-14} = 0b11;
1850   let Inst{13}    = opc;
1851   let Inst{12-10} = Pg;
1852   let Inst{9-5}   = Za;
1853   let Inst{4-0}   = Zdn;
1854
1855   let Constraints = "$Zdn = $_Zdn";
1856   let DestructiveInstType = Destructive;
1857   let ElementSize = zprty.ElementSize;
1858 }
1859
1860 multiclass sve_int_mladdsub_vvv_pred<bits<1> opc, string asm> {
1861   def _B : sve_int_mladdsub_vvv_pred<0b00, opc, asm, ZPR8>;
1862   def _H : sve_int_mladdsub_vvv_pred<0b01, opc, asm, ZPR16>;
1863   def _S : sve_int_mladdsub_vvv_pred<0b10, opc, asm, ZPR32>;
1864   def _D : sve_int_mladdsub_vvv_pred<0b11, opc, asm, ZPR64>;
1865 }
1866
1867 class sve_int_mlas_vvv_pred<bits<2> sz8_64, bits<1> opc, string asm,
1868                             ZPRRegOp zprty>
1869 : I<(outs zprty:$Zda), (ins PPR3bAny:$Pg, zprty:$_Zda, zprty:$Zn, zprty:$Zm),
1870   asm, "\t$Zda, $Pg/m, $Zn, $Zm",
1871   "",
1872   []>, Sched<[]> {
1873   bits<3> Pg;
1874   bits<5> Zda;
1875   bits<5> Zm;
1876   bits<5> Zn;
1877   let Inst{31-24} = 0b00000100;
1878   let Inst{23-22} = sz8_64;
1879   let Inst{21}    = 0b0;
1880   let Inst{20-16} = Zm;
1881   let Inst{15-14} = 0b01;
1882   let Inst{13}    = opc;
1883   let Inst{12-10} = Pg;
1884   let Inst{9-5}   = Zn;
1885   let Inst{4-0}   = Zda;
1886
1887   let Constraints = "$Zda = $_Zda";
1888   let DestructiveInstType = Destructive;
1889   let ElementSize = zprty.ElementSize;
1890 }
1891
1892 multiclass sve_int_mlas_vvv_pred<bits<1> opc, string asm> {
1893   def _B : sve_int_mlas_vvv_pred<0b00, opc, asm, ZPR8>;
1894   def _H : sve_int_mlas_vvv_pred<0b01, opc, asm, ZPR16>;
1895   def _S : sve_int_mlas_vvv_pred<0b10, opc, asm, ZPR32>;
1896   def _D : sve_int_mlas_vvv_pred<0b11, opc, asm, ZPR64>;
1897 }
1898
1899 //===----------------------------------------------------------------------===//
1900 // SVE2 Integer Multiply-Add - Unpredicated Group
1901 //===----------------------------------------------------------------------===//
1902
1903 class sve2_int_mla<bits<2> sz, bits<5> opc, string asm,
1904                    ZPRRegOp zprty1, ZPRRegOp zprty2>
1905 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty2:$Zm),
1906   asm, "\t$Zda, $Zn, $Zm", "", []>, Sched<[]> {
1907   bits<5> Zda;
1908   bits<5> Zn;
1909   bits<5> Zm;
1910   let Inst{31-24} = 0b01000100;
1911   let Inst{23-22} = sz;
1912   let Inst{21}    = 0b0;
1913   let Inst{20-16} = Zm;
1914   let Inst{15}    = 0b0;
1915   let Inst{14-10} = opc;
1916   let Inst{9-5}   = Zn;
1917   let Inst{4-0}   = Zda;
1918
1919   let Constraints = "$Zda = $_Zda";
1920   let DestructiveInstType = Destructive;
1921   let ElementSize = ElementSizeNone;
1922 }
1923
1924 multiclass sve2_int_mla<bit S, string asm> {
1925   def _B : sve2_int_mla<0b00, { 0b1110, S }, asm, ZPR8, ZPR8>;
1926   def _H : sve2_int_mla<0b01, { 0b1110, S }, asm, ZPR16, ZPR16>;
1927   def _S : sve2_int_mla<0b10, { 0b1110, S }, asm, ZPR32, ZPR32>;
1928   def _D : sve2_int_mla<0b11, { 0b1110, S }, asm, ZPR64, ZPR64>;
1929 }
1930
1931 multiclass sve2_int_mla_long<bits<5> opc, string asm> {
1932   def _H : sve2_int_mla<0b01, opc, asm, ZPR16, ZPR8>;
1933   def _S : sve2_int_mla<0b10, opc, asm, ZPR32, ZPR16>;
1934   def _D : sve2_int_mla<0b11, opc, asm, ZPR64, ZPR32>;
1935 }
1936
1937 //===----------------------------------------------------------------------===//
1938 // SVE2 Integer Multiply-Add - Indexed Group
1939 //===----------------------------------------------------------------------===//
1940
1941 class sve2_int_mla_by_indexed_elem<bits<2> sz, bits<6> opc, string asm,
1942                                    ZPRRegOp zprty1, ZPRRegOp zprty2,
1943                                    ZPRRegOp zprty3, Operand itype>
1944 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty3:$Zm, itype:$iop),
1945   asm, "\t$Zda, $Zn, $Zm$iop", "", []>, Sched<[]> {
1946   bits<5> Zda;
1947   bits<5> Zn;
1948   let Inst{31-24} = 0b01000100;
1949   let Inst{23-22} = sz;
1950   let Inst{21}    = 0b1;
1951   let Inst{15-10} = opc;
1952   let Inst{9-5}   = Zn;
1953   let Inst{4-0}   = Zda;
1954
1955   let Constraints = "$Zda = $_Zda";
1956   let DestructiveInstType = Destructive;
1957   let ElementSize = ElementSizeNone;
1958 }
1959
1960 multiclass sve2_int_mla_by_indexed_elem<bits<2> opc, bit S, string asm> {
1961   def _H : sve2_int_mla_by_indexed_elem<{0, ?}, { 0b000, opc, S }, asm, ZPR16, ZPR16, ZPR3b16, VectorIndexH> {
1962     bits<3> Zm;
1963     bits<3> iop;
1964     let Inst{22} = iop{2};
1965     let Inst{20-19} = iop{1-0};
1966     let Inst{18-16} = Zm;
1967   }
1968   def _S : sve2_int_mla_by_indexed_elem<0b10, { 0b000, opc, S }, asm, ZPR32, ZPR32, ZPR3b32, VectorIndexS> {
1969     bits<3> Zm;
1970     bits<2> iop;
1971     let Inst{20-19} = iop;
1972     let Inst{18-16} = Zm;
1973   }
1974   def _D : sve2_int_mla_by_indexed_elem<0b11, { 0b000, opc, S }, asm, ZPR64, ZPR64, ZPR4b64, VectorIndexD> {
1975     bits<4> Zm;
1976     bit iop;
1977     let Inst{20} = iop;
1978     let Inst{19-16} = Zm;
1979   }
1980 }
1981
1982 //===----------------------------------------------------------------------===//
1983 // SVE2 Integer Multiply-Add Long - Indexed Group
1984 //===----------------------------------------------------------------------===//
1985
1986 multiclass sve2_int_mla_long_by_indexed_elem<bits<4> opc, string asm> {
1987   def _S : sve2_int_mla_by_indexed_elem<0b10, { opc{3}, 0b0, opc{2-1}, ?, opc{0} },
1988                                         asm, ZPR32, ZPR16, ZPR3b16, VectorIndexH> {
1989     bits<3> Zm;
1990     bits<3> iop;
1991     let Inst{20-19} = iop{2-1};
1992     let Inst{18-16} = Zm;
1993     let Inst{11} = iop{0};
1994   }
1995   def _D : sve2_int_mla_by_indexed_elem<0b11, { opc{3}, 0b0, opc{2-1}, ?, opc{0} },
1996                                         asm, ZPR64, ZPR32, ZPR4b32, VectorIndexS> {
1997     bits<4> Zm;
1998     bits<2> iop;
1999     let Inst{20} = iop{1};
2000     let Inst{19-16} = Zm;
2001     let Inst{11} = iop{0};
2002   }
2003 }
2004
2005 //===----------------------------------------------------------------------===//
2006 // SVE Integer Dot Product Group
2007 //===----------------------------------------------------------------------===//
2008
2009 class sve_intx_dot<bit sz, bit U, string asm, ZPRRegOp zprty1,
2010                    ZPRRegOp zprty2>
2011 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty2:$Zm), asm,
2012   "\t$Zda, $Zn, $Zm", "", []>, Sched<[]> {
2013   bits<5> Zda;
2014   bits<5> Zn;
2015   bits<5> Zm;
2016   let Inst{31-23} = 0b010001001;
2017   let Inst{22}    = sz;
2018   let Inst{21}    = 0;
2019   let Inst{20-16} = Zm;
2020   let Inst{15-11} = 0;
2021   let Inst{10}    = U;
2022   let Inst{9-5}   = Zn;
2023   let Inst{4-0}   = Zda;
2024
2025   let Constraints = "$Zda = $_Zda";
2026   let DestructiveInstType = Destructive;
2027   let ElementSize = zprty1.ElementSize;
2028 }
2029
2030 multiclass sve_intx_dot<bit opc, string asm> {
2031   def _S : sve_intx_dot<0b0, opc, asm, ZPR32, ZPR8>;
2032   def _D : sve_intx_dot<0b1, opc, asm, ZPR64, ZPR16>;
2033 }
2034
2035 //===----------------------------------------------------------------------===//
2036 // SVE Integer Dot Product Group - Indexed Group
2037 //===----------------------------------------------------------------------===//
2038
2039 class sve_intx_dot_by_indexed_elem<bit sz, bit U, string asm,
2040                                    ZPRRegOp zprty1, ZPRRegOp zprty2,
2041                                    ZPRRegOp zprty3, Operand itype>
2042 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty3:$Zm, itype:$iop),
2043   asm, "\t$Zda, $Zn, $Zm$iop",
2044   "", []>, Sched<[]> {
2045   bits<5> Zda;
2046   bits<5> Zn;
2047   let Inst{31-23} = 0b010001001;
2048   let Inst{22}    = sz;
2049   let Inst{21}    = 0b1;
2050   let Inst{15-11} = 0;
2051   let Inst{10}    = U;
2052   let Inst{9-5}   = Zn;
2053   let Inst{4-0}   = Zda;
2054
2055   let Constraints = "$Zda = $_Zda";
2056   let DestructiveInstType = Destructive;
2057   let ElementSize = ElementSizeNone;
2058 }
2059
2060 multiclass sve_intx_dot_by_indexed_elem<bit opc, string asm> {
2061   def _S : sve_intx_dot_by_indexed_elem<0b0, opc, asm, ZPR32, ZPR8, ZPR3b8, VectorIndexS> {
2062     bits<2> iop;
2063     bits<3> Zm;
2064     let Inst{20-19} = iop;
2065     let Inst{18-16} = Zm;
2066   }
2067   def _D : sve_intx_dot_by_indexed_elem<0b1, opc, asm, ZPR64, ZPR16, ZPR4b16, VectorIndexD> {
2068     bits<1> iop;
2069     bits<4> Zm;
2070     let Inst{20} = iop;
2071     let Inst{19-16} = Zm;
2072   }
2073 }
2074
2075 //===----------------------------------------------------------------------===//
2076 // SVE2 Complex Integer Dot Product Group
2077 //===----------------------------------------------------------------------===//
2078
2079 class sve2_complex_int_arith<bits<2> sz, bits<4> opc, string asm,
2080                              ZPRRegOp zprty1, ZPRRegOp zprty2>
2081 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty2:$Zm,
2082                          complexrotateop:$rot),
2083   asm, "\t$Zda, $Zn, $Zm, $rot", "", []>, Sched<[]> {
2084   bits<5> Zda;
2085   bits<5> Zn;
2086   bits<5> Zm;
2087   bits<2> rot;
2088   let Inst{31-24} = 0b01000100;
2089   let Inst{23-22} = sz;
2090   let Inst{21}    = 0b0;
2091   let Inst{20-16} = Zm;
2092   let Inst{15-12} = opc;
2093   let Inst{11-10} = rot;
2094   let Inst{9-5}   = Zn;
2095   let Inst{4-0}   = Zda;
2096
2097   let Constraints = "$Zda = $_Zda";
2098   let DestructiveInstType = Destructive;
2099   let ElementSize = ElementSizeNone;
2100 }
2101
2102 multiclass sve2_cintx_dot<string asm> {
2103   def _S : sve2_complex_int_arith<0b10, 0b0001, asm, ZPR32, ZPR8>;
2104   def _D : sve2_complex_int_arith<0b11, 0b0001, asm, ZPR64, ZPR16>;
2105 }
2106
2107 //===----------------------------------------------------------------------===//
2108 // SVE2 Complex Multiply-Add Group
2109 //===----------------------------------------------------------------------===//
2110
2111 multiclass sve2_int_cmla<bit opc, string asm> {
2112   def _B : sve2_complex_int_arith<0b00, { 0b001, opc }, asm, ZPR8, ZPR8>;
2113   def _H : sve2_complex_int_arith<0b01, { 0b001, opc }, asm, ZPR16, ZPR16>;
2114   def _S : sve2_complex_int_arith<0b10, { 0b001, opc }, asm, ZPR32, ZPR32>;
2115   def _D : sve2_complex_int_arith<0b11, { 0b001, opc }, asm, ZPR64, ZPR64>;
2116 }
2117
2118 //===----------------------------------------------------------------------===//
2119 // SVE2 Complex Integer Dot Product - Indexed Group
2120 //===----------------------------------------------------------------------===//
2121
2122 class sve2_complex_int_arith_indexed<bits<2> sz, bits<4> opc, string asm,
2123                                      ZPRRegOp zprty1, ZPRRegOp zprty2,
2124                                      ZPRRegOp zprty3, Operand itype>
2125 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty3:$Zm, itype:$iop,
2126                          complexrotateop:$rot),
2127   asm, "\t$Zda, $Zn, $Zm$iop, $rot", "", []>, Sched<[]> {
2128   bits<5> Zda;
2129   bits<5> Zn;
2130   bits<2> rot;
2131   let Inst{31-24} = 0b01000100;
2132   let Inst{23-22} = sz;
2133   let Inst{21}    = 0b1;
2134   let Inst{15-12} = opc;
2135   let Inst{11-10} = rot;
2136   let Inst{9-5}   = Zn;
2137   let Inst{4-0}   = Zda;
2138
2139   let Constraints = "$Zda = $_Zda";
2140   let DestructiveInstType = Destructive;
2141   let ElementSize = ElementSizeNone;
2142 }
2143
2144 multiclass sve2_cintx_dot_by_indexed_elem<string asm> {
2145   def _S : sve2_complex_int_arith_indexed<0b10, 0b0100, asm, ZPR32, ZPR8, ZPR3b8, VectorIndexS> {
2146     bits<2> iop;
2147     bits<3> Zm;
2148     let Inst{20-19} = iop;
2149     let Inst{18-16} = Zm;
2150   }
2151   def _D : sve2_complex_int_arith_indexed<0b11, 0b0100, asm, ZPR64, ZPR16, ZPR4b16, VectorIndexD> {
2152     bit iop;
2153     bits<4> Zm;
2154     let Inst{20} = iop;
2155     let Inst{19-16} = Zm;
2156   }
2157 }
2158
2159 //===----------------------------------------------------------------------===//
2160 // SVE2 Complex Multiply-Add - Indexed Group
2161 //===----------------------------------------------------------------------===//
2162
2163 multiclass sve2_cmla_by_indexed_elem<bit opc, string asm> {
2164   def _H : sve2_complex_int_arith_indexed<0b10, { 0b011, opc }, asm, ZPR16, ZPR16, ZPR3b16, VectorIndexS> {
2165     bits<2> iop;
2166     bits<3> Zm;
2167     let Inst{20-19} = iop;
2168     let Inst{18-16} = Zm;
2169   }
2170   def _S : sve2_complex_int_arith_indexed<0b11, { 0b011, opc }, asm, ZPR32, ZPR32, ZPR4b32, VectorIndexD> {
2171     bit iop;
2172     bits<4> Zm;
2173     let Inst{20} = iop;
2174     let Inst{19-16} = Zm;
2175   }
2176 }
2177
2178 //===----------------------------------------------------------------------===//
2179 // SVE2 Integer Multiply - Unpredicated Group
2180 //===----------------------------------------------------------------------===//
2181
2182 class sve2_int_mul<bits<2> sz, bits<3> opc, string asm, ZPRRegOp zprty>
2183 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty:$Zm),
2184   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2185   bits<5> Zd;
2186   bits<5> Zm;
2187   bits<5> Zn;
2188   let Inst{31-24} = 0b00000100;
2189   let Inst{23-22} = sz;
2190   let Inst{21}    = 0b1;
2191   let Inst{20-16} = Zm;
2192   let Inst{15-13} = 0b011;
2193   let Inst{12-10} = opc;
2194   let Inst{9-5}   = Zn;
2195   let Inst{4-0}   = Zd;
2196 }
2197
2198 multiclass sve2_int_mul<bits<3> opc, string asm> {
2199   def _B : sve2_int_mul<0b00, opc, asm, ZPR8>;
2200   def _H : sve2_int_mul<0b01, opc, asm, ZPR16>;
2201   def _S : sve2_int_mul<0b10, opc, asm, ZPR32>;
2202   def _D : sve2_int_mul<0b11, opc, asm, ZPR64>;
2203 }
2204
2205 //===----------------------------------------------------------------------===//
2206 // SVE2 Integer Multiply - Indexed Group
2207 //===----------------------------------------------------------------------===//
2208
2209 class sve2_int_mul_by_indexed_elem<bits<2> sz, bits<4> opc, string asm,
2210                                    ZPRRegOp zprty1, ZPRRegOp zprty2,
2211                                    ZPRRegOp zprty3, Operand itype>
2212 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, zprty3:$Zm, itype:$iop),
2213   asm, "\t$Zd, $Zn, $Zm$iop", "", []>, Sched<[]> {
2214   bits<5> Zd;
2215   bits<5> Zn;
2216   let Inst{31-24} = 0b01000100;
2217   let Inst{23-22} = sz;
2218   let Inst{21}    = 0b1;
2219   let Inst{15-14} = 0b11;
2220   let Inst{13-10} = opc;
2221   let Inst{9-5}   = Zn;
2222   let Inst{4-0}   = Zd;
2223 }
2224
2225 multiclass sve2_int_mul_by_indexed_elem<bits<4> opc, string asm> {
2226   def _H : sve2_int_mul_by_indexed_elem<{0, ?}, opc, asm, ZPR16, ZPR16, ZPR3b16, VectorIndexH> {
2227     bits<3> Zm;
2228     bits<3> iop;
2229     let Inst{22} = iop{2};
2230     let Inst{20-19} = iop{1-0};
2231     let Inst{18-16} = Zm;
2232   }
2233   def _S : sve2_int_mul_by_indexed_elem<0b10, opc, asm, ZPR32, ZPR32, ZPR3b32, VectorIndexS> {
2234     bits<3> Zm;
2235     bits<2> iop;
2236     let Inst{20-19} = iop;
2237     let Inst{18-16} = Zm;
2238   }
2239   def _D : sve2_int_mul_by_indexed_elem<0b11, opc, asm, ZPR64, ZPR64, ZPR4b64, VectorIndexD> {
2240     bits<4> Zm;
2241     bit iop;
2242     let Inst{20} = iop;
2243     let Inst{19-16} = Zm;
2244   }
2245 }
2246
2247 multiclass sve2_int_mul_long_by_indexed_elem<bits<3> opc, string asm> {
2248   def _S : sve2_int_mul_by_indexed_elem<0b10, { opc{2-1}, ?, opc{0} }, asm,
2249                                         ZPR32, ZPR16, ZPR3b16, VectorIndexH> {
2250     bits<3> Zm;
2251     bits<3> iop;
2252     let Inst{20-19} = iop{2-1};
2253     let Inst{18-16} = Zm;
2254     let Inst{11} = iop{0};
2255   }
2256   def _D : sve2_int_mul_by_indexed_elem<0b11, { opc{2-1}, ?, opc{0} }, asm,
2257                                         ZPR64, ZPR32, ZPR4b32, VectorIndexS> {
2258     bits<4> Zm;
2259     bits<2> iop;
2260     let Inst{20} = iop{1};
2261     let Inst{19-16} = Zm;
2262     let Inst{11} = iop{0};
2263   }
2264 }
2265
2266 //===----------------------------------------------------------------------===//
2267 // SVE2 Integer - Predicated Group
2268 //===----------------------------------------------------------------------===//
2269
2270 class sve2_int_arith_pred<bits<2> sz, bits<6> opc, string asm,
2271                           ZPRRegOp zprty>
2272 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
2273   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm", "", []>, Sched<[]> {
2274   bits<3> Pg;
2275   bits<5> Zm;
2276   bits<5> Zdn;
2277   let Inst{31-24} = 0b01000100;
2278   let Inst{23-22} = sz;
2279   let Inst{21}    = 0b0;
2280   let Inst{20-16} = opc{5-1};
2281   let Inst{15-14} = 0b10;
2282   let Inst{13}    = opc{0};
2283   let Inst{12-10} = Pg;
2284   let Inst{9-5}   = Zm;
2285   let Inst{4-0}   = Zdn;
2286
2287   let Constraints = "$Zdn = $_Zdn";
2288   let DestructiveInstType = Destructive;
2289   let ElementSize = zprty.ElementSize;
2290 }
2291
2292 multiclass sve2_int_arith_pred<bits<6> opc, string asm> {
2293   def _B : sve2_int_arith_pred<0b00, opc, asm, ZPR8>;
2294   def _H : sve2_int_arith_pred<0b01, opc, asm, ZPR16>;
2295   def _S : sve2_int_arith_pred<0b10, opc, asm, ZPR32>;
2296   def _D : sve2_int_arith_pred<0b11, opc, asm, ZPR64>;
2297 }
2298
2299 class sve2_int_sadd_long_accum_pairwise<bits<2> sz, bit U, string asm,
2300                                         ZPRRegOp zprty1, ZPRRegOp zprty2>
2301 : I<(outs zprty1:$Zda), (ins PPR3bAny:$Pg, zprty1:$_Zda, zprty2:$Zn),
2302   asm, "\t$Zda, $Pg/m, $Zn", "", []>, Sched<[]> {
2303   bits<3> Pg;
2304   bits<5> Zn;
2305   bits<5> Zda;
2306   let Inst{31-24} = 0b01000100;
2307   let Inst{23-22} = sz;
2308   let Inst{21-17} = 0b00010;
2309   let Inst{16}    = U;
2310   let Inst{15-13} = 0b101;
2311   let Inst{12-10} = Pg;
2312   let Inst{9-5}   = Zn;
2313   let Inst{4-0}   = Zda;
2314
2315   let Constraints = "$Zda = $_Zda";
2316   let DestructiveInstType = Destructive;
2317   let ElementSize = zprty1.ElementSize;
2318 }
2319
2320 multiclass sve2_int_sadd_long_accum_pairwise<bit U, string asm> {
2321   def _H : sve2_int_sadd_long_accum_pairwise<0b01, U, asm, ZPR16, ZPR8>;
2322   def _S : sve2_int_sadd_long_accum_pairwise<0b10, U, asm, ZPR32, ZPR16>;
2323   def _D : sve2_int_sadd_long_accum_pairwise<0b11, U, asm, ZPR64, ZPR32>;
2324 }
2325
2326 class sve2_int_un_pred_arit<bits<2> sz, bit Q, bits<2> opc,
2327                             string asm, ZPRRegOp zprty>
2328 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPR3bAny:$Pg, zprty:$Zn),
2329   asm, "\t$Zd, $Pg/m, $Zn",
2330   "",
2331   []>, Sched<[]> {
2332   bits<3> Pg;
2333   bits<5> Zd;
2334   bits<5> Zn;
2335   let Inst{31-24} = 0b01000100;
2336   let Inst{23-22} = sz;
2337   let Inst{21-20} = 0b00;
2338   let Inst{19}    = Q;
2339   let Inst{18}    = 0b0;
2340   let Inst{17-16} = opc;
2341   let Inst{15-13} = 0b101;
2342   let Inst{12-10} = Pg;
2343   let Inst{9-5}   = Zn;
2344   let Inst{4-0}   = Zd;
2345
2346   let Constraints = "$Zd = $_Zd";
2347   let DestructiveInstType = Destructive;
2348   let ElementSize = zprty.ElementSize;
2349 }
2350
2351 multiclass sve2_int_un_pred_arit_s<bits<3> opc, string asm> {
2352   def _S : sve2_int_un_pred_arit<0b10, opc{2}, opc{1-0}, asm, ZPR32>;
2353 }
2354
2355 multiclass sve2_int_un_pred_arit<bits<3> opc, string asm> {
2356   def _B : sve2_int_un_pred_arit<0b00, opc{2}, opc{1-0}, asm, ZPR8>;
2357   def _H : sve2_int_un_pred_arit<0b01, opc{2}, opc{1-0}, asm, ZPR16>;
2358   def _S : sve2_int_un_pred_arit<0b10, opc{2}, opc{1-0}, asm, ZPR32>;
2359   def _D : sve2_int_un_pred_arit<0b11, opc{2}, opc{1-0}, asm, ZPR64>;
2360 }
2361
2362 //===----------------------------------------------------------------------===//
2363 // SVE2 Widening Integer Arithmetic Group
2364 //===----------------------------------------------------------------------===//
2365
2366 class sve2_wide_int_arith<bits<2> sz, bits<5> opc, string asm,
2367                           ZPRRegOp zprty1, ZPRRegOp zprty2, ZPRRegOp zprty3>
2368 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, zprty3:$Zm),
2369   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2370   bits<5> Zd;
2371   bits<5> Zn;
2372   bits<5> Zm;
2373   let Inst{31-24} = 0b01000101;
2374   let Inst{23-22} = sz;
2375   let Inst{21}    = 0b0;
2376   let Inst{20-16} = Zm;
2377   let Inst{15}    = 0b0;
2378   let Inst{14-10} = opc;
2379   let Inst{9-5}   = Zn;
2380   let Inst{4-0}   = Zd;
2381 }
2382
2383 multiclass sve2_wide_int_arith_long<bits<5> opc, string asm> {
2384   def _H : sve2_wide_int_arith<0b01, opc, asm, ZPR16, ZPR8, ZPR8>;
2385   def _S : sve2_wide_int_arith<0b10, opc, asm, ZPR32, ZPR16, ZPR16>;
2386   def _D : sve2_wide_int_arith<0b11, opc, asm, ZPR64, ZPR32, ZPR32>;
2387 }
2388
2389 multiclass sve2_wide_int_arith_wide<bits<3> opc, string asm> {
2390   def _H : sve2_wide_int_arith<0b01, { 0b10, opc }, asm, ZPR16, ZPR16, ZPR8>;
2391   def _S : sve2_wide_int_arith<0b10, { 0b10, opc }, asm, ZPR32, ZPR32, ZPR16>;
2392   def _D : sve2_wide_int_arith<0b11, { 0b10, opc }, asm, ZPR64, ZPR64, ZPR32>;
2393 }
2394
2395 multiclass sve2_pmul_long<bits<1> opc, string asm> {
2396   def _H : sve2_wide_int_arith<0b01, {0b1101, opc}, asm, ZPR16, ZPR8, ZPR8>;
2397   def _D : sve2_wide_int_arith<0b11, {0b1101, opc}, asm, ZPR64, ZPR32, ZPR32>;
2398 }
2399
2400 //===----------------------------------------------------------------------===//
2401 // SVE2 Misc Group
2402 //===----------------------------------------------------------------------===//
2403
2404 class sve2_misc<bits<2> sz, bits<4> opc, string asm,
2405                 ZPRRegOp zprty1, ZPRRegOp zprty2>
2406 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, zprty2:$Zm),
2407   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2408   bits<5> Zd;
2409   bits<5> Zn;
2410   bits<5> Zm;
2411   let Inst{31-24} = 0b01000101;
2412   let Inst{23-22} = sz;
2413   let Inst{21}    = 0b0;
2414   let Inst{20-16} = Zm;
2415   let Inst{15-14} = 0b10;
2416   let Inst{13-10} = opc;
2417   let Inst{9-5}   = Zn;
2418   let Inst{4-0}   = Zd;
2419 }
2420
2421 multiclass sve2_misc_bitwise<bits<4> opc, string asm> {
2422   def _B : sve2_misc<0b00, opc, asm, ZPR8, ZPR8>;
2423   def _H : sve2_misc<0b01, opc, asm, ZPR16, ZPR16>;
2424   def _S : sve2_misc<0b10, opc, asm, ZPR32, ZPR32>;
2425   def _D : sve2_misc<0b11, opc, asm, ZPR64, ZPR64>;
2426 }
2427
2428 multiclass sve2_misc_int_addsub_long_interleaved<bits<2> opc, string asm> {
2429   def _H : sve2_misc<0b01, { 0b00, opc }, asm, ZPR16, ZPR8>;
2430   def _S : sve2_misc<0b10, { 0b00, opc }, asm, ZPR32, ZPR16>;
2431   def _D : sve2_misc<0b11, { 0b00, opc }, asm, ZPR64, ZPR32>;
2432 }
2433
2434 class sve2_bitwise_xor_interleaved<bits<2> sz, bits<1> opc, string asm,
2435                                    ZPRRegOp zprty1, ZPRRegOp zprty2>
2436 : I<(outs zprty1:$Zd), (ins zprty1:$_Zd, zprty2:$Zn, zprty2:$Zm),
2437   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2438   bits<5> Zd;
2439   bits<5> Zn;
2440   bits<5> Zm;
2441   let Inst{31-24} = 0b01000101;
2442   let Inst{23-22} = sz;
2443   let Inst{21}    = 0b0;
2444   let Inst{20-16} = Zm;
2445   let Inst{15-11} = 0b10010;
2446   let Inst{10}    = opc;
2447   let Inst{9-5}   = Zn;
2448   let Inst{4-0}   = Zd;
2449
2450   let Constraints = "$Zd = $_Zd";
2451   let DestructiveInstType = Destructive;
2452   let ElementSize = ElementSizeNone;
2453 }
2454
2455 multiclass sve2_bitwise_xor_interleaved<bit opc, string asm> {
2456   def _B : sve2_bitwise_xor_interleaved<0b00, opc, asm, ZPR8,  ZPR8>;
2457   def _H : sve2_bitwise_xor_interleaved<0b01, opc, asm, ZPR16, ZPR16>;
2458   def _S : sve2_bitwise_xor_interleaved<0b10, opc, asm, ZPR32, ZPR32>;
2459   def _D : sve2_bitwise_xor_interleaved<0b11, opc, asm, ZPR64, ZPR64>;
2460 }
2461
2462 class sve2_bitwise_shift_left_long<bits<3> tsz8_64, bits<2> opc, string asm,
2463                                    ZPRRegOp zprty1, ZPRRegOp zprty2,
2464                                    Operand immtype>
2465 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, immtype:$imm),
2466   asm, "\t$Zd, $Zn, $imm",
2467   "", []>, Sched<[]> {
2468   bits<5> Zd;
2469   bits<5> Zn;
2470   bits<5> imm;
2471   let Inst{31-23} = 0b010001010;
2472   let Inst{22}    = tsz8_64{2};
2473   let Inst{21}    = 0b0;
2474   let Inst{20-19} = tsz8_64{1-0};
2475   let Inst{18-16} = imm{2-0}; // imm3
2476   let Inst{15-12} = 0b1010;
2477   let Inst{11-10} = opc;
2478   let Inst{9-5}   = Zn;
2479   let Inst{4-0}   = Zd;
2480 }
2481
2482 multiclass sve2_bitwise_shift_left_long<bits<2> opc, string asm> {
2483   def _H : sve2_bitwise_shift_left_long<{0,0,1}, opc, asm,
2484                                         ZPR16, ZPR8, vecshiftL8>;
2485   def _S : sve2_bitwise_shift_left_long<{0,1,?}, opc, asm,
2486                                         ZPR32, ZPR16, vecshiftL16> {
2487     let Inst{19} = imm{3};
2488   }
2489   def _D : sve2_bitwise_shift_left_long<{1,?,?}, opc, asm,
2490                                         ZPR64, ZPR32, vecshiftL32> {
2491     let Inst{20-19} = imm{4-3};
2492   }
2493 }
2494
2495 //===----------------------------------------------------------------------===//
2496 // SVE2 Accumulate Group
2497 //===----------------------------------------------------------------------===//
2498
2499 class sve2_int_bin_shift_imm<bits<4> tsz8_64, bit opc, string asm,
2500                              ZPRRegOp zprty, Operand immtype>
2501 : I<(outs zprty:$Zd), (ins zprty:$_Zd, zprty:$Zn, immtype:$imm),
2502   asm, "\t$Zd, $Zn, $imm",
2503   "", []>, Sched<[]> {
2504   bits<5> Zd;
2505   bits<5> Zn;
2506   bits<6> imm;
2507   let Inst{31-24} = 0b01000101;
2508   let Inst{23-22} = tsz8_64{3-2};
2509   let Inst{21}    = 0b0;
2510   let Inst{20-19} = tsz8_64{1-0};
2511   let Inst{18-16} = imm{2-0}; // imm3
2512   let Inst{15-11} = 0b11110;
2513   let Inst{10}    = opc;
2514   let Inst{9-5}   = Zn;
2515   let Inst{4-0}   = Zd;
2516
2517   let Constraints = "$Zd = $_Zd";
2518 }
2519
2520 multiclass sve2_int_bin_shift_imm_left<bit opc, string asm> {
2521   def _B : sve2_int_bin_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftL8>;
2522   def _H : sve2_int_bin_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftL16> {
2523     let Inst{19} = imm{3};
2524   }
2525   def _S : sve2_int_bin_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftL32> {
2526     let Inst{20-19} = imm{4-3};
2527   }
2528   def _D : sve2_int_bin_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftL64> {
2529     let Inst{22}    = imm{5};
2530     let Inst{20-19} = imm{4-3};
2531   }
2532 }
2533
2534 multiclass sve2_int_bin_shift_imm_right<bit opc, string asm> {
2535   def _B : sve2_int_bin_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftR8>;
2536   def _H : sve2_int_bin_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftR16> {
2537     let Inst{19} = imm{3};
2538   }
2539   def _S : sve2_int_bin_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftR32> {
2540     let Inst{20-19} = imm{4-3};
2541   }
2542   def _D : sve2_int_bin_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftR64> {
2543     let Inst{22}    = imm{5};
2544     let Inst{20-19} = imm{4-3};
2545   }
2546 }
2547
2548 class sve2_int_bin_accum_shift_imm<bits<4> tsz8_64, bits<2> opc, string asm,
2549                                    ZPRRegOp zprty, Operand immtype>
2550 : I<(outs zprty:$Zda), (ins zprty:$_Zda, zprty:$Zn, immtype:$imm),
2551   asm, "\t$Zda, $Zn, $imm",
2552   "", []>, Sched<[]> {
2553   bits<5> Zda;
2554   bits<5> Zn;
2555   bits<6> imm;
2556   let Inst{31-24} = 0b01000101;
2557   let Inst{23-22} = tsz8_64{3-2};
2558   let Inst{21}    = 0b0;
2559   let Inst{20-19} = tsz8_64{1-0};
2560   let Inst{18-16} = imm{2-0}; // imm3
2561   let Inst{15-12} = 0b1110;
2562   let Inst{11-10} = opc;
2563   let Inst{9-5}   = Zn;
2564   let Inst{4-0}   = Zda;
2565
2566   let Constraints = "$Zda = $_Zda";
2567   let DestructiveInstType = Destructive;
2568   let ElementSize = ElementSizeNone;
2569 }
2570
2571 multiclass sve2_int_bin_accum_shift_imm_right<bits<2> opc, string asm> {
2572   def _B : sve2_int_bin_accum_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftR8>;
2573   def _H : sve2_int_bin_accum_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftR16> {
2574     let Inst{19} = imm{3};
2575   }
2576   def _S : sve2_int_bin_accum_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftR32> {
2577     let Inst{20-19} = imm{4-3};
2578   }
2579   def _D : sve2_int_bin_accum_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftR64> {
2580     let Inst{22}    = imm{5};
2581     let Inst{20-19} = imm{4-3};
2582   }
2583 }
2584
2585 class sve2_int_cadd<bits<2> sz, bit opc, string asm, ZPRRegOp zprty>
2586 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, zprty:$Zm, complexrotateopodd:$rot),
2587   asm, "\t$Zdn, $_Zdn, $Zm, $rot", "", []>, Sched<[]> {
2588   bits<5> Zdn;
2589   bits<5> Zm;
2590   bit rot;
2591   let Inst{31-24} = 0b01000101;
2592   let Inst{23-22} = sz;
2593   let Inst{21-17} = 0b00000;
2594   let Inst{16}    = opc;
2595   let Inst{15-11} = 0b11011;
2596   let Inst{10}    = rot;
2597   let Inst{9-5}   = Zm;
2598   let Inst{4-0}   = Zdn;
2599
2600   let Constraints = "$Zdn = $_Zdn";
2601   let DestructiveInstType = Destructive;
2602   let ElementSize = ElementSizeNone;
2603 }
2604
2605 multiclass sve2_int_cadd<bit opc, string asm> {
2606   def _B : sve2_int_cadd<0b00, opc, asm, ZPR8>;
2607   def _H : sve2_int_cadd<0b01, opc, asm, ZPR16>;
2608   def _S : sve2_int_cadd<0b10, opc, asm, ZPR32>;
2609   def _D : sve2_int_cadd<0b11, opc, asm, ZPR64>;
2610 }
2611
2612 class sve2_int_absdiff_accum<bits<2> sz, bits<4> opc, string asm,
2613                              ZPRRegOp zprty1, ZPRRegOp zprty2>
2614 : I<(outs zprty1:$Zda), (ins zprty1:$_Zda, zprty2:$Zn, zprty2:$Zm),
2615   asm, "\t$Zda, $Zn, $Zm", "", []>, Sched<[]> {
2616   bits<5> Zda;
2617   bits<5> Zn;
2618   bits<5> Zm;
2619   let Inst{31-24} = 0b01000101;
2620   let Inst{23-22} = sz;
2621   let Inst{21}    = 0b0;
2622   let Inst{20-16} = Zm;
2623   let Inst{15-14} = 0b11;
2624   let Inst{13-10} = opc;
2625   let Inst{9-5}   = Zn;
2626   let Inst{4-0}   = Zda;
2627
2628   let Constraints = "$Zda = $_Zda";
2629   let DestructiveInstType = Destructive;
2630   let ElementSize = ElementSizeNone;
2631 }
2632
2633 multiclass sve2_int_absdiff_accum<bit opc, string asm> {
2634   def _B : sve2_int_absdiff_accum<0b00, { 0b111, opc }, asm, ZPR8, ZPR8>;
2635   def _H : sve2_int_absdiff_accum<0b01, { 0b111, opc }, asm, ZPR16, ZPR16>;
2636   def _S : sve2_int_absdiff_accum<0b10, { 0b111, opc }, asm, ZPR32, ZPR32>;
2637   def _D : sve2_int_absdiff_accum<0b11, { 0b111, opc }, asm, ZPR64, ZPR64>;
2638 }
2639
2640 multiclass sve2_int_absdiff_accum_long<bits<2> opc, string asm> {
2641   def _H : sve2_int_absdiff_accum<0b01, { 0b00, opc }, asm, ZPR16, ZPR8>;
2642   def _S : sve2_int_absdiff_accum<0b10, { 0b00, opc }, asm, ZPR32, ZPR16>;
2643   def _D : sve2_int_absdiff_accum<0b11, { 0b00, opc }, asm, ZPR64, ZPR32>;
2644 }
2645
2646 multiclass sve2_int_addsub_long_carry<bits<2> opc, string asm> {
2647   def _S : sve2_int_absdiff_accum<{ opc{1}, 0b0 }, { 0b010, opc{0} }, asm,
2648                                   ZPR32, ZPR32>;
2649   def _D : sve2_int_absdiff_accum<{ opc{1}, 0b1 }, { 0b010, opc{0} }, asm,
2650                                   ZPR64, ZPR64>;
2651 }
2652
2653 //===----------------------------------------------------------------------===//
2654 // SVE2 Narrowing Group
2655 //===----------------------------------------------------------------------===//
2656
2657 class sve2_int_bin_shift_imm_narrow_bottom<bits<3> tsz8_64, bits<3> opc,
2658                                            string asm, ZPRRegOp zprty1,
2659                                            ZPRRegOp zprty2, Operand immtype>
2660 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, immtype:$imm),
2661   asm, "\t$Zd, $Zn, $imm",
2662   "", []>, Sched<[]> {
2663   bits<5> Zd;
2664   bits<5> Zn;
2665   bits<5> imm;
2666   let Inst{31-23} = 0b010001010;
2667   let Inst{22}    = tsz8_64{2};
2668   let Inst{21}    = 0b1;
2669   let Inst{20-19} = tsz8_64{1-0};
2670   let Inst{18-16} = imm{2-0}; // imm3
2671   let Inst{15-14} = 0b00;
2672   let Inst{13-11} = opc;
2673   let Inst{10}    = 0b0;
2674   let Inst{9-5}   = Zn;
2675   let Inst{4-0}   = Zd;
2676 }
2677
2678 multiclass sve2_int_bin_shift_imm_right_narrow_bottom<bits<3> opc, string asm> {
2679   def _B : sve2_int_bin_shift_imm_narrow_bottom<{0,0,1}, opc, asm, ZPR8, ZPR16,
2680                                                 vecshiftR8>;
2681   def _H : sve2_int_bin_shift_imm_narrow_bottom<{0,1,?}, opc, asm, ZPR16, ZPR32,
2682                                                 vecshiftR16> {
2683     let Inst{19} = imm{3};
2684   }
2685   def _S : sve2_int_bin_shift_imm_narrow_bottom<{1,?,?}, opc, asm, ZPR32, ZPR64,
2686                                                 vecshiftR32> {
2687     let Inst{20-19} = imm{4-3};
2688   }
2689 }
2690
2691 class sve2_int_bin_shift_imm_narrow_top<bits<3> tsz8_64, bits<3> opc,
2692                                         string asm, ZPRRegOp zprty1,
2693                                         ZPRRegOp zprty2, Operand immtype>
2694 : I<(outs zprty1:$Zd), (ins zprty1:$_Zd, zprty2:$Zn, immtype:$imm),
2695   asm, "\t$Zd, $Zn, $imm",
2696   "", []>, Sched<[]> {
2697   bits<5> Zd;
2698   bits<5> Zn;
2699   bits<5> imm;
2700   let Inst{31-23} = 0b010001010;
2701   let Inst{22}    = tsz8_64{2};
2702   let Inst{21}    = 0b1;
2703   let Inst{20-19} = tsz8_64{1-0};
2704   let Inst{18-16} = imm{2-0}; // imm3
2705   let Inst{15-14} = 0b00;
2706   let Inst{13-11} = opc;
2707   let Inst{10}    = 0b1;
2708   let Inst{9-5}   = Zn;
2709   let Inst{4-0}   = Zd;
2710
2711   let Constraints = "$Zd = $_Zd";
2712 }
2713
2714 multiclass sve2_int_bin_shift_imm_right_narrow_top<bits<3> opc, string asm> {
2715   def _B : sve2_int_bin_shift_imm_narrow_top<{0,0,1}, opc, asm, ZPR8, ZPR16,
2716                                              vecshiftR8>;
2717   def _H : sve2_int_bin_shift_imm_narrow_top<{0,1,?}, opc, asm, ZPR16, ZPR32,
2718                                              vecshiftR16> {
2719     let Inst{19} = imm{3};
2720   }
2721   def _S : sve2_int_bin_shift_imm_narrow_top<{1,?,?}, opc, asm, ZPR32, ZPR64,
2722                                              vecshiftR32> {
2723     let Inst{20-19} = imm{4-3};
2724   }
2725 }
2726
2727 class sve2_int_addsub_narrow_high_bottom<bits<2> sz, bits<2> opc, string asm,
2728                                          ZPRRegOp zprty1, ZPRRegOp zprty2>
2729 : I<(outs zprty1:$Zd), (ins zprty2:$Zn, zprty2:$Zm),
2730   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2731   bits<5> Zd;
2732   bits<5> Zn;
2733   bits<5> Zm;
2734   let Inst{31-24} = 0b01000101;
2735   let Inst{23-22} = sz;
2736   let Inst{21}    = 0b1;
2737   let Inst{20-16} = Zm;
2738   let Inst{15-13} = 0b011;
2739   let Inst{12-11} = opc; // S, R
2740   let Inst{10}    = 0b0; // Top
2741   let Inst{9-5}   = Zn;
2742   let Inst{4-0}   = Zd;
2743 }
2744
2745 multiclass sve2_int_addsub_narrow_high_bottom<bits<2> opc, string asm> {
2746   def _B : sve2_int_addsub_narrow_high_bottom<0b01, opc, asm, ZPR8, ZPR16>;
2747   def _H : sve2_int_addsub_narrow_high_bottom<0b10, opc, asm, ZPR16, ZPR32>;
2748   def _S : sve2_int_addsub_narrow_high_bottom<0b11, opc, asm, ZPR32, ZPR64>;
2749 }
2750
2751 class sve2_int_addsub_narrow_high_top<bits<2> sz, bits<2> opc, string asm,
2752                                       ZPRRegOp zprty1, ZPRRegOp zprty2>
2753 : I<(outs zprty1:$Zd), (ins zprty1:$_Zd, zprty2:$Zn, zprty2:$Zm),
2754   asm, "\t$Zd, $Zn, $Zm", "", []>, Sched<[]> {
2755   bits<5> Zd;
2756   bits<5> Zn;
2757   bits<5> Zm;
2758   let Inst{31-24} = 0b01000101;
2759   let Inst{23-22} = sz;
2760   let Inst{21}    = 0b1;
2761   let Inst{20-16} = Zm;
2762   let Inst{15-13} = 0b011;
2763   let Inst{12-11} = opc; // S, R
2764   let Inst{10}    = 0b1; // Top
2765   let Inst{9-5}   = Zn;
2766   let Inst{4-0}   = Zd;
2767
2768   let Constraints = "$Zd = $_Zd";
2769 }
2770
2771 multiclass sve2_int_addsub_narrow_high_top<bits<2> opc, string asm> {
2772   def _B : sve2_int_addsub_narrow_high_top<0b01, opc, asm, ZPR8, ZPR16>;
2773   def _H : sve2_int_addsub_narrow_high_top<0b10, opc, asm, ZPR16, ZPR32>;
2774   def _S : sve2_int_addsub_narrow_high_top<0b11, opc, asm, ZPR32, ZPR64>;
2775 }
2776
2777 class sve2_int_sat_extract_narrow_bottom<bits<3> tsz8_64, bits<2> opc, string asm,
2778                                          ZPRRegOp zprty1, ZPRRegOp zprty2>
2779 : I<(outs zprty1:$Zd), (ins zprty2:$Zn),
2780   asm, "\t$Zd, $Zn", "", []>, Sched<[]> {
2781   bits<5> Zd;
2782   bits<5> Zn;
2783   let Inst{31-23} = 0b010001010;
2784   let Inst{22}    = tsz8_64{2};
2785   let Inst{21}    = 0b1;
2786   let Inst{20-19} = tsz8_64{1-0};
2787   let Inst{18-13} = 0b000010;
2788   let Inst{12-11} = opc;
2789   let Inst{10}    = 0b0;
2790   let Inst{9-5}   = Zn;
2791   let Inst{4-0}   = Zd;
2792 }
2793
2794 multiclass sve2_int_sat_extract_narrow_bottom<bits<2> opc, string asm> {
2795   def _B : sve2_int_sat_extract_narrow_bottom<0b001, opc, asm, ZPR8, ZPR16>;
2796   def _H : sve2_int_sat_extract_narrow_bottom<0b010, opc, asm, ZPR16, ZPR32>;
2797   def _S : sve2_int_sat_extract_narrow_bottom<0b100, opc, asm, ZPR32, ZPR64>;
2798 }
2799
2800 class sve2_int_sat_extract_narrow_top<bits<3> tsz8_64, bits<2> opc, string asm,
2801                                       ZPRRegOp zprty1, ZPRRegOp zprty2>
2802 : I<(outs zprty1:$Zd), (ins zprty1:$_Zd, zprty2:$Zn),
2803   asm, "\t$Zd, $Zn", "", []>, Sched<[]> {
2804   bits<5> Zd;
2805   bits<5> Zn;
2806   let Inst{31-23} = 0b010001010;
2807   let Inst{22}    = tsz8_64{2};
2808   let Inst{21}    = 0b1;
2809   let Inst{20-19} = tsz8_64{1-0};
2810   let Inst{18-13} = 0b000010;
2811   let Inst{12-11} = opc;
2812   let Inst{10}    = 0b1;
2813   let Inst{9-5}   = Zn;
2814   let Inst{4-0}   = Zd;
2815
2816   let Constraints = "$Zd = $_Zd";
2817 }
2818
2819 multiclass sve2_int_sat_extract_narrow_top<bits<2> opc, string asm> {
2820   def _B : sve2_int_sat_extract_narrow_top<0b001, opc, asm, ZPR8, ZPR16>;
2821   def _H : sve2_int_sat_extract_narrow_top<0b010, opc, asm, ZPR16, ZPR32>;
2822   def _S : sve2_int_sat_extract_narrow_top<0b100, opc, asm, ZPR32, ZPR64>;
2823 }
2824
2825 //===----------------------------------------------------------------------===//
2826 // SVE Integer Arithmetic - Unary Predicated Group
2827 //===----------------------------------------------------------------------===//
2828
2829 class sve_int_un_pred_arit<bits<2> sz8_64, bits<4> opc,
2830                              string asm, ZPRRegOp zprty>
2831 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPR3bAny:$Pg, zprty:$Zn),
2832   asm, "\t$Zd, $Pg/m, $Zn",
2833   "",
2834   []>, Sched<[]> {
2835   bits<3> Pg;
2836   bits<5> Zd;
2837   bits<5> Zn;
2838   let Inst{31-24} = 0b00000100;
2839   let Inst{23-22} = sz8_64;
2840   let Inst{21-20} = 0b01;
2841   let Inst{19}    = opc{0};
2842   let Inst{18-16} = opc{3-1};
2843   let Inst{15-13} = 0b101;
2844   let Inst{12-10} = Pg;
2845   let Inst{9-5}   = Zn;
2846   let Inst{4-0}   = Zd;
2847
2848   let Constraints = "$Zd = $_Zd";
2849   let DestructiveInstType = Destructive;
2850   let ElementSize = zprty.ElementSize;
2851 }
2852
2853 multiclass sve_int_un_pred_arit_0<bits<3> opc, string asm,
2854                                   SDPatternOperator op> {
2855   def _B : sve_int_un_pred_arit<0b00, { opc, 0b0 }, asm, ZPR8>;
2856   def _H : sve_int_un_pred_arit<0b01, { opc, 0b0 }, asm, ZPR16>;
2857   def _S : sve_int_un_pred_arit<0b10, { opc, 0b0 }, asm, ZPR32>;
2858   def _D : sve_int_un_pred_arit<0b11, { opc, 0b0 }, asm, ZPR64>;
2859
2860   def : SVE_3_Op_Pat<nxv16i8, op, nxv16i8, nxv16i1, nxv16i8, !cast<Instruction>(NAME # _B)>;
2861   def : SVE_3_Op_Pat<nxv8i16, op, nxv8i16, nxv8i1,  nxv8i16, !cast<Instruction>(NAME # _H)>;
2862   def : SVE_3_Op_Pat<nxv4i32, op, nxv4i32, nxv4i1,  nxv4i32, !cast<Instruction>(NAME # _S)>;
2863   def : SVE_3_Op_Pat<nxv2i64, op, nxv2i64, nxv2i1,  nxv2i64, !cast<Instruction>(NAME # _D)>;
2864 }
2865
2866 multiclass sve_int_un_pred_arit_0_h<bits<3> opc, string asm> {
2867   def _H : sve_int_un_pred_arit<0b01, { opc, 0b0 }, asm, ZPR16>;
2868   def _S : sve_int_un_pred_arit<0b10, { opc, 0b0 }, asm, ZPR32>;
2869   def _D : sve_int_un_pred_arit<0b11, { opc, 0b0 }, asm, ZPR64>;
2870 }
2871
2872 multiclass sve_int_un_pred_arit_0_w<bits<3> opc, string asm> {
2873   def _S : sve_int_un_pred_arit<0b10, { opc, 0b0 }, asm, ZPR32>;
2874   def _D : sve_int_un_pred_arit<0b11, { opc, 0b0 }, asm, ZPR64>;
2875 }
2876
2877 multiclass sve_int_un_pred_arit_0_d<bits<3> opc, string asm> {
2878   def _D : sve_int_un_pred_arit<0b11, { opc, 0b0 }, asm, ZPR64>;
2879 }
2880
2881 multiclass sve_int_un_pred_arit_1<bits<3> opc, string asm,
2882                                   SDPatternOperator op> {
2883   def _B : sve_int_un_pred_arit<0b00, { opc, 0b1 }, asm, ZPR8>;
2884   def _H : sve_int_un_pred_arit<0b01, { opc, 0b1 }, asm, ZPR16>;
2885   def _S : sve_int_un_pred_arit<0b10, { opc, 0b1 }, asm, ZPR32>;
2886   def _D : sve_int_un_pred_arit<0b11, { opc, 0b1 }, asm, ZPR64>;
2887
2888   def : SVE_3_Op_Pat<nxv16i8, op, nxv16i8, nxv16i1, nxv16i8, !cast<Instruction>(NAME # _B)>;
2889   def : SVE_3_Op_Pat<nxv8i16, op, nxv8i16, nxv8i1,  nxv8i16, !cast<Instruction>(NAME # _H)>;
2890   def : SVE_3_Op_Pat<nxv4i32, op, nxv4i32, nxv4i1,  nxv4i32, !cast<Instruction>(NAME # _S)>;
2891   def : SVE_3_Op_Pat<nxv2i64, op, nxv2i64, nxv2i1,  nxv2i64, !cast<Instruction>(NAME # _D)>;
2892
2893   def : SVE_3_Op_Pat<nxv8i16, op, nxv8i16, nxv8i1, nxv8f16, !cast<Instruction>(NAME # _H)>;
2894   def : SVE_3_Op_Pat<nxv4i32, op, nxv4i32, nxv4i1, nxv4f32, !cast<Instruction>(NAME # _S)>;
2895   def : SVE_3_Op_Pat<nxv2i64, op, nxv2i64, nxv2i1, nxv2f64, !cast<Instruction>(NAME # _D)>;
2896 }
2897
2898 multiclass sve_int_un_pred_arit_1_fp<bits<3> opc, string asm> {
2899   def _H : sve_int_un_pred_arit<0b01, { opc, 0b1 }, asm, ZPR16>;
2900   def _S : sve_int_un_pred_arit<0b10, { opc, 0b1 }, asm, ZPR32>;
2901   def _D : sve_int_un_pred_arit<0b11, { opc, 0b1 }, asm, ZPR64>;
2902 }
2903
2904 //===----------------------------------------------------------------------===//
2905 // SVE Integer Wide Immediate - Unpredicated Group
2906 //===----------------------------------------------------------------------===//
2907 class sve_int_dup_imm<bits<2> sz8_64, string asm,
2908                       ZPRRegOp zprty, Operand immtype>
2909 : I<(outs zprty:$Zd), (ins immtype:$imm),
2910   asm, "\t$Zd, $imm",
2911   "",
2912   []>, Sched<[]> {
2913   bits<5> Zd;
2914   bits<9> imm;
2915   let Inst{31-24} = 0b00100101;
2916   let Inst{23-22} = sz8_64;
2917   let Inst{21-14} = 0b11100011;
2918   let Inst{13}    = imm{8};   // sh
2919   let Inst{12-5}  = imm{7-0}; // imm8
2920   let Inst{4-0}   = Zd;
2921
2922   let isReMaterializable = 1;
2923 }
2924
2925 multiclass sve_int_dup_imm<string asm> {
2926   def _B : sve_int_dup_imm<0b00, asm, ZPR8, cpy_imm8_opt_lsl_i8>;
2927   def _H : sve_int_dup_imm<0b01, asm, ZPR16, cpy_imm8_opt_lsl_i16>;
2928   def _S : sve_int_dup_imm<0b10, asm, ZPR32, cpy_imm8_opt_lsl_i32>;
2929   def _D : sve_int_dup_imm<0b11, asm, ZPR64, cpy_imm8_opt_lsl_i64>;
2930
2931   def : InstAlias<"mov $Zd, $imm",
2932                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, cpy_imm8_opt_lsl_i8:$imm), 1>;
2933   def : InstAlias<"mov $Zd, $imm",
2934                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, cpy_imm8_opt_lsl_i16:$imm), 1>;
2935   def : InstAlias<"mov $Zd, $imm",
2936                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, cpy_imm8_opt_lsl_i32:$imm), 1>;
2937   def : InstAlias<"mov $Zd, $imm",
2938                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, cpy_imm8_opt_lsl_i64:$imm), 1>;
2939
2940   def : InstAlias<"fmov $Zd, #0.0",
2941                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, 0, 0), 1>;
2942   def : InstAlias<"fmov $Zd, #0.0",
2943                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, 0, 0), 1>;
2944   def : InstAlias<"fmov $Zd, #0.0",
2945                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, 0, 0), 1>;
2946 }
2947
2948 class sve_int_dup_fpimm<bits<2> sz8_64, Operand fpimmtype,
2949                         string asm, ZPRRegOp zprty>
2950 : I<(outs zprty:$Zd), (ins fpimmtype:$imm8),
2951   asm, "\t$Zd, $imm8",
2952   "",
2953   []>, Sched<[]> {
2954   bits<5> Zd;
2955   bits<8> imm8;
2956   let Inst{31-24} = 0b00100101;
2957   let Inst{23-22} = sz8_64;
2958   let Inst{21-14} = 0b11100111;
2959   let Inst{13}    = 0b0;
2960   let Inst{12-5}  = imm8;
2961   let Inst{4-0}   = Zd;
2962
2963   let isReMaterializable = 1;
2964 }
2965
2966 multiclass sve_int_dup_fpimm<string asm> {
2967   def _H : sve_int_dup_fpimm<0b01, fpimm16, asm, ZPR16>;
2968   def _S : sve_int_dup_fpimm<0b10, fpimm32, asm, ZPR32>;
2969   def _D : sve_int_dup_fpimm<0b11, fpimm64, asm, ZPR64>;
2970
2971   def : InstAlias<"fmov $Zd, $imm8",
2972                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, fpimm16:$imm8), 1>;
2973   def : InstAlias<"fmov $Zd, $imm8",
2974                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, fpimm32:$imm8), 1>;
2975   def : InstAlias<"fmov $Zd, $imm8",
2976                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, fpimm64:$imm8), 1>;
2977 }
2978
2979 class sve_int_arith_imm0<bits<2> sz8_64, bits<3> opc, string asm,
2980                          ZPRRegOp zprty, Operand immtype>
2981 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, immtype:$imm),
2982   asm, "\t$Zdn, $_Zdn, $imm",
2983   "",
2984   []>, Sched<[]> {
2985   bits<5> Zdn;
2986   bits<9> imm;
2987   let Inst{31-24} = 0b00100101;
2988   let Inst{23-22} = sz8_64;
2989   let Inst{21-19} = 0b100;
2990   let Inst{18-16} = opc;
2991   let Inst{15-14} = 0b11;
2992   let Inst{13}    = imm{8};   // sh
2993   let Inst{12-5}  = imm{7-0}; // imm8
2994   let Inst{4-0}   = Zdn;
2995
2996   let Constraints = "$Zdn = $_Zdn";
2997   let DestructiveInstType = Destructive;
2998   let ElementSize = ElementSizeNone;
2999 }
3000
3001 multiclass sve_int_arith_imm0<bits<3> opc, string asm> {
3002   def _B : sve_int_arith_imm0<0b00, opc, asm, ZPR8, addsub_imm8_opt_lsl_i8>;
3003   def _H : sve_int_arith_imm0<0b01, opc, asm, ZPR16, addsub_imm8_opt_lsl_i16>;
3004   def _S : sve_int_arith_imm0<0b10, opc, asm, ZPR32, addsub_imm8_opt_lsl_i32>;
3005   def _D : sve_int_arith_imm0<0b11, opc, asm, ZPR64, addsub_imm8_opt_lsl_i64>;
3006 }
3007
3008 class sve_int_arith_imm<bits<2> sz8_64, bits<6> opc, string asm,
3009                         ZPRRegOp zprty, Operand immtype>
3010 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, immtype:$imm),
3011   asm, "\t$Zdn, $_Zdn, $imm",
3012   "",
3013   []>, Sched<[]> {
3014   bits<5> Zdn;
3015   bits<8> imm;
3016   let Inst{31-24} = 0b00100101;
3017   let Inst{23-22} = sz8_64;
3018   let Inst{21-16} = opc;
3019   let Inst{15-13} = 0b110;
3020   let Inst{12-5} = imm;
3021   let Inst{4-0} = Zdn;
3022
3023   let Constraints = "$Zdn = $_Zdn";
3024   let DestructiveInstType = Destructive;
3025   let ElementSize = ElementSizeNone;
3026 }
3027
3028 multiclass sve_int_arith_imm1<bits<2> opc, string asm, Operand immtype> {
3029   def _B : sve_int_arith_imm<0b00, { 0b1010, opc }, asm, ZPR8, immtype>;
3030   def _H : sve_int_arith_imm<0b01, { 0b1010, opc }, asm, ZPR16, immtype>;
3031   def _S : sve_int_arith_imm<0b10, { 0b1010, opc }, asm, ZPR32, immtype>;
3032   def _D : sve_int_arith_imm<0b11, { 0b1010, opc }, asm, ZPR64, immtype>;
3033 }
3034
3035 multiclass sve_int_arith_imm2<string asm> {
3036   def _B : sve_int_arith_imm<0b00, 0b110000, asm, ZPR8,  simm8>;
3037   def _H : sve_int_arith_imm<0b01, 0b110000, asm, ZPR16, simm8>;
3038   def _S : sve_int_arith_imm<0b10, 0b110000, asm, ZPR32, simm8>;
3039   def _D : sve_int_arith_imm<0b11, 0b110000, asm, ZPR64, simm8>;
3040 }
3041
3042 //===----------------------------------------------------------------------===//
3043 // SVE Bitwise Logical - Unpredicated Group
3044 //===----------------------------------------------------------------------===//
3045
3046 class sve_int_bin_cons_log<bits<2> opc, string asm>
3047 : I<(outs ZPR64:$Zd), (ins ZPR64:$Zn, ZPR64:$Zm),
3048   asm, "\t$Zd, $Zn, $Zm",
3049   "",
3050   []>, Sched<[]> {
3051   bits<5> Zd;
3052   bits<5> Zm;
3053   bits<5> Zn;
3054   let Inst{31-24} = 0b00000100;
3055   let Inst{23-22} = opc{1-0};
3056   let Inst{21}    = 0b1;
3057   let Inst{20-16} = Zm;
3058   let Inst{15-10} = 0b001100;
3059   let Inst{9-5}   = Zn;
3060   let Inst{4-0}   = Zd;
3061 }
3062
3063 multiclass sve_int_bin_cons_log<bits<2> opc, string asm> {
3064   def NAME : sve_int_bin_cons_log<opc, asm>;
3065
3066   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
3067                   (!cast<Instruction>(NAME) ZPR8:$Zd,  ZPR8:$Zn,  ZPR8:$Zm),  1>;
3068   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
3069                   (!cast<Instruction>(NAME) ZPR16:$Zd, ZPR16:$Zn, ZPR16:$Zm), 1>;
3070   def : InstAlias<asm # "\t$Zd, $Zn, $Zm",
3071                   (!cast<Instruction>(NAME) ZPR32:$Zd, ZPR32:$Zn, ZPR32:$Zm), 1>;
3072 }
3073
3074 class sve2_int_bitwise_ternary_op_d<bits<3> opc, string asm>
3075 : I<(outs ZPR64:$Zdn), (ins ZPR64:$_Zdn, ZPR64:$Zm, ZPR64:$Zk),
3076   asm, "\t$Zdn, $_Zdn, $Zm, $Zk",
3077   "",
3078   []>, Sched<[]> {
3079   bits<5> Zdn;
3080   bits<5> Zk;
3081   bits<5> Zm;
3082   let Inst{31-24} = 0b00000100;
3083   let Inst{23-22} = opc{2-1};
3084   let Inst{21}    = 0b1;
3085   let Inst{20-16} = Zm;
3086   let Inst{15-11} = 0b00111;
3087   let Inst{10}    = opc{0};
3088   let Inst{9-5}   = Zk;
3089   let Inst{4-0}   = Zdn;
3090
3091   let Constraints = "$Zdn = $_Zdn";
3092   let DestructiveInstType = Destructive;
3093   let ElementSize = ElementSizeNone;
3094 }
3095
3096 multiclass sve2_int_bitwise_ternary_op<bits<3> opc, string asm> {
3097   def NAME : sve2_int_bitwise_ternary_op_d<opc, asm>;
3098
3099   def : InstAlias<asm # "\t$Zdn, $Zdn, $Zm, $Zk",
3100                   (!cast<Instruction>(NAME) ZPR8:$Zdn,  ZPR8:$Zm,  ZPR8:$Zk),  1>;
3101   def : InstAlias<asm # "\t$Zdn, $Zdn, $Zm, $Zk",
3102                   (!cast<Instruction>(NAME) ZPR16:$Zdn, ZPR16:$Zm, ZPR16:$Zk), 1>;
3103   def : InstAlias<asm # "\t$Zdn, $Zdn, $Zm, $Zk",
3104                   (!cast<Instruction>(NAME) ZPR32:$Zdn, ZPR32:$Zm, ZPR32:$Zk), 1>;
3105 }
3106
3107 class sve2_int_rotate_right_imm<bits<4> tsz8_64, string asm,
3108                                 ZPRRegOp zprty, Operand immtype>
3109 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, zprty:$Zm, immtype:$imm),
3110   asm, "\t$Zdn, $_Zdn, $Zm, $imm",
3111   "",
3112   []>, Sched<[]> {
3113   bits<5> Zdn;
3114   bits<5> Zm;
3115   bits<6> imm;
3116   let Inst{31-24} = 0b00000100;
3117   let Inst{23-22} = tsz8_64{3-2};
3118   let Inst{21}    = 0b1;
3119   let Inst{20-19} = tsz8_64{1-0};
3120   let Inst{18-16} = imm{2-0}; // imm3
3121   let Inst{15-10} = 0b001101;
3122   let Inst{9-5}   = Zm;
3123   let Inst{4-0}   = Zdn;
3124
3125   let Constraints = "$Zdn = $_Zdn";
3126   let DestructiveInstType = Destructive;
3127   let ElementSize = ElementSizeNone;
3128 }
3129
3130 multiclass sve2_int_rotate_right_imm<string asm> {
3131   def _B : sve2_int_rotate_right_imm<{0,0,0,1}, asm, ZPR8, vecshiftR8>;
3132   def _H : sve2_int_rotate_right_imm<{0,0,1,?}, asm, ZPR16, vecshiftR16> {
3133     let Inst{19} = imm{3};
3134   }
3135   def _S : sve2_int_rotate_right_imm<{0,1,?,?}, asm, ZPR32, vecshiftR32> {
3136     let Inst{20-19} = imm{4-3};
3137   }
3138   def _D : sve2_int_rotate_right_imm<{1,?,?,?}, asm, ZPR64, vecshiftR64> {
3139     let Inst{22}    = imm{5};
3140     let Inst{20-19} = imm{4-3};
3141   }
3142 }
3143
3144 //===----------------------------------------------------------------------===//
3145 // SVE Integer Wide Immediate - Predicated Group
3146 //===----------------------------------------------------------------------===//
3147
3148 class sve_int_dup_fpimm_pred<bits<2> sz, Operand fpimmtype,
3149                              string asm, ZPRRegOp zprty>
3150 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPRAny:$Pg, fpimmtype:$imm8),
3151   asm, "\t$Zd, $Pg/m, $imm8",
3152   "",
3153   []>, Sched<[]> {
3154   bits<4> Pg;
3155   bits<5> Zd;
3156   bits<8> imm8;
3157   let Inst{31-24} = 0b00000101;
3158   let Inst{23-22} = sz;
3159   let Inst{21-20} = 0b01;
3160   let Inst{19-16} = Pg;
3161   let Inst{15-13} = 0b110;
3162   let Inst{12-5}  = imm8;
3163   let Inst{4-0}   = Zd;
3164
3165   let Constraints = "$Zd = $_Zd";
3166   let DestructiveInstType = Destructive;
3167   let ElementSize = zprty.ElementSize;
3168 }
3169
3170 multiclass sve_int_dup_fpimm_pred<string asm> {
3171   def _H : sve_int_dup_fpimm_pred<0b01, fpimm16, asm, ZPR16>;
3172   def _S : sve_int_dup_fpimm_pred<0b10, fpimm32, asm, ZPR32>;
3173   def _D : sve_int_dup_fpimm_pred<0b11, fpimm64, asm, ZPR64>;
3174
3175   def : InstAlias<"fmov $Zd, $Pg/m, $imm8",
3176                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPRAny:$Pg, fpimm16:$imm8), 1>;
3177   def : InstAlias<"fmov $Zd, $Pg/m, $imm8",
3178                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPRAny:$Pg, fpimm32:$imm8), 1>;
3179   def : InstAlias<"fmov $Zd, $Pg/m, $imm8",
3180                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPRAny:$Pg, fpimm64:$imm8), 1>;
3181 }
3182
3183 class sve_int_dup_imm_pred<bits<2> sz8_64, bit m, string asm,
3184                            ZPRRegOp zprty, string pred_qual, dag iops>
3185 : I<(outs zprty:$Zd), iops,
3186   asm, "\t$Zd, $Pg"#pred_qual#", $imm",
3187   "", []>, Sched<[]> {
3188   bits<5> Zd;
3189   bits<4> Pg;
3190   bits<9> imm;
3191   let Inst{31-24} = 0b00000101;
3192   let Inst{23-22} = sz8_64;
3193   let Inst{21-20} = 0b01;
3194   let Inst{19-16} = Pg;
3195   let Inst{15}    = 0b0;
3196   let Inst{14}    = m;
3197   let Inst{13}    = imm{8};   // sh
3198   let Inst{12-5}  = imm{7-0}; // imm8
3199   let Inst{4-0}   = Zd;
3200
3201   let DestructiveInstType = Destructive;
3202   let ElementSize = zprty.ElementSize;
3203 }
3204
3205 multiclass sve_int_dup_imm_pred_merge<string asm> {
3206   let Constraints = "$Zd = $_Zd" in {
3207   def _B : sve_int_dup_imm_pred<0b00, 1, asm, ZPR8,  "/m", (ins ZPR8:$_Zd,  PPRAny:$Pg, cpy_imm8_opt_lsl_i8:$imm)>;
3208   def _H : sve_int_dup_imm_pred<0b01, 1, asm, ZPR16, "/m", (ins ZPR16:$_Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i16:$imm)>;
3209   def _S : sve_int_dup_imm_pred<0b10, 1, asm, ZPR32, "/m", (ins ZPR32:$_Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i32:$imm)>;
3210   def _D : sve_int_dup_imm_pred<0b11, 1, asm, ZPR64, "/m", (ins ZPR64:$_Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i64:$imm)>;
3211   }
3212
3213   def : InstAlias<"mov $Zd, $Pg/m, $imm",
3214                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd,  PPRAny:$Pg, cpy_imm8_opt_lsl_i8:$imm), 1>;
3215   def : InstAlias<"mov $Zd, $Pg/m, $imm",
3216                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i16:$imm), 1>;
3217   def : InstAlias<"mov $Zd, $Pg/m, $imm",
3218                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i32:$imm), 1>;
3219   def : InstAlias<"mov $Zd, $Pg/m, $imm",
3220                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i64:$imm), 1>;
3221
3222   def : InstAlias<"fmov $Zd, $Pg/m, #0.0",
3223                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPRAny:$Pg, 0, 0), 0>;
3224   def : InstAlias<"fmov $Zd, $Pg/m, #0.0",
3225                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPRAny:$Pg, 0, 0), 0>;
3226   def : InstAlias<"fmov $Zd, $Pg/m, #0.0",
3227                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPRAny:$Pg, 0, 0), 0>;
3228 }
3229
3230 multiclass sve_int_dup_imm_pred_zero<string asm> {
3231   def _B : sve_int_dup_imm_pred<0b00, 0, asm, ZPR8,  "/z", (ins PPRAny:$Pg, cpy_imm8_opt_lsl_i8:$imm)>;
3232   def _H : sve_int_dup_imm_pred<0b01, 0, asm, ZPR16, "/z", (ins PPRAny:$Pg, cpy_imm8_opt_lsl_i16:$imm)>;
3233   def _S : sve_int_dup_imm_pred<0b10, 0, asm, ZPR32, "/z", (ins PPRAny:$Pg, cpy_imm8_opt_lsl_i32:$imm)>;
3234   def _D : sve_int_dup_imm_pred<0b11, 0, asm, ZPR64, "/z", (ins PPRAny:$Pg, cpy_imm8_opt_lsl_i64:$imm)>;
3235
3236   def : InstAlias<"mov $Zd, $Pg/z, $imm",
3237                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd,  PPRAny:$Pg, cpy_imm8_opt_lsl_i8:$imm), 1>;
3238   def : InstAlias<"mov $Zd, $Pg/z, $imm",
3239                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i16:$imm), 1>;
3240   def : InstAlias<"mov $Zd, $Pg/z, $imm",
3241                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i32:$imm), 1>;
3242   def : InstAlias<"mov $Zd, $Pg/z, $imm",
3243                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPRAny:$Pg, cpy_imm8_opt_lsl_i64:$imm), 1>;
3244 }
3245
3246 //===----------------------------------------------------------------------===//
3247 // SVE Integer Compare - Vectors Group
3248 //===----------------------------------------------------------------------===//
3249
3250 class sve_int_cmp<bit cmp_1, bits<2> sz8_64, bits<3> opc, string asm,
3251                   PPRRegOp pprty, ZPRRegOp zprty1, ZPRRegOp zprty2>
3252 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty1:$Zn, zprty2:$Zm),
3253   asm, "\t$Pd, $Pg/z, $Zn, $Zm",
3254   "",
3255   []>, Sched<[]> {
3256   bits<4> Pd;
3257   bits<3> Pg;
3258   bits<5> Zm;
3259   bits<5> Zn;
3260   let Inst{31-24} = 0b00100100;
3261   let Inst{23-22} = sz8_64;
3262   let Inst{21}    = 0b0;
3263   let Inst{20-16} = Zm;
3264   let Inst{15}    = opc{2};
3265   let Inst{14}    = cmp_1;
3266   let Inst{13}    = opc{1};
3267   let Inst{12-10} = Pg;
3268   let Inst{9-5}   = Zn;
3269   let Inst{4}     = opc{0};
3270   let Inst{3-0}   = Pd;
3271
3272   let Defs = [NZCV];
3273 }
3274
3275 multiclass sve_int_cmp_0<bits<3> opc, string asm> {
3276   def _B : sve_int_cmp<0b0, 0b00, opc, asm, PPR8, ZPR8, ZPR8>;
3277   def _H : sve_int_cmp<0b0, 0b01, opc, asm, PPR16, ZPR16, ZPR16>;
3278   def _S : sve_int_cmp<0b0, 0b10, opc, asm, PPR32, ZPR32, ZPR32>;
3279   def _D : sve_int_cmp<0b0, 0b11, opc, asm, PPR64, ZPR64, ZPR64>;
3280 }
3281
3282 multiclass sve_int_cmp_0_wide<bits<3> opc, string asm> {
3283   def _B : sve_int_cmp<0b0, 0b00, opc, asm, PPR8, ZPR8, ZPR64>;
3284   def _H : sve_int_cmp<0b0, 0b01, opc, asm, PPR16, ZPR16, ZPR64>;
3285   def _S : sve_int_cmp<0b0, 0b10, opc, asm, PPR32, ZPR32, ZPR64>;
3286 }
3287
3288 multiclass sve_int_cmp_1_wide<bits<3> opc, string asm> {
3289   def _B : sve_int_cmp<0b1, 0b00, opc, asm, PPR8, ZPR8, ZPR64>;
3290   def _H : sve_int_cmp<0b1, 0b01, opc, asm, PPR16, ZPR16, ZPR64>;
3291   def _S : sve_int_cmp<0b1, 0b10, opc, asm, PPR32, ZPR32, ZPR64>;
3292 }
3293
3294
3295 //===----------------------------------------------------------------------===//
3296 // SVE Integer Compare - Signed Immediate Group
3297 //===----------------------------------------------------------------------===//
3298
3299 class sve_int_scmp_vi<bits<2> sz8_64, bits<3> opc, string asm, PPRRegOp pprty,
3300                       ZPRRegOp zprty,
3301                       Operand immtype>
3302 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty:$Zn, immtype:$imm5),
3303   asm, "\t$Pd, $Pg/z, $Zn, $imm5",
3304   "",
3305   []>, Sched<[]> {
3306   bits<4> Pd;
3307   bits<3> Pg;
3308   bits<5> Zn;
3309   bits<5> imm5;
3310   let Inst{31-24} = 0b00100101;
3311   let Inst{23-22} = sz8_64;
3312   let Inst{21}    = 0b0;
3313   let Inst{20-16} = imm5;
3314   let Inst{15}    = opc{2};
3315   let Inst{14}    = 0b0;
3316   let Inst{13}    = opc{1};
3317   let Inst{12-10} = Pg;
3318   let Inst{9-5}   = Zn;
3319   let Inst{4}     = opc{0};
3320   let Inst{3-0}   = Pd;
3321
3322   let Defs = [NZCV];
3323 }
3324
3325 multiclass sve_int_scmp_vi<bits<3> opc, string asm> {
3326   def _B : sve_int_scmp_vi<0b00, opc, asm, PPR8, ZPR8, simm5_32b>;
3327   def _H : sve_int_scmp_vi<0b01, opc, asm, PPR16, ZPR16, simm5_32b>;
3328   def _S : sve_int_scmp_vi<0b10, opc, asm, PPR32, ZPR32, simm5_32b>;
3329   def _D : sve_int_scmp_vi<0b11, opc, asm, PPR64, ZPR64, simm5_64b>;
3330 }
3331
3332
3333 //===----------------------------------------------------------------------===//
3334 // SVE Integer Compare - Unsigned Immediate Group
3335 //===----------------------------------------------------------------------===//
3336
3337 class sve_int_ucmp_vi<bits<2> sz8_64, bits<2> opc, string asm, PPRRegOp pprty,
3338                       ZPRRegOp zprty, Operand immtype>
3339 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty:$Zn, immtype:$imm7),
3340   asm, "\t$Pd, $Pg/z, $Zn, $imm7",
3341   "",
3342   []>, Sched<[]> {
3343   bits<4> Pd;
3344   bits<3> Pg;
3345   bits<5> Zn;
3346   bits<7> imm7;
3347   let Inst{31-24} = 0b00100100;
3348   let Inst{23-22} = sz8_64;
3349   let Inst{21}    = 1;
3350   let Inst{20-14} = imm7;
3351   let Inst{13}    = opc{1};
3352   let Inst{12-10} = Pg;
3353   let Inst{9-5}   = Zn;
3354   let Inst{4}     = opc{0};
3355   let Inst{3-0}   = Pd;
3356
3357   let Defs = [NZCV];
3358 }
3359
3360 multiclass sve_int_ucmp_vi<bits<2> opc, string asm> {
3361   def _B : sve_int_ucmp_vi<0b00, opc, asm, PPR8, ZPR8, imm0_127>;
3362   def _H : sve_int_ucmp_vi<0b01, opc, asm, PPR16, ZPR16, imm0_127>;
3363   def _S : sve_int_ucmp_vi<0b10, opc, asm, PPR32, ZPR32, imm0_127>;
3364   def _D : sve_int_ucmp_vi<0b11, opc, asm, PPR64, ZPR64, imm0_127>;
3365 }
3366
3367
3368 //===----------------------------------------------------------------------===//
3369 // SVE Integer Compare - Scalars Group
3370 //===----------------------------------------------------------------------===//
3371
3372 class sve_int_cterm<bit sz, bit opc, string asm, RegisterClass rt>
3373 : I<(outs), (ins rt:$Rn, rt:$Rm),
3374   asm, "\t$Rn, $Rm",
3375   "",
3376   []>, Sched<[]> {
3377   bits<5> Rm;
3378   bits<5> Rn;
3379   let Inst{31-23} = 0b001001011;
3380   let Inst{22}    = sz;
3381   let Inst{21}    = 0b1;
3382   let Inst{20-16} = Rm;
3383   let Inst{15-10} = 0b001000;
3384   let Inst{9-5}   = Rn;
3385   let Inst{4}     = opc;
3386   let Inst{3-0}   = 0b0000;
3387
3388   let Defs = [NZCV];
3389 }
3390
3391 class sve_int_while_rr<bits<2> sz8_64, bits<4> opc, string asm,
3392                        RegisterClass gprty, PPRRegOp pprty>
3393 : I<(outs pprty:$Pd), (ins gprty:$Rn, gprty:$Rm),
3394   asm, "\t$Pd, $Rn, $Rm",
3395   "", []>, Sched<[]> {
3396   bits<4> Pd;
3397   bits<5> Rm;
3398   bits<5> Rn;
3399   let Inst{31-24} = 0b00100101;
3400   let Inst{23-22} = sz8_64;
3401   let Inst{21}    = 0b1;
3402   let Inst{20-16} = Rm;
3403   let Inst{15-13} = 0b000;
3404   let Inst{12-10} = opc{3-1};
3405   let Inst{9-5}   = Rn;
3406   let Inst{4}     = opc{0};
3407   let Inst{3-0}   = Pd;
3408
3409   let Defs = [NZCV];
3410 }
3411
3412 multiclass sve_int_while4_rr<bits<3> opc, string asm> {
3413   def _B : sve_int_while_rr<0b00, { 0, opc }, asm, GPR32, PPR8>;
3414   def _H : sve_int_while_rr<0b01, { 0, opc }, asm, GPR32, PPR16>;
3415   def _S : sve_int_while_rr<0b10, { 0, opc }, asm, GPR32, PPR32>;
3416   def _D : sve_int_while_rr<0b11, { 0, opc }, asm, GPR32, PPR64>;
3417 }
3418
3419 multiclass sve_int_while8_rr<bits<3> opc, string asm> {
3420   def _B : sve_int_while_rr<0b00, { 1, opc }, asm, GPR64, PPR8>;
3421   def _H : sve_int_while_rr<0b01, { 1, opc }, asm, GPR64, PPR16>;
3422   def _S : sve_int_while_rr<0b10, { 1, opc }, asm, GPR64, PPR32>;
3423   def _D : sve_int_while_rr<0b11, { 1, opc }, asm, GPR64, PPR64>;
3424 }
3425
3426 class sve2_int_while_rr<bits<2> sz8_64, bits<1> rw, string asm,
3427                         PPRRegOp pprty>
3428 : I<(outs pprty:$Pd), (ins GPR64:$Rn, GPR64:$Rm),
3429   asm, "\t$Pd, $Rn, $Rm",
3430   "", []>, Sched<[]> {
3431   bits<4> Pd;
3432   bits<5> Rm;
3433   bits<5> Rn;
3434   let Inst{31-24} = 0b00100101;
3435   let Inst{23-22} = sz8_64;
3436   let Inst{21}    = 0b1;
3437   let Inst{20-16} = Rm;
3438   let Inst{15-10} = 0b001100;
3439   let Inst{9-5}   = Rn;
3440   let Inst{4}     = rw;
3441   let Inst{3-0}   = Pd;
3442
3443   let Defs = [NZCV];
3444 }
3445
3446 multiclass sve2_int_while_rr<bits<1> rw, string asm> {
3447   def _B : sve2_int_while_rr<0b00, rw, asm, PPR8>;
3448   def _H : sve2_int_while_rr<0b01, rw, asm, PPR16>;
3449   def _S : sve2_int_while_rr<0b10, rw, asm, PPR32>;
3450   def _D : sve2_int_while_rr<0b11, rw, asm, PPR64>;
3451 }
3452
3453 //===----------------------------------------------------------------------===//
3454 // SVE Floating Point Fast Reduction Group
3455 //===----------------------------------------------------------------------===//
3456
3457 class sve_fp_fast_red<bits<2> sz, bits<3> opc, string asm,
3458                       ZPRRegOp zprty, RegisterClass dstRegClass>
3459 : I<(outs dstRegClass:$Vd), (ins PPR3bAny:$Pg, zprty:$Zn),
3460   asm, "\t$Vd, $Pg, $Zn",
3461   "",
3462   []>, Sched<[]> {
3463   bits<5> Zn;
3464   bits<5> Vd;
3465   bits<3> Pg;
3466   let Inst{31-24} = 0b01100101;
3467   let Inst{23-22} = sz;
3468   let Inst{21-19} = 0b000;
3469   let Inst{18-16} = opc;
3470   let Inst{15-13} = 0b001;
3471   let Inst{12-10} = Pg;
3472   let Inst{9-5}   = Zn;
3473   let Inst{4-0}   = Vd;
3474 }
3475
3476 multiclass sve_fp_fast_red<bits<3> opc, string asm> {
3477   def _H : sve_fp_fast_red<0b01, opc, asm, ZPR16, FPR16>;
3478   def _S : sve_fp_fast_red<0b10, opc, asm, ZPR32, FPR32>;
3479   def _D : sve_fp_fast_red<0b11, opc, asm, ZPR64, FPR64>;
3480 }
3481
3482
3483 //===----------------------------------------------------------------------===//
3484 // SVE Floating Point Accumulating Reduction Group
3485 //===----------------------------------------------------------------------===//
3486
3487 class sve_fp_2op_p_vd<bits<2> sz, bits<3> opc, string asm,
3488                       ZPRRegOp zprty, RegisterClass dstRegClass>
3489 : I<(outs dstRegClass:$Vdn), (ins PPR3bAny:$Pg, dstRegClass:$_Vdn, zprty:$Zm),
3490   asm, "\t$Vdn, $Pg, $_Vdn, $Zm",
3491   "",
3492   []>,
3493   Sched<[]> {
3494   bits<3> Pg;
3495   bits<5> Vdn;
3496   bits<5> Zm;
3497   let Inst{31-24} = 0b01100101;
3498   let Inst{23-22} = sz;
3499   let Inst{21-19} = 0b011;
3500   let Inst{18-16} = opc;
3501   let Inst{15-13} = 0b001;
3502   let Inst{12-10} = Pg;
3503   let Inst{9-5}   = Zm;
3504   let Inst{4-0}   = Vdn;
3505
3506   let Constraints = "$Vdn = $_Vdn";
3507 }
3508
3509 multiclass sve_fp_2op_p_vd<bits<3> opc, string asm> {
3510   def _H : sve_fp_2op_p_vd<0b01, opc, asm, ZPR16, FPR16>;
3511   def _S : sve_fp_2op_p_vd<0b10, opc, asm, ZPR32, FPR32>;
3512   def _D : sve_fp_2op_p_vd<0b11, opc, asm, ZPR64, FPR64>;
3513 }
3514
3515 //===----------------------------------------------------------------------===//
3516 // SVE Floating Point Compare - Vectors Group
3517 //===----------------------------------------------------------------------===//
3518
3519 class sve_fp_3op_p_pd<bits<2> sz, bits<3> opc, string asm, PPRRegOp pprty,
3520                       ZPRRegOp zprty>
3521 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty:$Zn, zprty:$Zm),
3522   asm, "\t$Pd, $Pg/z, $Zn, $Zm",
3523   "",
3524   []>, Sched<[]> {
3525   bits<4> Pd;
3526   bits<3> Pg;
3527   bits<5> Zm;
3528   bits<5> Zn;
3529   let Inst{31-24} = 0b01100101;
3530   let Inst{23-22} = sz;
3531   let Inst{21}    = 0b0;
3532   let Inst{20-16} = Zm;
3533   let Inst{15}    = opc{2};
3534   let Inst{14}    = 0b1;
3535   let Inst{13}    = opc{1};
3536   let Inst{12-10} = Pg;
3537   let Inst{9-5}   = Zn;
3538   let Inst{4}     = opc{0};
3539   let Inst{3-0}   = Pd;
3540 }
3541
3542 multiclass sve_fp_3op_p_pd<bits<3> opc, string asm> {
3543   def _H : sve_fp_3op_p_pd<0b01, opc, asm, PPR16, ZPR16>;
3544   def _S : sve_fp_3op_p_pd<0b10, opc, asm, PPR32, ZPR32>;
3545   def _D : sve_fp_3op_p_pd<0b11, opc, asm, PPR64, ZPR64>;
3546 }
3547
3548
3549 //===----------------------------------------------------------------------===//
3550 // SVE Floating Point Compare - with Zero Group
3551 //===----------------------------------------------------------------------===//
3552
3553 class sve_fp_2op_p_pd<bits<2> sz, bits<3> opc, string asm, PPRRegOp pprty,
3554                       ZPRRegOp zprty>
3555 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty:$Zn),
3556   asm, "\t$Pd, $Pg/z, $Zn, #0.0",
3557   "",
3558   []>, Sched<[]> {
3559   bits<4> Pd;
3560   bits<3> Pg;
3561   bits<5> Zn;
3562   let Inst{31-24} = 0b01100101;
3563   let Inst{23-22} = sz;
3564   let Inst{21-18} = 0b0100;
3565   let Inst{17-16} = opc{2-1};
3566   let Inst{15-13} = 0b001;
3567   let Inst{12-10} = Pg;
3568   let Inst{9-5}   = Zn;
3569   let Inst{4}     = opc{0};
3570   let Inst{3-0}   = Pd;
3571 }
3572
3573 multiclass sve_fp_2op_p_pd<bits<3> opc, string asm> {
3574   def _H : sve_fp_2op_p_pd<0b01, opc, asm, PPR16, ZPR16>;
3575   def _S : sve_fp_2op_p_pd<0b10, opc, asm, PPR32, ZPR32>;
3576   def _D : sve_fp_2op_p_pd<0b11, opc, asm, PPR64, ZPR64>;
3577 }
3578
3579
3580 //===----------------------------------------------------------------------===//
3581 //SVE Index Generation Group
3582 //===----------------------------------------------------------------------===//
3583
3584 class sve_int_index_ii<bits<2> sz8_64, string asm, ZPRRegOp zprty,
3585                        Operand imm_ty>
3586 : I<(outs zprty:$Zd), (ins imm_ty:$imm5, imm_ty:$imm5b),
3587   asm, "\t$Zd, $imm5, $imm5b",
3588   "", []>, Sched<[]> {
3589   bits<5> Zd;
3590   bits<5> imm5;
3591   bits<5> imm5b;
3592   let Inst{31-24} = 0b00000100;
3593   let Inst{23-22} = sz8_64;
3594   let Inst{21}    = 0b1;
3595   let Inst{20-16} = imm5b;
3596   let Inst{15-10} = 0b010000;
3597   let Inst{9-5}   = imm5;
3598   let Inst{4-0}   = Zd;
3599 }
3600
3601 multiclass sve_int_index_ii<string asm> {
3602   def _B : sve_int_index_ii<0b00, asm, ZPR8, simm5_32b>;
3603   def _H : sve_int_index_ii<0b01, asm, ZPR16, simm5_32b>;
3604   def _S : sve_int_index_ii<0b10, asm, ZPR32, simm5_32b>;
3605   def _D : sve_int_index_ii<0b11, asm, ZPR64, simm5_64b>;
3606 }
3607
3608 class sve_int_index_ir<bits<2> sz8_64, string asm, ZPRRegOp zprty,
3609                        RegisterClass srcRegType, Operand imm_ty>
3610 : I<(outs zprty:$Zd), (ins imm_ty:$imm5, srcRegType:$Rm),
3611   asm, "\t$Zd, $imm5, $Rm",
3612   "", []>, Sched<[]> {
3613   bits<5> Rm;
3614   bits<5> Zd;
3615   bits<5> imm5;
3616   let Inst{31-24} = 0b00000100;
3617   let Inst{23-22} = sz8_64;
3618   let Inst{21}    = 0b1;
3619   let Inst{20-16} = Rm;
3620   let Inst{15-10} = 0b010010;
3621   let Inst{9-5}   = imm5;
3622   let Inst{4-0}   = Zd;
3623 }
3624
3625 multiclass sve_int_index_ir<string asm> {
3626   def _B : sve_int_index_ir<0b00, asm, ZPR8, GPR32, simm5_32b>;
3627   def _H : sve_int_index_ir<0b01, asm, ZPR16, GPR32, simm5_32b>;
3628   def _S : sve_int_index_ir<0b10, asm, ZPR32, GPR32, simm5_32b>;
3629   def _D : sve_int_index_ir<0b11, asm, ZPR64, GPR64, simm5_64b>;
3630 }
3631
3632 class sve_int_index_ri<bits<2> sz8_64, string asm, ZPRRegOp zprty,
3633                        RegisterClass srcRegType, Operand imm_ty>
3634 : I<(outs zprty:$Zd), (ins srcRegType:$Rn, imm_ty:$imm5),
3635   asm, "\t$Zd, $Rn, $imm5",
3636   "", []>, Sched<[]> {
3637   bits<5> Rn;
3638   bits<5> Zd;
3639   bits<5> imm5;
3640   let Inst{31-24} = 0b00000100;
3641   let Inst{23-22} = sz8_64;
3642   let Inst{21}    = 0b1;
3643   let Inst{20-16} = imm5;
3644   let Inst{15-10} = 0b010001;
3645   let Inst{9-5}   = Rn;
3646   let Inst{4-0}   = Zd;
3647 }
3648
3649 multiclass sve_int_index_ri<string asm> {
3650   def _B : sve_int_index_ri<0b00, asm, ZPR8, GPR32, simm5_32b>;
3651   def _H : sve_int_index_ri<0b01, asm, ZPR16, GPR32, simm5_32b>;
3652   def _S : sve_int_index_ri<0b10, asm, ZPR32, GPR32, simm5_32b>;
3653   def _D : sve_int_index_ri<0b11, asm, ZPR64, GPR64, simm5_64b>;
3654 }
3655
3656 class sve_int_index_rr<bits<2> sz8_64, string asm, ZPRRegOp zprty,
3657                        RegisterClass srcRegType>
3658 : I<(outs zprty:$Zd), (ins srcRegType:$Rn, srcRegType:$Rm),
3659   asm, "\t$Zd, $Rn, $Rm",
3660   "", []>, Sched<[]> {
3661   bits<5> Zd;
3662   bits<5> Rm;
3663   bits<5> Rn;
3664   let Inst{31-24} = 0b00000100;
3665   let Inst{23-22} = sz8_64;
3666   let Inst{21}    = 0b1;
3667   let Inst{20-16} = Rm;
3668   let Inst{15-10} = 0b010011;
3669   let Inst{9-5}   = Rn;
3670   let Inst{4-0}   = Zd;
3671 }
3672
3673 multiclass sve_int_index_rr<string asm> {
3674   def _B : sve_int_index_rr<0b00, asm, ZPR8, GPR32>;
3675   def _H : sve_int_index_rr<0b01, asm, ZPR16, GPR32>;
3676   def _S : sve_int_index_rr<0b10, asm, ZPR32, GPR32>;
3677   def _D : sve_int_index_rr<0b11, asm, ZPR64, GPR64>;
3678 }
3679 //
3680 //===----------------------------------------------------------------------===//
3681 // SVE Bitwise Shift - Predicated Group
3682 //===----------------------------------------------------------------------===//
3683 class sve_int_bin_pred_shift_imm<bits<4> tsz8_64, bits<4> opc, string asm,
3684                                  ZPRRegOp zprty, Operand immtype,
3685                                  ElementSizeEnum size>
3686 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, immtype:$imm),
3687   asm, "\t$Zdn, $Pg/m, $_Zdn, $imm",
3688   "",
3689   []>, Sched<[]> {
3690   bits<3> Pg;
3691   bits<5> Zdn;
3692   bits<6> imm;
3693   let Inst{31-24} = 0b00000100;
3694   let Inst{23-22} = tsz8_64{3-2};
3695   let Inst{21-20} = 0b00;
3696   let Inst{19-16} = opc;
3697   let Inst{15-13} = 0b100;
3698   let Inst{12-10} = Pg;
3699   let Inst{9-8}   = tsz8_64{1-0};
3700   let Inst{7-5}   = imm{2-0}; // imm3
3701   let Inst{4-0}   = Zdn;
3702
3703   let Constraints = "$Zdn = $_Zdn";
3704   let DestructiveInstType = Destructive;
3705   let ElementSize = size;
3706 }
3707
3708 multiclass sve_int_bin_pred_shift_imm_left<bits<4> opc, string asm> {
3709   def _B : sve_int_bin_pred_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftL8,
3710                                       ElementSizeB>;
3711   def _H : sve_int_bin_pred_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftL16,
3712                                       ElementSizeH> {
3713     let Inst{8} = imm{3};
3714   }
3715   def _S : sve_int_bin_pred_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftL32,
3716                                       ElementSizeS> {
3717     let Inst{9-8} = imm{4-3};
3718   }
3719   def _D : sve_int_bin_pred_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftL64,
3720                                       ElementSizeD> {
3721     let Inst{22}  = imm{5};
3722     let Inst{9-8} = imm{4-3};
3723   }
3724 }
3725
3726 multiclass sve_int_bin_pred_shift_imm_right<bits<4> opc, string asm> {
3727   def _B : sve_int_bin_pred_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftR8,
3728                                       ElementSizeB>;
3729   def _H : sve_int_bin_pred_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftR16,
3730                                       ElementSizeH> {
3731     let Inst{8} = imm{3};
3732   }
3733   def _S : sve_int_bin_pred_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftR32,
3734                                       ElementSizeS> {
3735     let Inst{9-8} = imm{4-3};
3736   }
3737   def _D : sve_int_bin_pred_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftR64,
3738                                       ElementSizeD> {
3739     let Inst{22}  = imm{5};
3740     let Inst{9-8} = imm{4-3};
3741   }
3742 }
3743
3744 class sve_int_bin_pred_shift<bits<2> sz8_64, bit wide, bits<3> opc,
3745                              string asm, ZPRRegOp zprty, ZPRRegOp zprty2>
3746 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty2:$Zm),
3747   asm, "\t$Zdn, $Pg/m, $_Zdn, $Zm",
3748   "",
3749   []>, Sched<[]> {
3750   bits<3> Pg;
3751   bits<5> Zdn;
3752   bits<5> Zm;
3753   let Inst{31-24} = 0b00000100;
3754   let Inst{23-22} = sz8_64;
3755   let Inst{21-20} = 0b01;
3756   let Inst{19}    = wide;
3757   let Inst{18-16} = opc;
3758   let Inst{15-13} = 0b100;
3759   let Inst{12-10} = Pg;
3760   let Inst{9-5}   = Zm;
3761   let Inst{4-0}   = Zdn;
3762
3763   let Constraints = "$Zdn = $_Zdn";
3764   let DestructiveInstType = Destructive;
3765   let ElementSize = zprty.ElementSize;
3766 }
3767
3768 multiclass sve_int_bin_pred_shift<bits<3> opc, string asm> {
3769   def _B : sve_int_bin_pred_shift<0b00, 0b0, opc, asm, ZPR8, ZPR8>;
3770   def _H : sve_int_bin_pred_shift<0b01, 0b0, opc, asm, ZPR16, ZPR16>;
3771   def _S : sve_int_bin_pred_shift<0b10, 0b0, opc, asm, ZPR32, ZPR32>;
3772   def _D : sve_int_bin_pred_shift<0b11, 0b0, opc, asm, ZPR64, ZPR64>;
3773 }
3774
3775 multiclass sve_int_bin_pred_shift_wide<bits<3> opc, string asm> {
3776   def _B : sve_int_bin_pred_shift<0b00, 0b1, opc, asm, ZPR8, ZPR64>;
3777   def _H : sve_int_bin_pred_shift<0b01, 0b1, opc, asm, ZPR16, ZPR64>;
3778   def _S : sve_int_bin_pred_shift<0b10, 0b1, opc, asm, ZPR32, ZPR64>;
3779 }
3780
3781 //===----------------------------------------------------------------------===//
3782 // SVE Shift - Unpredicated Group
3783 //===----------------------------------------------------------------------===//
3784
3785 class sve_int_bin_cons_shift_wide<bits<2> sz8_64, bits<2> opc, string asm,
3786                                ZPRRegOp zprty>
3787 : I<(outs zprty:$Zd), (ins zprty:$Zn, ZPR64:$Zm),
3788   asm, "\t$Zd, $Zn, $Zm",
3789   "",
3790   []>, Sched<[]> {
3791   bits<5> Zd;
3792   bits<5> Zm;
3793   bits<5> Zn;
3794   let Inst{31-24} = 0b00000100;
3795   let Inst{23-22} = sz8_64;
3796   let Inst{21}    = 0b1;
3797   let Inst{20-16} = Zm;
3798   let Inst{15-12} = 0b1000;
3799   let Inst{11-10} = opc;
3800   let Inst{9-5}   = Zn;
3801   let Inst{4-0}   = Zd;
3802 }
3803
3804 multiclass sve_int_bin_cons_shift_wide<bits<2> opc, string asm> {
3805   def _B : sve_int_bin_cons_shift_wide<0b00, opc, asm, ZPR8>;
3806   def _H : sve_int_bin_cons_shift_wide<0b01, opc, asm, ZPR16>;
3807   def _S : sve_int_bin_cons_shift_wide<0b10, opc, asm, ZPR32>;
3808 }
3809
3810 class sve_int_bin_cons_shift_imm<bits<4> tsz8_64, bits<2> opc, string asm,
3811                                ZPRRegOp zprty, Operand immtype>
3812 : I<(outs zprty:$Zd), (ins zprty:$Zn, immtype:$imm),
3813   asm, "\t$Zd, $Zn, $imm",
3814   "", []>, Sched<[]> {
3815   bits<5> Zd;
3816   bits<5> Zn;
3817   bits<6> imm;
3818   let Inst{31-24} = 0b00000100;
3819   let Inst{23-22} = tsz8_64{3-2};
3820   let Inst{21}    = 0b1;
3821   let Inst{20-19} = tsz8_64{1-0};
3822   let Inst{18-16} = imm{2-0}; // imm3
3823   let Inst{15-12} = 0b1001;
3824   let Inst{11-10} = opc;
3825   let Inst{9-5}   = Zn;
3826   let Inst{4-0}   = Zd;
3827 }
3828
3829 multiclass sve_int_bin_cons_shift_imm_left<bits<2> opc, string asm> {
3830   def _B : sve_int_bin_cons_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftL8>;
3831   def _H : sve_int_bin_cons_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftL16> {
3832     let Inst{19} = imm{3};
3833   }
3834   def _S : sve_int_bin_cons_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftL32> {
3835     let Inst{20-19} = imm{4-3};
3836   }
3837   def _D : sve_int_bin_cons_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftL64> {
3838     let Inst{22}    = imm{5};
3839     let Inst{20-19} = imm{4-3};
3840   }
3841 }
3842
3843 multiclass sve_int_bin_cons_shift_imm_right<bits<2> opc, string asm> {
3844   def _B : sve_int_bin_cons_shift_imm<{0,0,0,1}, opc, asm, ZPR8, vecshiftR8>;
3845   def _H : sve_int_bin_cons_shift_imm<{0,0,1,?}, opc, asm, ZPR16, vecshiftR16> {
3846     let Inst{19} = imm{3};
3847   }
3848   def _S : sve_int_bin_cons_shift_imm<{0,1,?,?}, opc, asm, ZPR32, vecshiftR32> {
3849     let Inst{20-19} = imm{4-3};
3850   }
3851   def _D : sve_int_bin_cons_shift_imm<{1,?,?,?}, opc, asm, ZPR64, vecshiftR64> {
3852     let Inst{22}    = imm{5};
3853     let Inst{20-19} = imm{4-3};
3854   }
3855 }
3856 //===----------------------------------------------------------------------===//
3857 // SVE Memory - Store Group
3858 //===----------------------------------------------------------------------===//
3859
3860 class sve_mem_cst_si<bits<2> msz, bits<2> esz, string asm,
3861                      RegisterOperand VecList>
3862 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4),
3863   asm, "\t$Zt, $Pg, [$Rn, $imm4, mul vl]",
3864   "",
3865   []>, Sched<[]> {
3866   bits<3> Pg;
3867   bits<5> Rn;
3868   bits<5> Zt;
3869   bits<4> imm4;
3870   let Inst{31-25} = 0b1110010;
3871   let Inst{24-23} = msz;
3872   let Inst{22-21} = esz;
3873   let Inst{20}    = 0;
3874   let Inst{19-16} = imm4;
3875   let Inst{15-13} = 0b111;
3876   let Inst{12-10} = Pg;
3877   let Inst{9-5}   = Rn;
3878   let Inst{4-0}   = Zt;
3879
3880   let mayStore = 1;
3881 }
3882
3883 multiclass sve_mem_cst_si<bits<2> msz, bits<2> esz, string asm,
3884                           RegisterOperand listty, ZPRRegOp zprty>
3885 {
3886   def NAME : sve_mem_cst_si<msz, esz, asm, listty>;
3887
3888   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $imm4, mul vl]",
3889                  (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4), 0>;
3890   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn]",
3891                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
3892   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn]",
3893                   (!cast<Instruction>(NAME) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
3894 }
3895
3896 class sve_mem_est_si<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
3897                      string asm, Operand immtype>
3898 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, immtype:$imm4),
3899   asm, "\t$Zt, $Pg, [$Rn, $imm4, mul vl]",
3900   "",
3901   []>, Sched<[]> {
3902   bits<3> Pg;
3903   bits<5> Rn;
3904   bits<5> Zt;
3905   bits<4> imm4;
3906   let Inst{31-25} = 0b1110010;
3907   let Inst{24-23} = sz;
3908   let Inst{22-21} = nregs;
3909   let Inst{20}    = 1;
3910   let Inst{19-16} = imm4;
3911   let Inst{15-13} = 0b111;
3912   let Inst{12-10} = Pg;
3913   let Inst{9-5}   = Rn;
3914   let Inst{4-0}   = Zt;
3915
3916   let mayStore = 1;
3917 }
3918
3919 multiclass sve_mem_est_si<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
3920                           string asm, Operand immtype> {
3921   def NAME : sve_mem_est_si<sz, nregs, VecList, asm, immtype>;
3922
3923   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn]",
3924                   (!cast<Instruction>(NAME) VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
3925 }
3926
3927 class sve_mem_est_ss<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
3928                      string asm, RegisterOperand gprty>
3929 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
3930   asm, "\t$Zt, $Pg, [$Rn, $Rm]",
3931   "",
3932   []>, Sched<[]> {
3933   bits<3> Pg;
3934   bits<5> Rm;
3935   bits<5> Rn;
3936   bits<5> Zt;
3937   let Inst{31-25} = 0b1110010;
3938   let Inst{24-23} = sz;
3939   let Inst{22-21} = nregs;
3940   let Inst{20-16} = Rm;
3941   let Inst{15-13} = 0b011;
3942   let Inst{12-10} = Pg;
3943   let Inst{9-5}   = Rn;
3944   let Inst{4-0}   = Zt;
3945
3946   let mayStore = 1;
3947 }
3948
3949 class sve_mem_cst_ss_base<bits<4> dtype, string asm,
3950                           RegisterOperand listty, RegisterOperand gprty>
3951 : I<(outs), (ins listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
3952   asm, "\t$Zt, $Pg, [$Rn, $Rm]",
3953   "",
3954   []>, Sched<[]> {
3955   bits<3> Pg;
3956   bits<5> Rm;
3957   bits<5> Rn;
3958   bits<5> Zt;
3959   let Inst{31-25} = 0b1110010;
3960   let Inst{24-21} = dtype;
3961   let Inst{20-16} = Rm;
3962   let Inst{15-13} = 0b010;
3963   let Inst{12-10} = Pg;
3964   let Inst{9-5}   = Rn;
3965   let Inst{4-0}   = Zt;
3966
3967   let mayStore = 1;
3968 }
3969
3970 multiclass sve_mem_cst_ss<bits<4> dtype, string asm,
3971                           RegisterOperand listty, ZPRRegOp zprty,
3972                           RegisterOperand gprty> {
3973   def NAME : sve_mem_cst_ss_base<dtype, asm, listty, gprty>;
3974
3975   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Rm]",
3976                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
3977 }
3978
3979 class sve_mem_cstnt_si<bits<2> msz, string asm, RegisterOperand VecList>
3980 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4),
3981   asm, "\t$Zt, $Pg, [$Rn, $imm4, mul vl]",
3982   "",
3983   []>, Sched<[]> {
3984   bits<3> Pg;
3985   bits<5> Rn;
3986   bits<5> Zt;
3987   bits<4> imm4;
3988   let Inst{31-25} = 0b1110010;
3989   let Inst{24-23} = msz;
3990   let Inst{22-20} = 0b001;
3991   let Inst{19-16} = imm4;
3992   let Inst{15-13} = 0b111;
3993   let Inst{12-10} = Pg;
3994   let Inst{9-5}   = Rn;
3995   let Inst{4-0}   = Zt;
3996
3997   let mayStore = 1;
3998 }
3999
4000 multiclass sve_mem_cstnt_si<bits<2> msz, string asm, RegisterOperand listty,
4001                             ZPRRegOp zprty> {
4002   def NAME : sve_mem_cstnt_si<msz, asm, listty>;
4003
4004   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn]",
4005                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
4006   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $imm4, mul vl]",
4007                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4), 0>;
4008   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn]",
4009                   (!cast<Instruction>(NAME) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4010 }
4011
4012 class sve_mem_cstnt_ss_base<bits<2> msz, string asm, RegisterOperand listty,
4013                             RegisterOperand gprty>
4014 : I<(outs), (ins listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4015   asm, "\t$Zt, $Pg, [$Rn, $Rm]",
4016   "",
4017   []>, Sched<[]> {
4018   bits<3> Pg;
4019   bits<5> Rm;
4020   bits<5> Rn;
4021   bits<5> Zt;
4022   let Inst{31-25} = 0b1110010;
4023   let Inst{24-23} = msz;
4024   let Inst{22-21} = 0b00;
4025   let Inst{20-16} = Rm;
4026   let Inst{15-13} = 0b011;
4027   let Inst{12-10} = Pg;
4028   let Inst{9-5}   = Rn;
4029   let Inst{4-0}   = Zt;
4030
4031   let mayStore = 1;
4032 }
4033
4034 multiclass sve_mem_cstnt_ss<bits<2> msz, string asm, RegisterOperand listty,
4035                             ZPRRegOp zprty, RegisterOperand gprty> {
4036   def NAME : sve_mem_cstnt_ss_base<msz, asm, listty, gprty>;
4037
4038   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Rm]",
4039                  (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
4040 }
4041
4042 class sve2_mem_sstnt_vs_base<bits<3> opc, string asm,
4043                              RegisterOperand listty, ZPRRegOp zprty>
4044 : I<(outs), (ins listty:$Zt, PPR3bAny:$Pg, zprty:$Zn, GPR64:$Rm),
4045   asm, "\t$Zt, $Pg, [$Zn, $Rm]",
4046   "",
4047   []>, Sched<[]> {
4048   bits<3> Pg;
4049   bits<5> Rm;
4050   bits<5> Zn;
4051   bits<5> Zt;
4052   let Inst{31-25} = 0b1110010;
4053   let Inst{24-22} = opc;
4054   let Inst{21}    = 0b0;
4055   let Inst{20-16} = Rm;
4056   let Inst{15-13} = 0b001;
4057   let Inst{12-10} = Pg;
4058   let Inst{9-5}   = Zn;
4059   let Inst{4-0}   = Zt;
4060
4061   let mayStore = 1;
4062 }
4063
4064 multiclass sve2_mem_sstnt_vs<bits<3> opc, string asm,
4065                              RegisterOperand listty, ZPRRegOp zprty> {
4066   def _REAL : sve2_mem_sstnt_vs_base<opc, asm, listty, zprty>;
4067
4068   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn, $Rm]",
4069                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, GPR64:$Rm), 0>;
4070   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn]",
4071                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, XZR), 0>;
4072   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn]",
4073                  (!cast<Instruction>(NAME # _REAL) listty:$Zt, PPR3bAny:$Pg, zprty:$Zn, XZR), 1>;
4074 }
4075
4076 class sve_mem_sst_sv<bits<3> opc, bit xs, bit scaled, string asm,
4077                      RegisterOperand VecList, RegisterOperand zprext>
4078 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
4079   asm, "\t$Zt, $Pg, [$Rn, $Zm]",
4080   "",
4081   []>, Sched<[]> {
4082   bits<3> Pg;
4083   bits<5> Rn;
4084   bits<5> Zm;
4085   bits<5> Zt;
4086   let Inst{31-25} = 0b1110010;
4087   let Inst{24-22} = opc;
4088   let Inst{21}    = scaled;
4089   let Inst{20-16} = Zm;
4090   let Inst{15}    = 0b1;
4091   let Inst{14}    = xs;
4092   let Inst{13}    = 0;
4093   let Inst{12-10} = Pg;
4094   let Inst{9-5}   = Rn;
4095   let Inst{4-0}   = Zt;
4096
4097   let mayStore = 1;
4098 }
4099
4100 multiclass sve_mem_sst_sv_32_scaled<bits<3> opc, string asm,
4101                                     RegisterOperand listty,
4102                                     ZPRRegOp zprty,
4103                                     RegisterOperand sxtw_opnd,
4104                                     RegisterOperand uxtw_opnd > {
4105   def _UXTW_SCALED : sve_mem_sst_sv<opc, 0, 1, asm, listty, uxtw_opnd>;
4106   def _SXTW_SCALED : sve_mem_sst_sv<opc, 1, 1, asm, listty, sxtw_opnd>;
4107
4108   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4109                  (!cast<Instruction>(NAME # _UXTW_SCALED) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
4110   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4111                  (!cast<Instruction>(NAME # _SXTW_SCALED) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
4112 }
4113
4114 multiclass sve_mem_sst_sv_32_unscaled<bits<3> opc, string asm,
4115                                       RegisterOperand listty,
4116                                       ZPRRegOp zprty,
4117                                       RegisterOperand sxtw_opnd,
4118                                       RegisterOperand uxtw_opnd> {
4119   def _UXTW : sve_mem_sst_sv<opc, 0, 0, asm, listty, uxtw_opnd>;
4120   def _SXTW : sve_mem_sst_sv<opc, 1, 0, asm, listty, sxtw_opnd>;
4121
4122   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4123                  (!cast<Instruction>(NAME # _UXTW) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
4124   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4125                  (!cast<Instruction>(NAME # _SXTW) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
4126 }
4127
4128 class sve_mem_sst_sv2<bits<2> msz, bit scaled, string asm,
4129                       RegisterOperand zprext>
4130 : I<(outs), (ins Z_d:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
4131   asm, "\t$Zt, $Pg, [$Rn, $Zm]",
4132   "",
4133   []>, Sched<[]> {
4134   bits<3> Pg;
4135   bits<5> Rn;
4136   bits<5> Zm;
4137   bits<5> Zt;
4138   let Inst{31-25} = 0b1110010;
4139   let Inst{24-23} = msz;
4140   let Inst{22}    = 0b0;
4141   let Inst{21}    = scaled;
4142   let Inst{20-16} = Zm;
4143   let Inst{15-13} = 0b101;
4144   let Inst{12-10} = Pg;
4145   let Inst{9-5}   = Rn;
4146   let Inst{4-0}   = Zt;
4147
4148   let mayStore = 1;
4149 }
4150
4151 multiclass sve_mem_sst_sv_64_scaled<bits<2> msz, string asm,
4152                                     RegisterOperand zprext> {
4153   def "" : sve_mem_sst_sv2<msz, 1, asm, zprext>;
4154
4155   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4156                  (!cast<Instruction>(NAME) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm), 0>;
4157
4158 }
4159
4160 multiclass sve_mem_sst_sv_64_unscaled<bits<2> msz, string asm> {
4161   def "" : sve_mem_sst_sv2<msz, 0, asm, ZPR64ExtLSL8>;
4162
4163   def : InstAlias<asm # "\t$Zt, $Pg, [$Rn, $Zm]",
4164                  (!cast<Instruction>(NAME) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, ZPR64ExtLSL8:$Zm), 0>;
4165 }
4166
4167 class sve_mem_sst_vi<bits<3> opc, string asm, ZPRRegOp zprty,
4168                      RegisterOperand VecList, Operand imm_ty>
4169 : I<(outs), (ins VecList:$Zt, PPR3bAny:$Pg, zprty:$Zn, imm_ty:$imm5),
4170   asm, "\t$Zt, $Pg, [$Zn, $imm5]",
4171   "",
4172   []>, Sched<[]> {
4173   bits<3> Pg;
4174   bits<5> imm5;
4175   bits<5> Zn;
4176   bits<5> Zt;
4177   let Inst{31-25} = 0b1110010;
4178   let Inst{24-23} = opc{2-1};
4179   let Inst{22}    = 0b1;
4180   let Inst{21}    = opc{0};
4181   let Inst{20-16} = imm5;
4182   let Inst{15-13} = 0b101;
4183   let Inst{12-10} = Pg;
4184   let Inst{9-5}   = Zn;
4185   let Inst{4-0}   = Zt;
4186
4187   let mayStore = 1;
4188 }
4189
4190 multiclass sve_mem_sst_vi_ptrs<bits<3> opc, string asm, RegisterOperand listty,
4191                                ZPRRegOp zprty, Operand imm_ty> {
4192   def _IMM : sve_mem_sst_vi<opc, asm, zprty, listty, imm_ty>;
4193
4194   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn]",
4195                   (!cast<Instruction>(NAME # _IMM) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, 0), 0>;
4196   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn, $imm5]",
4197                   (!cast<Instruction>(NAME # _IMM) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, imm_ty:$imm5), 0>;
4198   def : InstAlias<asm # "\t$Zt, $Pg, [$Zn]",
4199                   (!cast<Instruction>(NAME # _IMM) listty:$Zt, PPR3bAny:$Pg, zprty:$Zn, 0), 1>;
4200 }
4201
4202 class sve_mem_z_spill<string asm>
4203 : I<(outs), (ins ZPRAny:$Zt, GPR64sp:$Rn, simm9:$imm9),
4204   asm, "\t$Zt, [$Rn, $imm9, mul vl]",
4205   "",
4206   []>, Sched<[]> {
4207   bits<5> Rn;
4208   bits<5> Zt;
4209   bits<9> imm9;
4210   let Inst{31-22} = 0b1110010110;
4211   let Inst{21-16} = imm9{8-3};
4212   let Inst{15-13} = 0b010;
4213   let Inst{12-10} = imm9{2-0};
4214   let Inst{9-5}   = Rn;
4215   let Inst{4-0}   = Zt;
4216
4217   let mayStore = 1;
4218 }
4219
4220 multiclass sve_mem_z_spill<string asm> {
4221   def NAME : sve_mem_z_spill<asm>;
4222
4223   def : InstAlias<asm # "\t$Zt, [$Rn]",
4224                   (!cast<Instruction>(NAME) ZPRAny:$Zt, GPR64sp:$Rn, 0), 1>;
4225 }
4226
4227 class sve_mem_p_spill<string asm>
4228 : I<(outs), (ins PPRAny:$Pt, GPR64sp:$Rn, simm9:$imm9),
4229   asm, "\t$Pt, [$Rn, $imm9, mul vl]",
4230   "",
4231   []>, Sched<[]> {
4232   bits<4> Pt;
4233   bits<5> Rn;
4234   bits<9> imm9;
4235   let Inst{31-22} = 0b1110010110;
4236   let Inst{21-16} = imm9{8-3};
4237   let Inst{15-13} = 0b000;
4238   let Inst{12-10} = imm9{2-0};
4239   let Inst{9-5}   = Rn;
4240   let Inst{4}     = 0b0;
4241   let Inst{3-0}   = Pt;
4242
4243   let mayStore = 1;
4244 }
4245
4246 multiclass sve_mem_p_spill<string asm> {
4247   def NAME : sve_mem_p_spill<asm>;
4248
4249   def : InstAlias<asm # "\t$Pt, [$Rn]",
4250                   (!cast<Instruction>(NAME) PPRAny:$Pt, GPR64sp:$Rn, 0), 1>;
4251 }
4252
4253 //===----------------------------------------------------------------------===//
4254 // SVE Permute - Predicates Group
4255 //===----------------------------------------------------------------------===//
4256
4257 class sve_int_perm_bin_perm_pp<bits<3> opc, bits<2> sz8_64, string asm,
4258                                PPRRegOp pprty>
4259 : I<(outs pprty:$Pd), (ins pprty:$Pn, pprty:$Pm),
4260   asm, "\t$Pd, $Pn, $Pm",
4261   "",
4262   []>, Sched<[]> {
4263   bits<4> Pd;
4264   bits<4> Pm;
4265   bits<4> Pn;
4266   let Inst{31-24} = 0b00000101;
4267   let Inst{23-22} = sz8_64;
4268   let Inst{21-20} = 0b10;
4269   let Inst{19-16} = Pm;
4270   let Inst{15-13} = 0b010;
4271   let Inst{12-10} = opc;
4272   let Inst{9}     = 0b0;
4273   let Inst{8-5}   = Pn;
4274   let Inst{4}     = 0b0;
4275   let Inst{3-0}   = Pd;
4276 }
4277
4278 multiclass sve_int_perm_bin_perm_pp<bits<3> opc, string asm> {
4279   def _B : sve_int_perm_bin_perm_pp<opc, 0b00, asm, PPR8>;
4280   def _H : sve_int_perm_bin_perm_pp<opc, 0b01, asm, PPR16>;
4281   def _S : sve_int_perm_bin_perm_pp<opc, 0b10, asm, PPR32>;
4282   def _D : sve_int_perm_bin_perm_pp<opc, 0b11, asm, PPR64>;
4283 }
4284
4285 class sve_int_perm_punpk<bit opc, string asm>
4286 : I<(outs PPR16:$Pd), (ins PPR8:$Pn),
4287   asm, "\t$Pd, $Pn",
4288   "",
4289   []>, Sched<[]> {
4290   bits<4> Pd;
4291   bits<4> Pn;
4292   let Inst{31-17} = 0b000001010011000;
4293   let Inst{16}    = opc;
4294   let Inst{15-9}  = 0b0100000;
4295   let Inst{8-5}   = Pn;
4296   let Inst{4}     = 0b0;
4297   let Inst{3-0}   = Pd;
4298 }
4299
4300 multiclass sve_int_perm_punpk<bit opc, string asm, SDPatternOperator op> {
4301   def NAME : sve_int_perm_punpk<opc, asm>;
4302
4303   def : SVE_1_Op_Pat<nxv8i1, op, nxv16i1, !cast<Instruction>(NAME)>;
4304   def : SVE_1_Op_Pat<nxv4i1, op, nxv8i1,  !cast<Instruction>(NAME)>;
4305   def : SVE_1_Op_Pat<nxv2i1, op, nxv4i1,  !cast<Instruction>(NAME)>;
4306 }
4307
4308 class sve_int_rdffr_pred<bit s, string asm>
4309 : I<(outs PPR8:$Pd), (ins PPRAny:$Pg),
4310   asm, "\t$Pd, $Pg/z",
4311   "",
4312   []>, Sched<[]> {
4313   bits<4> Pd;
4314   bits<4> Pg;
4315   let Inst{31-23} = 0b001001010;
4316   let Inst{22}    = s;
4317   let Inst{21-9}  = 0b0110001111000;
4318   let Inst{8-5}   = Pg;
4319   let Inst{4}     = 0;
4320   let Inst{3-0}   = Pd;
4321
4322   let Defs = !if(!eq (s, 1), [NZCV], []);
4323   let Uses = [FFR];
4324 }
4325
4326 class sve_int_rdffr_unpred<string asm> : I<
4327   (outs PPR8:$Pd), (ins),
4328   asm, "\t$Pd",
4329   "",
4330   []>, Sched<[]> {
4331   bits<4> Pd;
4332   let Inst{31-4} = 0b0010010100011001111100000000;
4333   let Inst{3-0}   = Pd;
4334
4335   let Uses = [FFR];
4336 }
4337
4338 class sve_int_wrffr<string asm>
4339 : I<(outs), (ins PPR8:$Pn),
4340   asm, "\t$Pn",
4341   "",
4342   []>, Sched<[]> {
4343   bits<4> Pn;
4344   let Inst{31-9} = 0b00100101001010001001000;
4345   let Inst{8-5}  = Pn;
4346   let Inst{4-0}  = 0b00000;
4347
4348   let hasSideEffects = 1;
4349   let Defs = [FFR];
4350 }
4351
4352 class sve_int_setffr<string asm>
4353 : I<(outs), (ins),
4354   asm, "",
4355   "",
4356   []>, Sched<[]> {
4357   let Inst{31-0} = 0b00100101001011001001000000000000;
4358
4359   let hasSideEffects = 1;
4360   let Defs = [FFR];
4361 }
4362
4363 //===----------------------------------------------------------------------===//
4364 // SVE Permute Vector - Predicated Group
4365 //===----------------------------------------------------------------------===//
4366
4367 class sve_int_perm_clast_rz<bits<2> sz8_64, bit ab, string asm,
4368                             ZPRRegOp zprty, RegisterClass rt>
4369 : I<(outs rt:$Rdn), (ins PPR3bAny:$Pg, rt:$_Rdn, zprty:$Zm),
4370   asm, "\t$Rdn, $Pg, $_Rdn, $Zm",
4371   "",
4372   []>, Sched<[]> {
4373   bits<3> Pg;
4374   bits<5> Rdn;
4375   bits<5> Zm;
4376   let Inst{31-24} = 0b00000101;
4377   let Inst{23-22} = sz8_64;
4378   let Inst{21-17} = 0b11000;
4379   let Inst{16}    = ab;
4380   let Inst{15-13} = 0b101;
4381   let Inst{12-10} = Pg;
4382   let Inst{9-5}   = Zm;
4383   let Inst{4-0}   = Rdn;
4384
4385   let Constraints = "$Rdn = $_Rdn";
4386 }
4387
4388 multiclass sve_int_perm_clast_rz<bit ab, string asm> {
4389   def _B : sve_int_perm_clast_rz<0b00, ab, asm, ZPR8, GPR32>;
4390   def _H : sve_int_perm_clast_rz<0b01, ab, asm, ZPR16, GPR32>;
4391   def _S : sve_int_perm_clast_rz<0b10, ab, asm, ZPR32, GPR32>;
4392   def _D : sve_int_perm_clast_rz<0b11, ab, asm, ZPR64, GPR64>;
4393 }
4394
4395 class sve_int_perm_clast_vz<bits<2> sz8_64, bit ab, string asm,
4396                             ZPRRegOp zprty, RegisterClass rt>
4397 : I<(outs rt:$Vdn), (ins PPR3bAny:$Pg, rt:$_Vdn, zprty:$Zm),
4398   asm, "\t$Vdn, $Pg, $_Vdn, $Zm",
4399   "",
4400   []>, Sched<[]> {
4401   bits<3> Pg;
4402   bits<5> Vdn;
4403   bits<5> Zm;
4404   let Inst{31-24} = 0b00000101;
4405   let Inst{23-22} = sz8_64;
4406   let Inst{21-17} = 0b10101;
4407   let Inst{16}    = ab;
4408   let Inst{15-13} = 0b100;
4409   let Inst{12-10} = Pg;
4410   let Inst{9-5}   = Zm;
4411   let Inst{4-0}   = Vdn;
4412
4413   let Constraints = "$Vdn = $_Vdn";
4414 }
4415
4416 multiclass sve_int_perm_clast_vz<bit ab, string asm> {
4417   def _B : sve_int_perm_clast_vz<0b00, ab, asm, ZPR8, FPR8>;
4418   def _H : sve_int_perm_clast_vz<0b01, ab, asm, ZPR16, FPR16>;
4419   def _S : sve_int_perm_clast_vz<0b10, ab, asm, ZPR32, FPR32>;
4420   def _D : sve_int_perm_clast_vz<0b11, ab, asm, ZPR64, FPR64>;
4421 }
4422
4423 class sve_int_perm_clast_zz<bits<2> sz8_64, bit ab, string asm,
4424                             ZPRRegOp zprty>
4425 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
4426   asm, "\t$Zdn, $Pg, $_Zdn, $Zm",
4427   "",
4428   []>, Sched<[]> {
4429   bits<3> Pg;
4430   bits<5> Zdn;
4431   bits<5> Zm;
4432   let Inst{31-24} = 0b00000101;
4433   let Inst{23-22} = sz8_64;
4434   let Inst{21-17} = 0b10100;
4435   let Inst{16}    = ab;
4436   let Inst{15-13} = 0b100;
4437   let Inst{12-10} = Pg;
4438   let Inst{9-5}   = Zm;
4439   let Inst{4-0}   = Zdn;
4440
4441   let Constraints = "$Zdn = $_Zdn";
4442   let DestructiveInstType = Destructive;
4443   let ElementSize = ElementSizeNone;
4444 }
4445
4446 multiclass sve_int_perm_clast_zz<bit ab, string asm> {
4447   def _B : sve_int_perm_clast_zz<0b00, ab, asm, ZPR8>;
4448   def _H : sve_int_perm_clast_zz<0b01, ab, asm, ZPR16>;
4449   def _S : sve_int_perm_clast_zz<0b10, ab, asm, ZPR32>;
4450   def _D : sve_int_perm_clast_zz<0b11, ab, asm, ZPR64>;
4451 }
4452
4453 class sve_int_perm_last_r<bits<2> sz8_64, bit ab, string asm,
4454                           ZPRRegOp zprty, RegisterClass resultRegType>
4455 : I<(outs resultRegType:$Rd), (ins PPR3bAny:$Pg, zprty:$Zn),
4456   asm, "\t$Rd, $Pg, $Zn",
4457   "",
4458   []>, Sched<[]> {
4459   bits<3> Pg;
4460   bits<5> Rd;
4461   bits<5> Zn;
4462   let Inst{31-24} = 0b00000101;
4463   let Inst{23-22} = sz8_64;
4464   let Inst{21-17} = 0b10000;
4465   let Inst{16}    = ab;
4466   let Inst{15-13} = 0b101;
4467   let Inst{12-10} = Pg;
4468   let Inst{9-5}   = Zn;
4469   let Inst{4-0}   = Rd;
4470 }
4471
4472 multiclass sve_int_perm_last_r<bit ab, string asm> {
4473   def _B : sve_int_perm_last_r<0b00, ab, asm, ZPR8, GPR32>;
4474   def _H : sve_int_perm_last_r<0b01, ab, asm, ZPR16, GPR32>;
4475   def _S : sve_int_perm_last_r<0b10, ab, asm, ZPR32, GPR32>;
4476   def _D : sve_int_perm_last_r<0b11, ab, asm, ZPR64, GPR64>;
4477 }
4478
4479 class sve_int_perm_last_v<bits<2> sz8_64, bit ab, string asm,
4480                           ZPRRegOp zprty, RegisterClass dstRegtype>
4481 : I<(outs dstRegtype:$Vd), (ins PPR3bAny:$Pg, zprty:$Zn),
4482   asm, "\t$Vd, $Pg, $Zn",
4483   "",
4484   []>, Sched<[]> {
4485   bits<3> Pg;
4486   bits<5> Vd;
4487   bits<5> Zn;
4488   let Inst{31-24} = 0b00000101;
4489   let Inst{23-22} = sz8_64;
4490   let Inst{21-17} = 0b10001;
4491   let Inst{16}    = ab;
4492   let Inst{15-13} = 0b100;
4493   let Inst{12-10} = Pg;
4494   let Inst{9-5}   = Zn;
4495   let Inst{4-0}   = Vd;
4496 }
4497
4498 multiclass sve_int_perm_last_v<bit ab, string asm> {
4499   def _B : sve_int_perm_last_v<0b00, ab, asm, ZPR8, FPR8>;
4500   def _H : sve_int_perm_last_v<0b01, ab, asm, ZPR16, FPR16>;
4501   def _S : sve_int_perm_last_v<0b10, ab, asm, ZPR32, FPR32>;
4502   def _D : sve_int_perm_last_v<0b11, ab, asm, ZPR64, FPR64>;
4503 }
4504
4505 class sve_int_perm_splice<bits<2> sz8_64, string asm, ZPRRegOp zprty>
4506 : I<(outs zprty:$Zdn), (ins PPR3bAny:$Pg, zprty:$_Zdn, zprty:$Zm),
4507   asm, "\t$Zdn, $Pg, $_Zdn, $Zm",
4508   "",
4509   []>, Sched<[]> {
4510   bits<3> Pg;
4511   bits<5> Zdn;
4512   bits<5> Zm;
4513   let Inst{31-24} = 0b00000101;
4514   let Inst{23-22} = sz8_64;
4515   let Inst{21-13} = 0b101100100;
4516   let Inst{12-10} = Pg;
4517   let Inst{9-5}   = Zm;
4518   let Inst{4-0}   = Zdn;
4519
4520   let Constraints = "$Zdn = $_Zdn";
4521   let DestructiveInstType = Destructive;
4522   let ElementSize = ElementSizeNone;
4523 }
4524
4525 multiclass sve_int_perm_splice<string asm> {
4526   def _B : sve_int_perm_splice<0b00, asm, ZPR8>;
4527   def _H : sve_int_perm_splice<0b01, asm, ZPR16>;
4528   def _S : sve_int_perm_splice<0b10, asm, ZPR32>;
4529   def _D : sve_int_perm_splice<0b11, asm, ZPR64>;
4530 }
4531
4532 class sve2_int_perm_splice_cons<bits<2> sz8_64, string asm,
4533                                ZPRRegOp zprty, RegisterOperand VecList>
4534 : I<(outs zprty:$Zd), (ins PPR3bAny:$Pg, VecList:$Zn),
4535   asm, "\t$Zd, $Pg, $Zn",
4536   "",
4537   []>, Sched<[]> {
4538   bits<3> Pg;
4539   bits<5> Zn;
4540   bits<5> Zd;
4541   let Inst{31-24} = 0b00000101;
4542   let Inst{23-22} = sz8_64;
4543   let Inst{21-13} = 0b101101100;
4544   let Inst{12-10} = Pg;
4545   let Inst{9-5}   = Zn;
4546   let Inst{4-0}   = Zd;
4547 }
4548
4549 multiclass sve2_int_perm_splice_cons<string asm> {
4550   def _B : sve2_int_perm_splice_cons<0b00, asm, ZPR8,  ZZ_b>;
4551   def _H : sve2_int_perm_splice_cons<0b01, asm, ZPR16, ZZ_h>;
4552   def _S : sve2_int_perm_splice_cons<0b10, asm, ZPR32, ZZ_s>;
4553   def _D : sve2_int_perm_splice_cons<0b11, asm, ZPR64, ZZ_d>;
4554 }
4555
4556 class sve_int_perm_rev<bits<2> sz8_64, bits<2> opc, string asm,
4557                        ZPRRegOp zprty>
4558 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPR3bAny:$Pg, zprty:$Zn),
4559   asm, "\t$Zd, $Pg/m, $Zn",
4560   "",
4561   []>, Sched<[]> {
4562   bits<5> Zd;
4563   bits<3> Pg;
4564   bits<5> Zn;
4565   let Inst{31-24} = 0b00000101;
4566   let Inst{23-22} = sz8_64;
4567   let Inst{21-18} = 0b1001;
4568   let Inst{17-16} = opc;
4569   let Inst{15-13} = 0b100;
4570   let Inst{12-10} = Pg;
4571   let Inst{9-5}   = Zn;
4572   let Inst{4-0}   = Zd;
4573
4574   let Constraints = "$Zd = $_Zd";
4575   let DestructiveInstType = Destructive;
4576   let ElementSize = zprty.ElementSize;
4577 }
4578
4579 multiclass sve_int_perm_rev_rbit<string asm> {
4580   def _B : sve_int_perm_rev<0b00, 0b11, asm, ZPR8>;
4581   def _H : sve_int_perm_rev<0b01, 0b11, asm, ZPR16>;
4582   def _S : sve_int_perm_rev<0b10, 0b11, asm, ZPR32>;
4583   def _D : sve_int_perm_rev<0b11, 0b11, asm, ZPR64>;
4584 }
4585
4586 multiclass sve_int_perm_rev_revb<string asm> {
4587   def _H : sve_int_perm_rev<0b01, 0b00, asm, ZPR16>;
4588   def _S : sve_int_perm_rev<0b10, 0b00, asm, ZPR32>;
4589   def _D : sve_int_perm_rev<0b11, 0b00, asm, ZPR64>;
4590 }
4591
4592 multiclass sve_int_perm_rev_revh<string asm> {
4593   def _S : sve_int_perm_rev<0b10, 0b01, asm, ZPR32>;
4594   def _D : sve_int_perm_rev<0b11, 0b01, asm, ZPR64>;
4595 }
4596
4597 multiclass sve_int_perm_rev_revw<string asm> {
4598   def _D : sve_int_perm_rev<0b11, 0b10, asm, ZPR64>;
4599 }
4600
4601 class sve_int_perm_cpy_r<bits<2> sz8_64, string asm, ZPRRegOp zprty,
4602                          RegisterClass srcRegType>
4603 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPR3bAny:$Pg, srcRegType:$Rn),
4604   asm, "\t$Zd, $Pg/m, $Rn",
4605   "",
4606   []>, Sched<[]> {
4607   bits<3> Pg;
4608   bits<5> Rn;
4609   bits<5> Zd;
4610   let Inst{31-24} = 0b00000101;
4611   let Inst{23-22} = sz8_64;
4612   let Inst{21-13} = 0b101000101;
4613   let Inst{12-10} = Pg;
4614   let Inst{9-5}   = Rn;
4615   let Inst{4-0}   = Zd;
4616
4617   let Constraints = "$Zd = $_Zd";
4618   let DestructiveInstType = Destructive;
4619   let ElementSize = zprty.ElementSize;
4620 }
4621
4622 multiclass sve_int_perm_cpy_r<string asm> {
4623   def _B : sve_int_perm_cpy_r<0b00, asm, ZPR8, GPR32sp>;
4624   def _H : sve_int_perm_cpy_r<0b01, asm, ZPR16, GPR32sp>;
4625   def _S : sve_int_perm_cpy_r<0b10, asm, ZPR32, GPR32sp>;
4626   def _D : sve_int_perm_cpy_r<0b11, asm, ZPR64, GPR64sp>;
4627
4628   def : InstAlias<"mov $Zd, $Pg/m, $Rn",
4629                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, PPR3bAny:$Pg, GPR32sp:$Rn), 1>;
4630   def : InstAlias<"mov $Zd, $Pg/m, $Rn",
4631                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPR3bAny:$Pg, GPR32sp:$Rn), 1>;
4632   def : InstAlias<"mov $Zd, $Pg/m, $Rn",
4633                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPR3bAny:$Pg, GPR32sp:$Rn), 1>;
4634   def : InstAlias<"mov $Zd, $Pg/m, $Rn",
4635                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPR3bAny:$Pg, GPR64sp:$Rn), 1>;
4636 }
4637
4638 class sve_int_perm_cpy_v<bits<2> sz8_64, string asm, ZPRRegOp zprty,
4639                          RegisterClass srcRegtype>
4640 : I<(outs zprty:$Zd), (ins zprty:$_Zd, PPR3bAny:$Pg, srcRegtype:$Vn),
4641   asm, "\t$Zd, $Pg/m, $Vn",
4642   "",
4643   []>, Sched<[]> {
4644   bits<3> Pg;
4645   bits<5> Vn;
4646   bits<5> Zd;
4647   let Inst{31-24} = 0b00000101;
4648   let Inst{23-22} = sz8_64;
4649   let Inst{21-13} = 0b100000100;
4650   let Inst{12-10} = Pg;
4651   let Inst{9-5}   = Vn;
4652   let Inst{4-0}   = Zd;
4653
4654   let Constraints = "$Zd = $_Zd";
4655   let DestructiveInstType = Destructive;
4656   let ElementSize = zprty.ElementSize;
4657 }
4658
4659 multiclass sve_int_perm_cpy_v<string asm> {
4660   def _B : sve_int_perm_cpy_v<0b00, asm, ZPR8, FPR8>;
4661   def _H : sve_int_perm_cpy_v<0b01, asm, ZPR16, FPR16>;
4662   def _S : sve_int_perm_cpy_v<0b10, asm, ZPR32, FPR32>;
4663   def _D : sve_int_perm_cpy_v<0b11, asm, ZPR64, FPR64>;
4664
4665   def : InstAlias<"mov $Zd, $Pg/m, $Vn",
4666                   (!cast<Instruction>(NAME # _B) ZPR8:$Zd, PPR3bAny:$Pg, FPR8:$Vn), 1>;
4667   def : InstAlias<"mov $Zd, $Pg/m, $Vn",
4668                   (!cast<Instruction>(NAME # _H) ZPR16:$Zd, PPR3bAny:$Pg, FPR16:$Vn), 1>;
4669   def : InstAlias<"mov $Zd, $Pg/m, $Vn",
4670                   (!cast<Instruction>(NAME # _S) ZPR32:$Zd, PPR3bAny:$Pg, FPR32:$Vn), 1>;
4671   def : InstAlias<"mov $Zd, $Pg/m, $Vn",
4672                   (!cast<Instruction>(NAME # _D) ZPR64:$Zd, PPR3bAny:$Pg, FPR64:$Vn), 1>;
4673 }
4674
4675 class sve_int_perm_compact<bit sz, string asm, ZPRRegOp zprty>
4676 : I<(outs zprty:$Zd), (ins PPR3bAny:$Pg, zprty:$Zn),
4677   asm, "\t$Zd, $Pg, $Zn",
4678   "",
4679   []>, Sched<[]> {
4680   bits<3> Pg;
4681   bits<5> Zd;
4682   bits<5> Zn;
4683   let Inst{31-23} = 0b000001011;
4684   let Inst{22}    = sz;
4685   let Inst{21-13} = 0b100001100;
4686   let Inst{12-10} = Pg;
4687   let Inst{9-5}   = Zn;
4688   let Inst{4-0}   = Zd;
4689 }
4690
4691 multiclass sve_int_perm_compact<string asm> {
4692   def _S : sve_int_perm_compact<0b0, asm, ZPR32>;
4693   def _D : sve_int_perm_compact<0b1, asm, ZPR64>;
4694 }
4695
4696
4697 //===----------------------------------------------------------------------===//
4698 // SVE Memory - Contiguous Load Group
4699 //===----------------------------------------------------------------------===//
4700
4701 class sve_mem_cld_si_base<bits<4> dtype, bit nf, string asm,
4702                           RegisterOperand VecList>
4703 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4),
4704   asm, "\t$Zt, $Pg/z, [$Rn, $imm4, mul vl]",
4705   "",
4706   []>, Sched<[]> {
4707   bits<3> Pg;
4708   bits<5> Rn;
4709   bits<5> Zt;
4710   bits<4> imm4;
4711   let Inst{31-25} = 0b1010010;
4712   let Inst{24-21} = dtype;
4713   let Inst{20}    = nf;
4714   let Inst{19-16} = imm4;
4715   let Inst{15-13} = 0b101;
4716   let Inst{12-10} = Pg;
4717   let Inst{9-5}   = Rn;
4718   let Inst{4-0}   = Zt;
4719
4720   let mayLoad = 1;
4721   let Uses = !if(!eq(nf, 1), [FFR], []);
4722   let Defs = !if(!eq(nf, 1), [FFR], []);
4723 }
4724
4725 multiclass sve_mem_cld_si_base<bits<4> dtype, bit nf, string asm,
4726                                RegisterOperand listty, ZPRRegOp zprty> {
4727   def _REAL : sve_mem_cld_si_base<dtype, nf, asm, listty>;
4728
4729   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4730                   (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
4731   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $imm4, mul vl]",
4732                   (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4), 0>;
4733   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4734                   (!cast<Instruction>(NAME # _REAL) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4735 }
4736
4737 multiclass sve_mem_cld_si<bits<4> dtype, string asm, RegisterOperand listty,
4738                           ZPRRegOp zprty>
4739 : sve_mem_cld_si_base<dtype, 0, asm, listty, zprty>;
4740
4741 class sve_mem_cldnt_si_base<bits<2> msz, string asm, RegisterOperand VecList>
4742 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4),
4743   asm, "\t$Zt, $Pg/z, [$Rn, $imm4, mul vl]",
4744   "",
4745   []>, Sched<[]> {
4746   bits<5> Zt;
4747   bits<3> Pg;
4748   bits<5> Rn;
4749   bits<4> imm4;
4750   let Inst{31-25} = 0b1010010;
4751   let Inst{24-23} = msz;
4752   let Inst{22-20} = 0b000;
4753   let Inst{19-16} = imm4;
4754   let Inst{15-13} = 0b111;
4755   let Inst{12-10} = Pg;
4756   let Inst{9-5}   = Rn;
4757   let Inst{4-0}   = Zt;
4758
4759   let mayLoad = 1;
4760 }
4761
4762 multiclass sve_mem_cldnt_si<bits<2> msz, string asm, RegisterOperand listty,
4763                             ZPRRegOp zprty> {
4764   def NAME : sve_mem_cldnt_si_base<msz, asm, listty>;
4765
4766   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4767                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
4768   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $imm4, mul vl]",
4769                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s1:$imm4), 0>;
4770   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4771                   (!cast<Instruction>(NAME) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4772 }
4773
4774 class sve_mem_cldnt_ss_base<bits<2> msz, string asm, RegisterOperand VecList,
4775                             RegisterOperand gprty>
4776 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4777   asm, "\t$Zt, $Pg/z, [$Rn, $Rm]",
4778   "",
4779   []>, Sched<[]> {
4780   bits<3> Pg;
4781   bits<5> Rm;
4782   bits<5> Rn;
4783   bits<5> Zt;
4784   let Inst{31-25} = 0b1010010;
4785   let Inst{24-23} = msz;
4786   let Inst{22-21} = 0b00;
4787   let Inst{20-16} = Rm;
4788   let Inst{15-13} = 0b110;
4789   let Inst{12-10} = Pg;
4790   let Inst{9-5}   = Rn;
4791   let Inst{4-0}   = Zt;
4792
4793   let mayLoad = 1;
4794 }
4795
4796 multiclass sve_mem_cldnt_ss<bits<2> msz, string asm, RegisterOperand listty,
4797                             ZPRRegOp zprty, RegisterOperand gprty> {
4798   def NAME : sve_mem_cldnt_ss_base<msz, asm, listty, gprty>;
4799
4800   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Rm]",
4801                  (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
4802 }
4803
4804 class sve_mem_ldqr_si<bits<2> sz, string asm, RegisterOperand VecList>
4805 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, simm4s16:$imm4),
4806   asm, "\t$Zt, $Pg/z, [$Rn, $imm4]", "", []>, Sched<[]> {
4807   bits<5> Zt;
4808   bits<5> Rn;
4809   bits<3> Pg;
4810   bits<4> imm4;
4811   let Inst{31-25} = 0b1010010;
4812   let Inst{24-23} = sz;
4813   let Inst{22-20} = 0;
4814   let Inst{19-16} = imm4;
4815   let Inst{15-13} = 0b001;
4816   let Inst{12-10} = Pg;
4817   let Inst{9-5}   = Rn;
4818   let Inst{4-0}   = Zt;
4819
4820   let mayLoad = 1;
4821 }
4822
4823 multiclass sve_mem_ldqr_si<bits<2> sz, string asm, RegisterOperand listty,
4824                            ZPRRegOp zprty> {
4825   def NAME : sve_mem_ldqr_si<sz, asm, listty>;
4826   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4827                   (!cast<Instruction>(NAME) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4828   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4829                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
4830   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $imm4]",
4831                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, simm4s16:$imm4), 0>;
4832 }
4833
4834 class sve_mem_ldqr_ss<bits<2> sz, string asm, RegisterOperand VecList,
4835                       RegisterOperand gprty>
4836 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4837   asm, "\t$Zt, $Pg/z, [$Rn, $Rm]", "", []>, Sched<[]> {
4838   bits<5> Zt;
4839   bits<3> Pg;
4840   bits<5> Rn;
4841   bits<5> Rm;
4842   let Inst{31-25} = 0b1010010;
4843   let Inst{24-23} = sz;
4844   let Inst{22-21} = 0;
4845   let Inst{20-16} = Rm;
4846   let Inst{15-13} = 0;
4847   let Inst{12-10} = Pg;
4848   let Inst{9-5}   = Rn;
4849   let Inst{4-0}   = Zt;
4850
4851   let mayLoad = 1;
4852 }
4853
4854 multiclass sve_mem_ldqr_ss<bits<2> sz, string asm, RegisterOperand listty,
4855                            ZPRRegOp zprty, RegisterOperand gprty> {
4856   def NAME : sve_mem_ldqr_ss<sz, asm, listty, gprty>;
4857
4858   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Rm]",
4859                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
4860 }
4861
4862 class sve_mem_ld_dup<bits<2> dtypeh, bits<2> dtypel, string asm,
4863                      RegisterOperand VecList, Operand immtype>
4864 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, immtype:$imm6),
4865   asm, "\t$Zt, $Pg/z, [$Rn, $imm6]",
4866   "",
4867   []>, Sched<[]> {
4868   bits<3> Pg;
4869   bits<5> Rn;
4870   bits<5> Zt;
4871   bits<6> imm6;
4872   let Inst{31-25} = 0b1000010;
4873   let Inst{24-23} = dtypeh;
4874   let Inst{22}    = 1;
4875   let Inst{21-16} = imm6;
4876   let Inst{15}    = 0b1;
4877   let Inst{14-13} = dtypel;
4878   let Inst{12-10} = Pg;
4879   let Inst{9-5}   = Rn;
4880   let Inst{4-0}   = Zt;
4881
4882   let mayLoad = 1;
4883 }
4884
4885 multiclass sve_mem_ld_dup<bits<2> dtypeh, bits<2> dtypel, string asm,
4886                           RegisterOperand zlistty, ZPRRegOp zprty, Operand immtype> {
4887   def NAME : sve_mem_ld_dup<dtypeh, dtypel, asm, zlistty, immtype>;
4888
4889   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4890                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 0>;
4891   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $imm6]",
4892                   (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, immtype:$imm6), 0>;
4893   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4894                   (!cast<Instruction>(NAME) zlistty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4895 }
4896
4897 class sve_mem_cld_ss_base<bits<4> dtype, bit ff, dag iops, string asm,
4898                           RegisterOperand VecList>
4899 : I<(outs VecList:$Zt), iops,
4900   asm, "\t$Zt, $Pg/z, [$Rn, $Rm]",
4901   "",
4902   []>, Sched<[]> {
4903   bits<5> Zt;
4904   bits<3> Pg;
4905   bits<5> Rm;
4906   bits<5> Rn;
4907   let Inst{31-25} = 0b1010010;
4908   let Inst{24-21} = dtype;
4909   let Inst{20-16} = Rm;
4910   let Inst{15-14} = 0b01;
4911   let Inst{13}    = ff;
4912   let Inst{12-10} = Pg;
4913   let Inst{9-5}   = Rn;
4914   let Inst{4-0}   = Zt;
4915
4916   let mayLoad = 1;
4917   let Uses = !if(!eq(ff, 1), [FFR], []);
4918   let Defs = !if(!eq(ff, 1), [FFR], []);
4919 }
4920
4921 multiclass sve_mem_cld_ss<bits<4> dtype, string asm, RegisterOperand listty,
4922                           ZPRRegOp zprty, RegisterOperand gprty> {
4923   def "" : sve_mem_cld_ss_base<dtype, 0, (ins PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4924                                asm, listty>;
4925
4926   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Rm]",
4927                  (!cast<Instruction>(NAME) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
4928 }
4929
4930 multiclass sve_mem_cldff_ss<bits<4> dtype, string asm, RegisterOperand listty,
4931                             ZPRRegOp zprty, RegisterOperand gprty> {
4932   def _REAL : sve_mem_cld_ss_base<dtype, 1, (ins PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4933                                   asm, listty>;
4934
4935   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Rm]",
4936                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm), 0>;
4937
4938   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4939                  (!cast<Instruction>(NAME # _REAL) listty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, XZR), 1>;
4940
4941   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4942                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, XZR), 0>;
4943 }
4944
4945 multiclass sve_mem_cldnf_si<bits<4> dtype, string asm, RegisterOperand listty,
4946                             ZPRRegOp zprty>
4947 : sve_mem_cld_si_base<dtype, 1, asm, listty, zprty>;
4948
4949 class sve_mem_eld_si<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
4950                      string asm, Operand immtype>
4951 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, immtype:$imm4),
4952   asm, "\t$Zt, $Pg/z, [$Rn, $imm4, mul vl]",
4953   "",
4954   []>, Sched<[]> {
4955   bits<5> Zt;
4956   bits<3> Pg;
4957   bits<5> Rn;
4958   bits<4> imm4;
4959   let Inst{31-25} = 0b1010010;
4960   let Inst{24-23} = sz;
4961   let Inst{22-21} = nregs;
4962   let Inst{20}    = 0;
4963   let Inst{19-16} = imm4;
4964   let Inst{15-13} = 0b111;
4965   let Inst{12-10} = Pg;
4966   let Inst{9-5}   = Rn;
4967   let Inst{4-0}   = Zt;
4968
4969   let mayLoad = 1;
4970 }
4971
4972 multiclass sve_mem_eld_si<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
4973                           string asm, Operand immtype> {
4974   def NAME : sve_mem_eld_si<sz, nregs, VecList, asm, immtype>;
4975
4976   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn]",
4977                   (!cast<Instruction>(NAME) VecList:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
4978 }
4979
4980 class sve_mem_eld_ss<bits<2> sz, bits<2> nregs, RegisterOperand VecList,
4981                      string asm, RegisterOperand gprty>
4982 : I<(outs VecList:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
4983   asm, "\t$Zt, $Pg/z, [$Rn, $Rm]",
4984   "",
4985   []>, Sched<[]> {
4986   bits<3> Pg;
4987   bits<5> Rm;
4988   bits<5> Rn;
4989   bits<5> Zt;
4990   let Inst{31-25} = 0b1010010;
4991   let Inst{24-23} = sz;
4992   let Inst{22-21} = nregs;
4993   let Inst{20-16} = Rm;
4994   let Inst{15-13} = 0b110;
4995   let Inst{12-10} = Pg;
4996   let Inst{9-5}   = Rn;
4997   let Inst{4-0}   = Zt;
4998
4999   let mayLoad = 1;
5000 }
5001
5002 //===----------------------------------------------------------------------===//
5003 // SVE Memory - 32-bit Gather and Unsized Contiguous Group
5004 //===----------------------------------------------------------------------===//
5005
5006 // bit xs      is '1' if offsets are signed
5007 // bit scaled  is '1' if the offsets are scaled
5008 class sve_mem_32b_gld_sv<bits<4> opc, bit xs, bit scaled, string asm,
5009                          RegisterOperand zprext>
5010 : I<(outs Z_s:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
5011   asm, "\t$Zt, $Pg/z, [$Rn, $Zm]",
5012   "",
5013   []>, Sched<[]> {
5014   bits<3> Pg;
5015   bits<5> Rn;
5016   bits<5> Zm;
5017   bits<5> Zt;
5018   let Inst{31-25} = 0b1000010;
5019   let Inst{24-23} = opc{3-2};
5020   let Inst{22}    = xs;
5021   let Inst{21}    = scaled;
5022   let Inst{20-16} = Zm;
5023   let Inst{15}    = 0b0;
5024   let Inst{14-13} = opc{1-0};
5025   let Inst{12-10} = Pg;
5026   let Inst{9-5}   = Rn;
5027   let Inst{4-0}   = Zt;
5028
5029   let mayLoad = 1;
5030   let Defs = !if(!eq(opc{0}, 1), [FFR], []);
5031   let Uses = !if(!eq(opc{0}, 1), [FFR], []);
5032 }
5033
5034 multiclass sve_mem_32b_gld_sv_32_scaled<bits<4> opc, string asm,
5035                                         RegisterOperand sxtw_opnd,
5036                                         RegisterOperand uxtw_opnd> {
5037   def _UXTW_SCALED_REAL : sve_mem_32b_gld_sv<opc, 0, 1, asm, uxtw_opnd>;
5038   def _SXTW_SCALED_REAL : sve_mem_32b_gld_sv<opc, 1, 1, asm, sxtw_opnd>;
5039
5040   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5041                   (!cast<Instruction>(NAME # _UXTW_SCALED_REAL) ZPR32:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
5042   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5043                   (!cast<Instruction>(NAME # _SXTW_SCALED_REAL) ZPR32:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
5044 }
5045
5046 multiclass sve_mem_32b_gld_vs_32_unscaled<bits<4> opc, string asm,
5047                                           RegisterOperand sxtw_opnd,
5048                                           RegisterOperand uxtw_opnd> {
5049   def _UXTW_REAL : sve_mem_32b_gld_sv<opc, 0, 0, asm, uxtw_opnd>;
5050   def _SXTW_REAL : sve_mem_32b_gld_sv<opc, 1, 0, asm, sxtw_opnd>;
5051
5052   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5053                   (!cast<Instruction>(NAME # _UXTW_REAL) ZPR32:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
5054   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5055                   (!cast<Instruction>(NAME # _SXTW_REAL) ZPR32:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
5056 }
5057
5058
5059 class sve_mem_32b_gld_vi<bits<4> opc, string asm, Operand imm_ty>
5060 : I<(outs Z_s:$Zt), (ins PPR3bAny:$Pg, ZPR32:$Zn, imm_ty:$imm5),
5061   asm, "\t$Zt, $Pg/z, [$Zn, $imm5]",
5062   "",
5063   []>, Sched<[]> {
5064   bits<3> Pg;
5065   bits<5> Zn;
5066   bits<5> Zt;
5067   bits<5> imm5;
5068   let Inst{31-25} = 0b1000010;
5069   let Inst{24-23} = opc{3-2};
5070   let Inst{22-21} = 0b01;
5071   let Inst{20-16} = imm5;
5072   let Inst{15}    = 0b1;
5073   let Inst{14-13} = opc{1-0};
5074   let Inst{12-10} = Pg;
5075   let Inst{9-5}   = Zn;
5076   let Inst{4-0}   = Zt;
5077
5078   let mayLoad = 1;
5079   let Defs = !if(!eq(opc{0}, 1), [FFR], []);
5080   let Uses = !if(!eq(opc{0}, 1), [FFR], []);
5081 }
5082
5083 multiclass sve_mem_32b_gld_vi_32_ptrs<bits<4> opc, string asm, Operand imm_ty> {
5084   def _IMM_REAL : sve_mem_32b_gld_vi<opc, asm, imm_ty>;
5085
5086   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5087                   (!cast<Instruction>(NAME # _IMM_REAL) ZPR32:$Zt, PPR3bAny:$Pg, ZPR32:$Zn, 0), 0>;
5088   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn, $imm5]",
5089                   (!cast<Instruction>(NAME # _IMM_REAL) ZPR32:$Zt, PPR3bAny:$Pg, ZPR32:$Zn, imm_ty:$imm5), 0>;
5090   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5091                   (!cast<Instruction>(NAME # _IMM_REAL) Z_s:$Zt, PPR3bAny:$Pg, ZPR32:$Zn, 0), 1>;
5092 }
5093
5094 class sve_mem_prfm_si<bits<2> msz, string asm>
5095 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, simm6s1:$imm6),
5096   asm, "\t$prfop, $Pg, [$Rn, $imm6, mul vl]",
5097   "",
5098   []>, Sched<[]> {
5099   bits<5> Rn;
5100   bits<3> Pg;
5101   bits<6> imm6;
5102   bits<4> prfop;
5103   let Inst{31-22} = 0b1000010111;
5104   let Inst{21-16} = imm6;
5105   let Inst{15}    = 0b0;
5106   let Inst{14-13} = msz;
5107   let Inst{12-10} = Pg;
5108   let Inst{9-5}   = Rn;
5109   let Inst{4}     = 0b0;
5110   let Inst{3-0}   = prfop;
5111
5112   let hasSideEffects = 1;
5113 }
5114
5115 multiclass sve_mem_prfm_si<bits<2> msz, string asm> {
5116   def NAME : sve_mem_prfm_si<msz, asm>;
5117
5118   def : InstAlias<asm # "\t$prfop, $Pg, [$Rn]",
5119                   (!cast<Instruction>(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, 0), 1>;
5120 }
5121
5122 class sve_mem_prfm_ss<bits<3> opc, string asm, RegisterOperand gprty>
5123 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, gprty:$Rm),
5124   asm, "\t$prfop, $Pg, [$Rn, $Rm]",
5125   "",
5126   []>, Sched<[]> {
5127   bits<5> Rm;
5128   bits<5> Rn;
5129   bits<3> Pg;
5130   bits<4> prfop;
5131   let Inst{31-25} = 0b1000010;
5132   let Inst{24-23} = opc{2-1};
5133   let Inst{22-21} = 0b00;
5134   let Inst{20-16} = Rm;
5135   let Inst{15}    = 0b1;
5136   let Inst{14}    = opc{0};
5137   let Inst{13}    = 0b0;
5138   let Inst{12-10} = Pg;
5139   let Inst{9-5}   = Rn;
5140   let Inst{4}     = 0b0;
5141   let Inst{3-0}   = prfop;
5142
5143   let hasSideEffects = 1;
5144 }
5145
5146 class sve_mem_32b_prfm_sv<bits<2> msz, bit xs, string asm,
5147                           RegisterOperand zprext>
5148 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
5149   asm, "\t$prfop, $Pg, [$Rn, $Zm]",
5150   "",
5151   []>, Sched<[]> {
5152   bits<3> Pg;
5153   bits<5> Rn;
5154   bits<5> Zm;
5155   bits<4> prfop;
5156   let Inst{31-23} = 0b100001000;
5157   let Inst{22}    = xs;
5158   let Inst{21}    = 0b1;
5159   let Inst{20-16} = Zm;
5160   let Inst{15}    = 0b0;
5161   let Inst{14-13} = msz;
5162   let Inst{12-10} = Pg;
5163   let Inst{9-5}   = Rn;
5164   let Inst{4}     = 0b0;
5165   let Inst{3-0}   = prfop;
5166
5167   let hasSideEffects = 1;
5168 }
5169
5170 multiclass sve_mem_32b_prfm_sv_scaled<bits<2> msz, string asm,
5171                                       RegisterOperand sxtw_opnd,
5172                                       RegisterOperand uxtw_opnd> {
5173   def _UXTW_SCALED : sve_mem_32b_prfm_sv<msz, 0, asm, uxtw_opnd>;
5174   def _SXTW_SCALED : sve_mem_32b_prfm_sv<msz, 1, asm, sxtw_opnd>;
5175 }
5176
5177 class sve_mem_32b_prfm_vi<bits<2> msz, string asm, Operand imm_ty>
5178 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, ZPR32:$Zn, imm_ty:$imm5),
5179   asm, "\t$prfop, $Pg, [$Zn, $imm5]",
5180   "",
5181   []>, Sched<[]> {
5182   bits<3> Pg;
5183   bits<5> Zn;
5184   bits<5> imm5;
5185   bits<4> prfop;
5186   let Inst{31-25} = 0b1000010;
5187   let Inst{24-23} = msz;
5188   let Inst{22-21} = 0b00;
5189   let Inst{20-16} = imm5;
5190   let Inst{15-13} = 0b111;
5191   let Inst{12-10} = Pg;
5192   let Inst{9-5}   = Zn;
5193   let Inst{4}     = 0b0;
5194   let Inst{3-0}   = prfop;
5195 }
5196
5197 multiclass sve_mem_32b_prfm_vi<bits<2> msz, string asm, Operand imm_ty> {
5198   def NAME : sve_mem_32b_prfm_vi<msz, asm, imm_ty>;
5199
5200   def : InstAlias<asm # "\t$prfop, $Pg, [$Zn]",
5201                   (!cast<Instruction>(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, ZPR32:$Zn, 0), 1>;
5202 }
5203
5204 class sve_mem_z_fill<string asm>
5205 : I<(outs ZPRAny:$Zt), (ins GPR64sp:$Rn, simm9:$imm9),
5206   asm, "\t$Zt, [$Rn, $imm9, mul vl]",
5207   "",
5208   []>, Sched<[]> {
5209   bits<5> Rn;
5210   bits<5> Zt;
5211   bits<9> imm9;
5212   let Inst{31-22} = 0b1000010110;
5213   let Inst{21-16} = imm9{8-3};
5214   let Inst{15-13} = 0b010;
5215   let Inst{12-10} = imm9{2-0};
5216   let Inst{9-5}   = Rn;
5217   let Inst{4-0}   = Zt;
5218
5219   let mayLoad = 1;
5220 }
5221
5222 multiclass sve_mem_z_fill<string asm> {
5223   def NAME : sve_mem_z_fill<asm>;
5224
5225   def : InstAlias<asm # "\t$Zt, [$Rn]",
5226                   (!cast<Instruction>(NAME) ZPRAny:$Zt, GPR64sp:$Rn, 0), 1>;
5227 }
5228
5229 class sve_mem_p_fill<string asm>
5230 : I<(outs PPRAny:$Pt), (ins GPR64sp:$Rn, simm9:$imm9),
5231   asm, "\t$Pt, [$Rn, $imm9, mul vl]",
5232   "",
5233   []>, Sched<[]> {
5234   bits<4> Pt;
5235   bits<5> Rn;
5236   bits<9> imm9;
5237   let Inst{31-22} = 0b1000010110;
5238   let Inst{21-16} = imm9{8-3};
5239   let Inst{15-13} = 0b000;
5240   let Inst{12-10} = imm9{2-0};
5241   let Inst{9-5}   = Rn;
5242   let Inst{4}     = 0b0;
5243   let Inst{3-0}   = Pt;
5244
5245   let mayLoad = 1;
5246 }
5247
5248 multiclass sve_mem_p_fill<string asm> {
5249   def NAME : sve_mem_p_fill<asm>;
5250
5251   def : InstAlias<asm # "\t$Pt, [$Rn]",
5252                   (!cast<Instruction>(NAME) PPRAny:$Pt, GPR64sp:$Rn, 0), 1>;
5253 }
5254
5255 class sve2_mem_gldnt_vs_base<bits<5> opc, dag iops, string asm,
5256                              RegisterOperand VecList>
5257 : I<(outs VecList:$Zt), iops,
5258   asm, "\t$Zt, $Pg/z, [$Zn, $Rm]",
5259   "",
5260   []>, Sched<[]> {
5261   bits<3> Pg;
5262   bits<5> Rm;
5263   bits<5> Zn;
5264   bits<5> Zt;
5265   let Inst{31}    = 0b1;
5266   let Inst{30}    = opc{4};
5267   let Inst{29-25} = 0b00010;
5268   let Inst{24-23} = opc{3-2};
5269   let Inst{22-21} = 0b00;
5270   let Inst{20-16} = Rm;
5271   let Inst{15}    = 0b1;
5272   let Inst{14-13} = opc{1-0};
5273   let Inst{12-10} = Pg;
5274   let Inst{9-5}   = Zn;
5275   let Inst{4-0}   = Zt;
5276
5277   let mayLoad = 1;
5278 }
5279
5280 multiclass sve2_mem_gldnt_vs<bits<5> opc, string asm,
5281                              RegisterOperand listty, ZPRRegOp zprty> {
5282   def _REAL : sve2_mem_gldnt_vs_base<opc, (ins PPR3bAny:$Pg, zprty:$Zn, GPR64:$Rm),
5283                                      asm, listty>;
5284
5285   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn, $Rm]",
5286                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, GPR64:$Rm), 0>;
5287   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5288                  (!cast<Instruction>(NAME # _REAL) zprty:$Zt, PPR3bAny:$Pg, zprty:$Zn, XZR), 0>;
5289   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5290                  (!cast<Instruction>(NAME # _REAL) listty:$Zt, PPR3bAny:$Pg, zprty:$Zn, XZR), 1>;
5291 }
5292
5293 //===----------------------------------------------------------------------===//
5294 // SVE Memory - 64-bit Gather Group
5295 //===----------------------------------------------------------------------===//
5296
5297 // bit xs      is '1' if offsets are signed
5298 // bit scaled  is '1' if the offsets are scaled
5299 // bit lsl     is '0' if the offsets are extended (uxtw/sxtw), '1' if shifted (lsl)
5300 class sve_mem_64b_gld_sv<bits<4> opc, bit xs, bit scaled, bit lsl, string asm,
5301                          RegisterOperand zprext>
5302 : I<(outs Z_d:$Zt), (ins PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
5303   asm, "\t$Zt, $Pg/z, [$Rn, $Zm]",
5304   "",
5305   []>, Sched<[]> {
5306   bits<3> Pg;
5307   bits<5> Rn;
5308   bits<5> Zm;
5309   bits<5> Zt;
5310   let Inst{31-25} = 0b1100010;
5311   let Inst{24-23} = opc{3-2};
5312   let Inst{22}    = xs;
5313   let Inst{21}    = scaled;
5314   let Inst{20-16} = Zm;
5315   let Inst{15}    = lsl;
5316   let Inst{14-13} = opc{1-0};
5317   let Inst{12-10} = Pg;
5318   let Inst{9-5}   = Rn;
5319   let Inst{4-0}   = Zt;
5320
5321   let mayLoad = 1;
5322   let Defs = !if(!eq(opc{0}, 1), [FFR], []);
5323   let Uses = !if(!eq(opc{0}, 1), [FFR], []);
5324 }
5325
5326 multiclass sve_mem_64b_gld_sv_32_scaled<bits<4> opc, string asm,
5327                                         RegisterOperand sxtw_opnd,
5328                                         RegisterOperand uxtw_opnd> {
5329   def _UXTW_SCALED_REAL : sve_mem_64b_gld_sv<opc, 0, 1, 0, asm, uxtw_opnd>;
5330   def _SXTW_SCALED_REAL : sve_mem_64b_gld_sv<opc, 1, 1, 0, asm, sxtw_opnd>;
5331
5332   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5333                   (!cast<Instruction>(NAME # _UXTW_SCALED_REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
5334   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5335                   (!cast<Instruction>(NAME # _SXTW_SCALED_REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
5336 }
5337
5338 multiclass sve_mem_64b_gld_vs_32_unscaled<bits<4> opc, string asm,
5339                                           RegisterOperand sxtw_opnd,
5340                                           RegisterOperand uxtw_opnd> {
5341   def _UXTW_REAL : sve_mem_64b_gld_sv<opc, 0, 0, 0, asm, uxtw_opnd>;
5342   def _SXTW_REAL : sve_mem_64b_gld_sv<opc, 1, 0, 0, asm, sxtw_opnd>;
5343
5344   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5345                   (!cast<Instruction>(NAME # _UXTW_REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, uxtw_opnd:$Zm), 0>;
5346   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5347                   (!cast<Instruction>(NAME # _SXTW_REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, sxtw_opnd:$Zm), 0>;
5348 }
5349
5350 multiclass sve_mem_64b_gld_sv2_64_scaled<bits<4> opc, string asm,
5351                                          RegisterOperand zprext> {
5352   def _SCALED_REAL : sve_mem_64b_gld_sv<opc, 1, 1, 1, asm, zprext>;
5353
5354   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5355                   (!cast<Instruction>(NAME # _SCALED_REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm), 0>;
5356 }
5357
5358 multiclass sve_mem_64b_gld_vs2_64_unscaled<bits<4> opc, string asm> {
5359   def _REAL : sve_mem_64b_gld_sv<opc, 1, 0, 1, asm, ZPR64ExtLSL8>;
5360
5361   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Rn, $Zm]",
5362                   (!cast<Instruction>(NAME # _REAL) ZPR64:$Zt, PPR3bAny:$Pg, GPR64sp:$Rn, ZPR64ExtLSL8:$Zm), 0>;
5363 }
5364
5365 class sve_mem_64b_gld_vi<bits<4> opc, string asm, Operand imm_ty>
5366 : I<(outs Z_d:$Zt), (ins PPR3bAny:$Pg, ZPR64:$Zn, imm_ty:$imm5),
5367   asm, "\t$Zt, $Pg/z, [$Zn, $imm5]",
5368   "",
5369   []>, Sched<[]> {
5370   bits<3> Pg;
5371   bits<5> Zn;
5372   bits<5> Zt;
5373   bits<5> imm5;
5374   let Inst{31-25} = 0b1100010;
5375   let Inst{24-23} = opc{3-2};
5376   let Inst{22-21} = 0b01;
5377   let Inst{20-16} = imm5;
5378   let Inst{15}    = 0b1;
5379   let Inst{14-13} = opc{1-0};
5380   let Inst{12-10} = Pg;
5381   let Inst{9-5}   = Zn;
5382   let Inst{4-0}   = Zt;
5383
5384   let mayLoad = 1;
5385   let Defs = !if(!eq(opc{0}, 1), [FFR], []);
5386   let Uses = !if(!eq(opc{0}, 1), [FFR], []);
5387 }
5388
5389 multiclass sve_mem_64b_gld_vi_64_ptrs<bits<4> opc, string asm, Operand imm_ty> {
5390   def _IMM_REAL : sve_mem_64b_gld_vi<opc, asm, imm_ty>;
5391
5392   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5393                   (!cast<Instruction>(NAME # _IMM_REAL) ZPR64:$Zt, PPR3bAny:$Pg, ZPR64:$Zn, 0), 0>;
5394   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn, $imm5]",
5395                  (!cast<Instruction>(NAME # _IMM_REAL) ZPR64:$Zt, PPR3bAny:$Pg, ZPR64:$Zn, imm_ty:$imm5), 0>;
5396   def : InstAlias<asm # "\t$Zt, $Pg/z, [$Zn]",
5397                   (!cast<Instruction>(NAME # _IMM_REAL) Z_d:$Zt, PPR3bAny:$Pg, ZPR64:$Zn, 0), 1>;
5398 }
5399
5400 // bit lsl is '0' if the offsets are extended (uxtw/sxtw), '1' if shifted (lsl)
5401 class sve_mem_64b_prfm_sv<bits<2> msz, bit xs, bit lsl, string asm,
5402                           RegisterOperand zprext>
5403 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, GPR64sp:$Rn, zprext:$Zm),
5404   asm, "\t$prfop, $Pg, [$Rn, $Zm]",
5405   "",
5406   []>, Sched<[]> {
5407   bits<3> Pg;
5408   bits<5> Rn;
5409   bits<5> Zm;
5410   bits<4> prfop;
5411   let Inst{31-23} = 0b110001000;
5412   let Inst{22}    = xs;
5413   let Inst{21}    = 0b1;
5414   let Inst{20-16} = Zm;
5415   let Inst{15}    = lsl;
5416   let Inst{14-13} = msz;
5417   let Inst{12-10} = Pg;
5418   let Inst{9-5}   = Rn;
5419   let Inst{4}     = 0b0;
5420   let Inst{3-0}   = prfop;
5421
5422   let hasSideEffects = 1;
5423 }
5424
5425 multiclass sve_mem_64b_prfm_sv_ext_scaled<bits<2> msz, string asm,
5426                                           RegisterOperand sxtw_opnd,
5427                                           RegisterOperand uxtw_opnd> {
5428   def _UXTW_SCALED : sve_mem_64b_prfm_sv<msz, 0, 0, asm, uxtw_opnd>;
5429   def _SXTW_SCALED : sve_mem_64b_prfm_sv<msz, 1, 0, asm, sxtw_opnd>;
5430 }
5431
5432 multiclass sve_mem_64b_prfm_sv_lsl_scaled<bits<2> msz, string asm,
5433                                           RegisterOperand zprext> {
5434   def NAME : sve_mem_64b_prfm_sv<msz, 1, 1, asm, zprext>;
5435 }
5436
5437
5438 class sve_mem_64b_prfm_vi<bits<2> msz, string asm, Operand imm_ty>
5439 : I<(outs), (ins sve_prfop:$prfop, PPR3bAny:$Pg, ZPR64:$Zn, imm_ty:$imm5),
5440   asm, "\t$prfop, $Pg, [$Zn, $imm5]",
5441   "",
5442   []>, Sched<[]> {
5443   bits<3> Pg;
5444   bits<5> Zn;
5445   bits<5> imm5;
5446   bits<4> prfop;
5447   let Inst{31-25} = 0b1100010;
5448   let Inst{24-23} = msz;
5449   let Inst{22-21} = 0b00;
5450   let Inst{20-16} = imm5;
5451   let Inst{15-13} = 0b111;
5452   let Inst{12-10} = Pg;
5453   let Inst{9-5}   = Zn;
5454   let Inst{4}     = 0b0;
5455   let Inst{3-0}   = prfop;
5456
5457   let hasSideEffects = 1;
5458 }
5459
5460 multiclass sve_mem_64b_prfm_vi<bits<2> msz, string asm, Operand imm_ty> {
5461   def NAME : sve_mem_64b_prfm_vi<msz, asm, imm_ty>;
5462
5463   def : InstAlias<asm # "\t$prfop, $Pg, [$Zn]",
5464                   (!cast<Instruction>(NAME) sve_prfop:$prfop, PPR3bAny:$Pg, ZPR64:$Zn, 0), 1>;
5465 }
5466
5467
5468 //===----------------------------------------------------------------------===//
5469 // SVE Compute Vector Address Group
5470 //===----------------------------------------------------------------------===//
5471
5472 class sve_int_bin_cons_misc_0_a<bits<2> opc, bits<2> msz, string asm,
5473                                 ZPRRegOp zprty, RegisterOperand zprext>
5474 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprext:$Zm),
5475   asm, "\t$Zd, [$Zn, $Zm]",
5476   "",
5477   []>, Sched<[]> {
5478   bits<5> Zd;
5479   bits<5> Zn;
5480   bits<5> Zm;
5481   let Inst{31-24} = 0b00000100;
5482   let Inst{23-22} = opc;
5483   let Inst{21}    = 0b1;
5484   let Inst{20-16} = Zm;
5485   let Inst{15-12} = 0b1010;
5486   let Inst{11-10} = msz;
5487   let Inst{9-5}   = Zn;
5488   let Inst{4-0}   = Zd;
5489 }
5490
5491 multiclass sve_int_bin_cons_misc_0_a_uxtw<bits<2> opc, string asm> {
5492   def _0 : sve_int_bin_cons_misc_0_a<opc, 0b00, asm, ZPR64, ZPR64ExtUXTW8>;
5493   def _1 : sve_int_bin_cons_misc_0_a<opc, 0b01, asm, ZPR64, ZPR64ExtUXTW16>;
5494   def _2 : sve_int_bin_cons_misc_0_a<opc, 0b10, asm, ZPR64, ZPR64ExtUXTW32>;
5495   def _3 : sve_int_bin_cons_misc_0_a<opc, 0b11, asm, ZPR64, ZPR64ExtUXTW64>;
5496 }
5497
5498 multiclass sve_int_bin_cons_misc_0_a_sxtw<bits<2> opc, string asm> {
5499   def _0 : sve_int_bin_cons_misc_0_a<opc, 0b00, asm, ZPR64, ZPR64ExtSXTW8>;
5500   def _1 : sve_int_bin_cons_misc_0_a<opc, 0b01, asm, ZPR64, ZPR64ExtSXTW16>;
5501   def _2 : sve_int_bin_cons_misc_0_a<opc, 0b10, asm, ZPR64, ZPR64ExtSXTW32>;
5502   def _3 : sve_int_bin_cons_misc_0_a<opc, 0b11, asm, ZPR64, ZPR64ExtSXTW64>;
5503 }
5504
5505 multiclass sve_int_bin_cons_misc_0_a_32_lsl<bits<2> opc, string asm> {
5506   def _0 : sve_int_bin_cons_misc_0_a<opc, 0b00, asm, ZPR32, ZPR32ExtLSL8>;
5507   def _1 : sve_int_bin_cons_misc_0_a<opc, 0b01, asm, ZPR32, ZPR32ExtLSL16>;
5508   def _2 : sve_int_bin_cons_misc_0_a<opc, 0b10, asm, ZPR32, ZPR32ExtLSL32>;
5509   def _3 : sve_int_bin_cons_misc_0_a<opc, 0b11, asm, ZPR32, ZPR32ExtLSL64>;
5510 }
5511
5512 multiclass sve_int_bin_cons_misc_0_a_64_lsl<bits<2> opc, string asm> {
5513   def _0 : sve_int_bin_cons_misc_0_a<opc, 0b00, asm, ZPR64, ZPR64ExtLSL8>;
5514   def _1 : sve_int_bin_cons_misc_0_a<opc, 0b01, asm, ZPR64, ZPR64ExtLSL16>;
5515   def _2 : sve_int_bin_cons_misc_0_a<opc, 0b10, asm, ZPR64, ZPR64ExtLSL32>;
5516   def _3 : sve_int_bin_cons_misc_0_a<opc, 0b11, asm, ZPR64, ZPR64ExtLSL64>;
5517 }
5518
5519
5520 //===----------------------------------------------------------------------===//
5521 // SVE Integer Misc - Unpredicated Group
5522 //===----------------------------------------------------------------------===//
5523
5524 class sve_int_bin_cons_misc_0_b<bits<2> sz, string asm, ZPRRegOp zprty>
5525 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty:$Zm),
5526   asm, "\t$Zd, $Zn, $Zm",
5527   "",
5528   []>, Sched<[]> {
5529   bits<5> Zd;
5530   bits<5> Zm;
5531   bits<5> Zn;
5532   let Inst{31-24} = 0b00000100;
5533   let Inst{23-22} = sz;
5534   let Inst{21}    = 0b1;
5535   let Inst{20-16} = Zm;
5536   let Inst{15-10} = 0b101100;
5537   let Inst{9-5}   = Zn;
5538   let Inst{4-0}   = Zd;
5539 }
5540
5541 multiclass sve_int_bin_cons_misc_0_b<string asm> {
5542   def _H : sve_int_bin_cons_misc_0_b<0b01, asm, ZPR16>;
5543   def _S : sve_int_bin_cons_misc_0_b<0b10, asm, ZPR32>;
5544   def _D : sve_int_bin_cons_misc_0_b<0b11, asm, ZPR64>;
5545 }
5546
5547 class sve_int_bin_cons_misc_0_c<bits<8> opc, string asm, ZPRRegOp zprty>
5548 : I<(outs zprty:$Zd), (ins zprty:$Zn),
5549   asm, "\t$Zd, $Zn",
5550   "",
5551   []>, Sched<[]> {
5552   bits<5> Zd;
5553   bits<5> Zn;
5554   let Inst{31-24} = 0b00000100;
5555   let Inst{23-22} = opc{7-6};
5556   let Inst{21}    = 0b1;
5557   let Inst{20-16} = opc{5-1};
5558   let Inst{15-11} = 0b10111;
5559   let Inst{10}    = opc{0};
5560   let Inst{9-5}   = Zn;
5561   let Inst{4-0}   = Zd;
5562 }
5563
5564 //===----------------------------------------------------------------------===//
5565 // SVE Integer Reduction Group
5566 //===----------------------------------------------------------------------===//
5567
5568 class sve_int_reduce<bits<2> sz8_32, bits<2> fmt, bits<3> opc, string asm,
5569                      ZPRRegOp zprty, RegisterClass regtype>
5570 : I<(outs regtype:$Vd), (ins PPR3bAny:$Pg, zprty:$Zn),
5571   asm, "\t$Vd, $Pg, $Zn",
5572   "",
5573   []>, Sched<[]> {
5574   bits<3> Pg;
5575   bits<5> Vd;
5576   bits<5> Zn;
5577   let Inst{31-24} = 0b00000100;
5578   let Inst{23-22} = sz8_32;
5579   let Inst{21}    = 0b0;
5580   let Inst{20-19} = fmt;
5581   let Inst{18-16} = opc;
5582   let Inst{15-13} = 0b001;
5583   let Inst{12-10} = Pg;
5584   let Inst{9-5}   = Zn;
5585   let Inst{4-0}   = Vd;
5586 }
5587
5588 multiclass sve_int_reduce_0_saddv<bits<3> opc, string asm> {
5589   def _B : sve_int_reduce<0b00, 0b00, opc, asm, ZPR8, FPR64>;
5590   def _H : sve_int_reduce<0b01, 0b00, opc, asm, ZPR16, FPR64>;
5591   def _S : sve_int_reduce<0b10, 0b00, opc, asm, ZPR32, FPR64>;
5592 }
5593
5594 multiclass sve_int_reduce_0_uaddv<bits<3> opc, string asm> {
5595   def _B : sve_int_reduce<0b00, 0b00, opc, asm, ZPR8, FPR64>;
5596   def _H : sve_int_reduce<0b01, 0b00, opc, asm, ZPR16, FPR64>;
5597   def _S : sve_int_reduce<0b10, 0b00, opc, asm, ZPR32, FPR64>;
5598   def _D : sve_int_reduce<0b11, 0b00, opc, asm, ZPR64, FPR64>;
5599 }
5600
5601 multiclass sve_int_reduce_1<bits<3> opc, string asm> {
5602   def _B : sve_int_reduce<0b00, 0b01, opc, asm, ZPR8, FPR8>;
5603   def _H : sve_int_reduce<0b01, 0b01, opc, asm, ZPR16, FPR16>;
5604   def _S : sve_int_reduce<0b10, 0b01, opc, asm, ZPR32, FPR32>;
5605   def _D : sve_int_reduce<0b11, 0b01, opc, asm, ZPR64, FPR64>;
5606 }
5607
5608 multiclass sve_int_reduce_2<bits<3> opc, string asm> {
5609   def _B : sve_int_reduce<0b00, 0b11, opc, asm, ZPR8, FPR8>;
5610   def _H : sve_int_reduce<0b01, 0b11, opc, asm, ZPR16, FPR16>;
5611   def _S : sve_int_reduce<0b10, 0b11, opc, asm, ZPR32, FPR32>;
5612   def _D : sve_int_reduce<0b11, 0b11, opc, asm, ZPR64, FPR64>;
5613 }
5614
5615 class sve_int_movprfx_pred<bits<2> sz8_32, bits<3> opc, string asm,
5616                            ZPRRegOp zprty, string pg_suffix, dag iops>
5617 : I<(outs zprty:$Zd), iops,
5618   asm, "\t$Zd, $Pg"#pg_suffix#", $Zn",
5619   "",
5620   []>, Sched<[]> {
5621   bits<3> Pg;
5622   bits<5> Zd;
5623   bits<5> Zn;
5624   let Inst{31-24} = 0b00000100;
5625   let Inst{23-22} = sz8_32;
5626   let Inst{21-19} = 0b010;
5627   let Inst{18-16} = opc;
5628   let Inst{15-13} = 0b001;
5629   let Inst{12-10} = Pg;
5630   let Inst{9-5}   = Zn;
5631   let Inst{4-0}   = Zd;
5632
5633   let ElementSize = zprty.ElementSize;
5634 }
5635
5636 multiclass sve_int_movprfx_pred_merge<bits<3> opc, string asm> {
5637 let Constraints = "$Zd = $_Zd" in {
5638   def _B : sve_int_movprfx_pred<0b00, opc, asm, ZPR8, "/m",
5639                                 (ins ZPR8:$_Zd, PPR3bAny:$Pg, ZPR8:$Zn)>;
5640   def _H : sve_int_movprfx_pred<0b01, opc, asm, ZPR16, "/m",
5641                                 (ins ZPR16:$_Zd, PPR3bAny:$Pg, ZPR16:$Zn)>;
5642   def _S : sve_int_movprfx_pred<0b10, opc, asm, ZPR32, "/m",
5643                                 (ins ZPR32:$_Zd, PPR3bAny:$Pg, ZPR32:$Zn)>;
5644   def _D : sve_int_movprfx_pred<0b11, opc, asm, ZPR64, "/m",
5645                                 (ins ZPR64:$_Zd, PPR3bAny:$Pg, ZPR64:$Zn)>;
5646 }
5647 }
5648
5649 multiclass sve_int_movprfx_pred_zero<bits<3> opc, string asm> {
5650   def _B : sve_int_movprfx_pred<0b00, opc, asm, ZPR8, "/z",
5651                                 (ins PPR3bAny:$Pg, ZPR8:$Zn)>;
5652   def _H : sve_int_movprfx_pred<0b01, opc, asm, ZPR16, "/z",
5653                                 (ins PPR3bAny:$Pg, ZPR16:$Zn)>;
5654   def _S : sve_int_movprfx_pred<0b10, opc, asm, ZPR32, "/z",
5655                                 (ins PPR3bAny:$Pg, ZPR32:$Zn)>;
5656   def _D : sve_int_movprfx_pred<0b11, opc, asm, ZPR64, "/z",
5657                                 (ins PPR3bAny:$Pg, ZPR64:$Zn)>;
5658 }
5659
5660 //===----------------------------------------------------------------------===//
5661 // SVE Propagate Break Group
5662 //===----------------------------------------------------------------------===//
5663
5664 class sve_int_brkp<bits<2> opc, string asm>
5665 : I<(outs PPR8:$Pd), (ins PPRAny:$Pg, PPR8:$Pn, PPR8:$Pm),
5666   asm, "\t$Pd, $Pg/z, $Pn, $Pm",
5667   "",
5668   []>, Sched<[]> {
5669   bits<4> Pd;
5670   bits<4> Pg;
5671   bits<4> Pm;
5672   bits<4> Pn;
5673   let Inst{31-24} = 0b00100101;
5674   let Inst{23}    = 0b0;
5675   let Inst{22}    = opc{1};
5676   let Inst{21-20} = 0b00;
5677   let Inst{19-16} = Pm;
5678   let Inst{15-14} = 0b11;
5679   let Inst{13-10} = Pg;
5680   let Inst{9}     = 0b0;
5681   let Inst{8-5}   = Pn;
5682   let Inst{4}     = opc{0};
5683   let Inst{3-0}   = Pd;
5684
5685   let Defs = !if(!eq (opc{1}, 1), [NZCV], []);
5686 }
5687
5688
5689 //===----------------------------------------------------------------------===//
5690 // SVE Partition Break Group
5691 //===----------------------------------------------------------------------===//
5692
5693 class sve_int_brkn<bit S, string asm>
5694 : I<(outs PPR8:$Pdm), (ins PPRAny:$Pg, PPR8:$Pn, PPR8:$_Pdm),
5695   asm, "\t$Pdm, $Pg/z, $Pn, $_Pdm",
5696   "",
5697   []>, Sched<[]> {
5698   bits<4> Pdm;
5699   bits<4> Pg;
5700   bits<4> Pn;
5701   let Inst{31-23} = 0b001001010;
5702   let Inst{22}    = S;
5703   let Inst{21-14} = 0b01100001;
5704   let Inst{13-10} = Pg;
5705   let Inst{9}     = 0b0;
5706   let Inst{8-5}   = Pn;
5707   let Inst{4}     = 0b0;
5708   let Inst{3-0}   = Pdm;
5709
5710   let Constraints = "$Pdm = $_Pdm";
5711   let Defs = !if(!eq (S, 0b1), [NZCV], []);
5712 }
5713
5714 class sve_int_break<bits<3> opc, string asm, string suffix, dag iops>
5715 : I<(outs PPR8:$Pd), iops,
5716   asm, "\t$Pd, $Pg"#suffix#", $Pn",
5717   "",
5718   []>, Sched<[]> {
5719   bits<4> Pd;
5720   bits<4> Pg;
5721   bits<4> Pn;
5722   let Inst{31-24} = 0b00100101;
5723   let Inst{23-22} = opc{2-1};
5724   let Inst{21-14} = 0b01000001;
5725   let Inst{13-10} = Pg;
5726   let Inst{9}     = 0b0;
5727   let Inst{8-5}   = Pn;
5728   let Inst{4}     = opc{0};
5729   let Inst{3-0}   = Pd;
5730
5731   let Constraints = !if(!eq (opc{0}, 1), "$Pd = $_Pd", "");
5732   let Defs = !if(!eq (opc{1}, 1), [NZCV], []);
5733
5734 }
5735
5736 multiclass sve_int_break_m<bits<3> opc, string asm> {
5737   def NAME : sve_int_break<opc, asm, "/m", (ins PPR8:$_Pd, PPRAny:$Pg, PPR8:$Pn)>;
5738 }
5739
5740 multiclass sve_int_break_z<bits<3> opc, string asm> {
5741   def NAME : sve_int_break<opc, asm, "/z", (ins PPRAny:$Pg, PPR8:$Pn)>;
5742 }
5743
5744 //===----------------------------------------------------------------------===//
5745 // SVE2 String Processing Group
5746 //===----------------------------------------------------------------------===//
5747
5748 class sve2_char_match<bit sz, bit opc, string asm,
5749                       PPRRegOp pprty, ZPRRegOp zprty>
5750 : I<(outs pprty:$Pd), (ins PPR3bAny:$Pg, zprty:$Zn, zprty:$Zm),
5751   asm, "\t$Pd, $Pg/z, $Zn, $Zm",
5752   "",
5753   []>, Sched<[]> {
5754   bits<4> Pd;
5755   bits<3> Pg;
5756   bits<5> Zm;
5757   bits<5> Zn;
5758   let Inst{31-23} = 0b010001010;
5759   let Inst{22}    = sz;
5760   let Inst{21}    = 0b1;
5761   let Inst{20-16} = Zm;
5762   let Inst{15-13} = 0b100;
5763   let Inst{12-10} = Pg;
5764   let Inst{9-5}   = Zn;
5765   let Inst{4}     = opc;
5766   let Inst{3-0}   = Pd;
5767
5768   let Defs = [NZCV];
5769 }
5770
5771 multiclass sve2_char_match<bit opc, string asm> {
5772   def _B : sve2_char_match<0b0, opc, asm, PPR8, ZPR8>;
5773   def _H : sve2_char_match<0b1, opc, asm, PPR16, ZPR16>;
5774 }
5775
5776 //===----------------------------------------------------------------------===//
5777 // SVE2 Histogram Computation - Segment Group
5778 //===----------------------------------------------------------------------===//
5779
5780 class sve2_hist_gen_segment<string asm>
5781 : I<(outs ZPR8:$Zd), (ins ZPR8:$Zn, ZPR8:$Zm),
5782   asm, "\t$Zd, $Zn, $Zm",
5783   "",
5784   []>, Sched<[]> {
5785   bits<5> Zd;
5786   bits<5> Zn;
5787   bits<5> Zm;
5788   let Inst{31-21} = 0b01000101001;
5789   let Inst{20-16} = Zm;
5790   let Inst{15-10} = 0b101000;
5791   let Inst{9-5}   = Zn;
5792   let Inst{4-0}   = Zd;
5793 }
5794
5795 //===----------------------------------------------------------------------===//
5796 // SVE2 Histogram Computation - Vector Group
5797 //===----------------------------------------------------------------------===//
5798
5799 class sve2_hist_gen_vector<bit sz, string asm, ZPRRegOp zprty>
5800 : I<(outs zprty:$Zd), (ins PPR3bAny:$Pg, zprty:$Zn, zprty:$Zm),
5801   asm, "\t$Zd, $Pg/z, $Zn, $Zm",
5802   "",
5803   []>, Sched<[]> {
5804   bits<5> Zd;
5805   bits<5> Zn;
5806   bits<3> Pg;
5807   bits<5> Zm;
5808   let Inst{31-23} = 0b010001011;
5809   let Inst{22}    = sz;
5810   let Inst{21}    = 0b1;
5811   let Inst{20-16} = Zm;
5812   let Inst{15-13} = 0b110;
5813   let Inst{12-10} = Pg;
5814   let Inst{9-5}   = Zn;
5815   let Inst{4-0}   = Zd;
5816 }
5817
5818 multiclass sve2_hist_gen_vector<string asm> {
5819   def _S : sve2_hist_gen_vector<0b0, asm, ZPR32>;
5820   def _D : sve2_hist_gen_vector<0b1, asm, ZPR64>;
5821 }
5822
5823 //===----------------------------------------------------------------------===//
5824 // SVE2 Crypto Extensions Group
5825 //===----------------------------------------------------------------------===//
5826
5827 class sve2_crypto_cons_bin_op<bit opc, string asm, ZPRRegOp zprty>
5828 : I<(outs zprty:$Zd), (ins zprty:$Zn, zprty:$Zm),
5829   asm, "\t$Zd, $Zn, $Zm",
5830   "",
5831   []>, Sched<[]> {
5832   bits<5> Zd;
5833   bits<5> Zn;
5834   bits<5> Zm;
5835   let Inst{31-21} = 0b01000101001;
5836   let Inst{20-16} = Zm;
5837   let Inst{15-11} = 0b11110;
5838   let Inst{10}    = opc;
5839   let Inst{9-5}   = Zn;
5840   let Inst{4-0}   = Zd;
5841 }
5842
5843 class sve2_crypto_des_bin_op<bits<2> opc, string asm, ZPRRegOp zprty>
5844 : I<(outs zprty:$Zdn), (ins zprty:$_Zdn, zprty:$Zm),
5845   asm, "\t$Zdn, $_Zdn, $Zm",
5846   "",
5847   []>, Sched<[]> {
5848   bits<5> Zdn;
5849   bits<5> Zm;
5850   let Inst{31-17} = 0b010001010010001;
5851   let Inst{16}    = opc{1};
5852   let Inst{15-11} = 0b11100;
5853   let Inst{10}    = opc{0};
5854   let Inst{9-5}   = Zm;
5855   let Inst{4-0}   = Zdn;
5856
5857   let Constraints = "$Zdn = $_Zdn";
5858 }
5859
5860 class sve2_crypto_unary_op<bit opc, string asm>
5861 : I<(outs ZPR8:$Zdn), (ins ZPR8:$_Zdn),
5862   asm, "\t$Zdn, $_Zdn",
5863   "",
5864   []>, Sched<[]> {
5865   bits<5> Zdn;
5866   let Inst{31-11} = 0b010001010010000011100;
5867   let Inst{10}    = opc;
5868   let Inst{9-5}   = 0b00000;
5869   let Inst{4-0}   = Zdn;
5870
5871   let Constraints = "$Zdn = $_Zdn";
5872 }