lib/Target/AArch64/AArch64RegisterInfo.td

   1 //=- AArch64RegisterInfo.td - Describe the AArch64 Registers -*- 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 //
  10 //===----------------------------------------------------------------------===//
  11
  12
  13 class AArch64Reg<bits<16> enc, string n, list<Register> subregs = [],
  14                list<string> altNames = []>
  15         : Register<n, altNames> {
  16   let HWEncoding = enc;
  17   let Namespace = "AArch64";
  18   let SubRegs = subregs;
  19 }
  20
  21 let Namespace = "AArch64" in {
  22   def sub_32 : SubRegIndex<32>;
  23
  24   def bsub : SubRegIndex<8>;
  25   def hsub : SubRegIndex<16>;
  26   def ssub : SubRegIndex<32>;
  27   def dsub : SubRegIndex<32>;
  28   def sube32 : SubRegIndex<32>;
  29   def subo32 : SubRegIndex<32>;
  30   def qhisub : SubRegIndex<64>;
  31   def qsub : SubRegIndex<64>;
  32   def sube64 : SubRegIndex<64>;
  33   def subo64 : SubRegIndex<64>;
  34   // SVE
  35   def zsub    : SubRegIndex<128>;
  36   // Note: zsub_hi should never be used directly because it represents
  37   // the scalable part of the SVE vector and cannot be manipulated as a
  38   // subvector in the same way the lower 128bits can.
  39   def zsub_hi : SubRegIndex<128>;
  40   // Note: Code depends on these having consecutive numbers
  41   def dsub0 : SubRegIndex<64>;
  42   def dsub1 : SubRegIndex<64>;
  43   def dsub2 : SubRegIndex<64>;
  44   def dsub3 : SubRegIndex<64>;
  45   // Note: Code depends on these having consecutive numbers
  46   def qsub0 : SubRegIndex<128>;
  47   def qsub1 : SubRegIndex<128>;
  48   def qsub2 : SubRegIndex<128>;
  49   def qsub3 : SubRegIndex<128>;
  50 }
  51
  52 let Namespace = "AArch64" in {
  53   def vreg : RegAltNameIndex;
  54   def vlist1 : RegAltNameIndex;
  55 }
  56
  57 //===----------------------------------------------------------------------===//
  58 // Registers
  59 //===----------------------------------------------------------------------===//
  60 def W0    : AArch64Reg<0,   "w0" >, DwarfRegNum<[0]>;
  61 def W1    : AArch64Reg<1,   "w1" >, DwarfRegNum<[1]>;
  62 def W2    : AArch64Reg<2,   "w2" >, DwarfRegNum<[2]>;
  63 def W3    : AArch64Reg<3,   "w3" >, DwarfRegNum<[3]>;
  64 def W4    : AArch64Reg<4,   "w4" >, DwarfRegNum<[4]>;
  65 def W5    : AArch64Reg<5,   "w5" >, DwarfRegNum<[5]>;
  66 def W6    : AArch64Reg<6,   "w6" >, DwarfRegNum<[6]>;
  67 def W7    : AArch64Reg<7,   "w7" >, DwarfRegNum<[7]>;
  68 def W8    : AArch64Reg<8,   "w8" >, DwarfRegNum<[8]>;
  69 def W9    : AArch64Reg<9,   "w9" >, DwarfRegNum<[9]>;
  70 def W10   : AArch64Reg<10, "w10">, DwarfRegNum<[10]>;
  71 def W11   : AArch64Reg<11, "w11">, DwarfRegNum<[11]>;
  72 def W12   : AArch64Reg<12, "w12">, DwarfRegNum<[12]>;
  73 def W13   : AArch64Reg<13, "w13">, DwarfRegNum<[13]>;
  74 def W14   : AArch64Reg<14, "w14">, DwarfRegNum<[14]>;
  75 def W15   : AArch64Reg<15, "w15">, DwarfRegNum<[15]>;
  76 def W16   : AArch64Reg<16, "w16">, DwarfRegNum<[16]>;
  77 def W17   : AArch64Reg<17, "w17">, DwarfRegNum<[17]>;
  78 def W18   : AArch64Reg<18, "w18">, DwarfRegNum<[18]>;
  79 def W19   : AArch64Reg<19, "w19">, DwarfRegNum<[19]>;
  80 def W20   : AArch64Reg<20, "w20">, DwarfRegNum<[20]>;
  81 def W21   : AArch64Reg<21, "w21">, DwarfRegNum<[21]>;
  82 def W22   : AArch64Reg<22, "w22">, DwarfRegNum<[22]>;
  83 def W23   : AArch64Reg<23, "w23">, DwarfRegNum<[23]>;
  84 def W24   : AArch64Reg<24, "w24">, DwarfRegNum<[24]>;
  85 def W25   : AArch64Reg<25, "w25">, DwarfRegNum<[25]>;
  86 def W26   : AArch64Reg<26, "w26">, DwarfRegNum<[26]>;
  87 def W27   : AArch64Reg<27, "w27">, DwarfRegNum<[27]>;
  88 def W28   : AArch64Reg<28, "w28">, DwarfRegNum<[28]>;
  89 def W29   : AArch64Reg<29, "w29">, DwarfRegNum<[29]>;
  90 def W30   : AArch64Reg<30, "w30">, DwarfRegNum<[30]>;
  91 def WSP   : AArch64Reg<31, "wsp">, DwarfRegNum<[31]>;
  92 def WZR   : AArch64Reg<31, "wzr">, DwarfRegAlias<WSP>;
  93
  94 let SubRegIndices = [sub_32] in {
  95 def X0    : AArch64Reg<0,   "x0",  [W0]>, DwarfRegAlias<W0>;
  96 def X1    : AArch64Reg<1,   "x1",  [W1]>, DwarfRegAlias<W1>;
  97 def X2    : AArch64Reg<2,   "x2",  [W2]>, DwarfRegAlias<W2>;
  98 def X3    : AArch64Reg<3,   "x3",  [W3]>, DwarfRegAlias<W3>;
  99 def X4    : AArch64Reg<4,   "x4",  [W4]>, DwarfRegAlias<W4>;
 100 def X5    : AArch64Reg<5,   "x5",  [W5]>, DwarfRegAlias<W5>;
 101 def X6    : AArch64Reg<6,   "x6",  [W6]>, DwarfRegAlias<W6>;
 102 def X7    : AArch64Reg<7,   "x7",  [W7]>, DwarfRegAlias<W7>;
 103 def X8    : AArch64Reg<8,   "x8",  [W8]>, DwarfRegAlias<W8>;
 104 def X9    : AArch64Reg<9,   "x9",  [W9]>, DwarfRegAlias<W9>;
 105 def X10   : AArch64Reg<10, "x10", [W10]>, DwarfRegAlias<W10>;
 106 def X11   : AArch64Reg<11, "x11", [W11]>, DwarfRegAlias<W11>;
 107 def X12   : AArch64Reg<12, "x12", [W12]>, DwarfRegAlias<W12>;
 108 def X13   : AArch64Reg<13, "x13", [W13]>, DwarfRegAlias<W13>;
 109 def X14   : AArch64Reg<14, "x14", [W14]>, DwarfRegAlias<W14>;
 110 def X15   : AArch64Reg<15, "x15", [W15]>, DwarfRegAlias<W15>;
 111 def X16   : AArch64Reg<16, "x16", [W16]>, DwarfRegAlias<W16>;
 112 def X17   : AArch64Reg<17, "x17", [W17]>, DwarfRegAlias<W17>;
 113 def X18   : AArch64Reg<18, "x18", [W18]>, DwarfRegAlias<W18>;
 114 def X19   : AArch64Reg<19, "x19", [W19]>, DwarfRegAlias<W19>;
 115 def X20   : AArch64Reg<20, "x20", [W20]>, DwarfRegAlias<W20>;
 116 def X21   : AArch64Reg<21, "x21", [W21]>, DwarfRegAlias<W21>;
 117 def X22   : AArch64Reg<22, "x22", [W22]>, DwarfRegAlias<W22>;
 118 def X23   : AArch64Reg<23, "x23", [W23]>, DwarfRegAlias<W23>;
 119 def X24   : AArch64Reg<24, "x24", [W24]>, DwarfRegAlias<W24>;
 120 def X25   : AArch64Reg<25, "x25", [W25]>, DwarfRegAlias<W25>;
 121 def X26   : AArch64Reg<26, "x26", [W26]>, DwarfRegAlias<W26>;
 122 def X27   : AArch64Reg<27, "x27", [W27]>, DwarfRegAlias<W27>;
 123 def X28   : AArch64Reg<28, "x28", [W28]>, DwarfRegAlias<W28>;
 124 def FP    : AArch64Reg<29, "x29", [W29]>, DwarfRegAlias<W29>;
 125 def LR    : AArch64Reg<30, "x30", [W30]>, DwarfRegAlias<W30>;
 126 def SP    : AArch64Reg<31, "sp",  [WSP]>, DwarfRegAlias<WSP>;
 127 def XZR   : AArch64Reg<31, "xzr", [WZR]>, DwarfRegAlias<WSP>;
 128 }
 129
 130 // Condition code register.
 131 def NZCV  : AArch64Reg<0, "nzcv">;
 132
 133 // First fault status register
 134 def FFR : AArch64Reg<0, "ffr">, DwarfRegNum<[47]>;
 135
 136 // GPR register classes with the intersections of GPR32/GPR32sp and
 137 // GPR64/GPR64sp for use by the coalescer.
 138 def GPR32common : RegisterClass<"AArch64", [i32], 32, (sequence "W%u", 0, 30)> {
 139   let AltOrders = [(rotl GPR32common, 8)];
 140   let AltOrderSelect = [{ return 1; }];
 141 }
 142 def GPR64common : RegisterClass<"AArch64", [i64], 64,
 143                                 (add (sequence "X%u", 0, 28), FP, LR)> {
 144   let AltOrders = [(rotl GPR64common, 8)];
 145   let AltOrderSelect = [{ return 1; }];
 146 }
 147 // GPR register classes which exclude SP/WSP.
 148 def GPR32 : RegisterClass<"AArch64", [i32], 32, (add GPR32common, WZR)> {
 149   let AltOrders = [(rotl GPR32, 8)];
 150   let AltOrderSelect = [{ return 1; }];
 151 }
 152 def GPR64 : RegisterClass<"AArch64", [i64], 64, (add GPR64common, XZR)> {
 153   let AltOrders = [(rotl GPR64, 8)];
 154   let AltOrderSelect = [{ return 1; }];
 155 }
 156
 157 // GPR register classes which include SP/WSP.
 158 def GPR32sp : RegisterClass<"AArch64", [i32], 32, (add GPR32common, WSP)> {
 159   let AltOrders = [(rotl GPR32sp, 8)];
 160   let AltOrderSelect = [{ return 1; }];
 161 }
 162 def GPR64sp : RegisterClass<"AArch64", [i64], 64, (add GPR64common, SP)> {
 163   let AltOrders = [(rotl GPR64sp, 8)];
 164   let AltOrderSelect = [{ return 1; }];
 165 }
 166
 167 def GPR32sponly : RegisterClass<"AArch64", [i32], 32, (add WSP)>;
 168 def GPR64sponly : RegisterClass<"AArch64", [i64], 64, (add SP)>;
 169
 170 def GPR64spPlus0Operand : AsmOperandClass {
 171   let Name = "GPR64sp0";
 172   let RenderMethod = "addRegOperands";
 173   let PredicateMethod = "isGPR64<AArch64::GPR64spRegClassID>";
 174   let ParserMethod = "tryParseGPR64sp0Operand";
 175 }
 176
 177 def GPR64sp0 : RegisterOperand<GPR64sp> {
 178   let ParserMatchClass = GPR64spPlus0Operand;
 179 }
 180
 181 // GPR32/GPR64 but with zero-register substitution enabled.
 182 // TODO: Roll this out to GPR32/GPR64/GPR32all/GPR64all.
 183 def GPR32z : RegisterOperand<GPR32> {
 184   let GIZeroRegister = WZR;
 185 }
 186 def GPR64z : RegisterOperand<GPR64> {
 187   let GIZeroRegister = XZR;
 188 }
 189
 190 // GPR argument registers.
 191 def GPR32arg : RegisterClass<"AArch64", [i32], 32, (sequence "W%u", 0, 7)>;
 192 def GPR64arg : RegisterClass<"AArch64", [i64], 64, (sequence "X%u", 0, 7)>;
 193
 194 // GPR register classes which include WZR/XZR AND SP/WSP. This is not a
 195 // constraint used by any instructions, it is used as a common super-class.
 196 def GPR32all : RegisterClass<"AArch64", [i32], 32, (add GPR32common, WZR, WSP)>;
 197 def GPR64all : RegisterClass<"AArch64", [i64], 64, (add GPR64common, XZR, SP)>;
 198
 199 // For tail calls, we can't use callee-saved registers, as they are restored
 200 // to the saved value before the tail call, which would clobber a call address.
 201 // This is for indirect tail calls to store the address of the destination.
 202 def tcGPR64 : RegisterClass<"AArch64", [i64], 64, (sub GPR64common, X19, X20, X21,
 203                                                      X22, X23, X24, X25, X26,
 204                                                      X27, X28, FP, LR)>;
 205
 206 // Restricted set of tail call registers, for use when branch target
 207 // enforcement is enabled. These are the only registers which can be used to
 208 // indirectly branch (not call) to the "BTI c" instruction at the start of a
 209 // BTI-protected function.
 210 def rtcGPR64 : RegisterClass<"AArch64", [i64], 64, (add X16, X17)>;
 211
 212 // Register set that excludes registers that are reserved for procedure calls.
 213 // This is used for pseudo-instructions that are actually implemented using a
 214 // procedure call.
 215 def GPR64noip : RegisterClass<"AArch64", [i64], 64, (sub GPR64, X16, X17, LR)>;
 216
 217 // GPR register classes for post increment amount of vector load/store that
 218 // has alternate printing when Rm=31 and prints a constant immediate value
 219 // equal to the total number of bytes transferred.
 220
 221 // FIXME: TableGen *should* be able to do these itself now. There appears to be
 222 // a bug in counting how many operands a Post-indexed MCInst should have which
 223 // means the aliases don't trigger.
 224 def GPR64pi1  : RegisterOperand<GPR64, "printPostIncOperand<1>">;
 225 def GPR64pi2  : RegisterOperand<GPR64, "printPostIncOperand<2>">;
 226 def GPR64pi3  : RegisterOperand<GPR64, "printPostIncOperand<3>">;
 227 def GPR64pi4  : RegisterOperand<GPR64, "printPostIncOperand<4>">;
 228 def GPR64pi6  : RegisterOperand<GPR64, "printPostIncOperand<6>">;
 229 def GPR64pi8  : RegisterOperand<GPR64, "printPostIncOperand<8>">;
 230 def GPR64pi12 : RegisterOperand<GPR64, "printPostIncOperand<12>">;
 231 def GPR64pi16 : RegisterOperand<GPR64, "printPostIncOperand<16>">;
 232 def GPR64pi24 : RegisterOperand<GPR64, "printPostIncOperand<24>">;
 233 def GPR64pi32 : RegisterOperand<GPR64, "printPostIncOperand<32>">;
 234 def GPR64pi48 : RegisterOperand<GPR64, "printPostIncOperand<48>">;
 235 def GPR64pi64 : RegisterOperand<GPR64, "printPostIncOperand<64>">;
 236
 237 // Condition code regclass.
 238 def CCR : RegisterClass<"AArch64", [i32], 32, (add NZCV)> {
 239   let CopyCost = -1;  // Don't allow copying of status registers.
 240
 241   // CCR is not allocatable.
 242   let isAllocatable = 0;
 243 }
 244
 245 //===----------------------------------------------------------------------===//
 246 // Floating Point Scalar Registers
 247 //===----------------------------------------------------------------------===//
 248
 249 def B0    : AArch64Reg<0,   "b0">, DwarfRegNum<[64]>;
 250 def B1    : AArch64Reg<1,   "b1">, DwarfRegNum<[65]>;
 251 def B2    : AArch64Reg<2,   "b2">, DwarfRegNum<[66]>;
 252 def B3    : AArch64Reg<3,   "b3">, DwarfRegNum<[67]>;
 253 def B4    : AArch64Reg<4,   "b4">, DwarfRegNum<[68]>;
 254 def B5    : AArch64Reg<5,   "b5">, DwarfRegNum<[69]>;
 255 def B6    : AArch64Reg<6,   "b6">, DwarfRegNum<[70]>;
 256 def B7    : AArch64Reg<7,   "b7">, DwarfRegNum<[71]>;
 257 def B8    : AArch64Reg<8,   "b8">, DwarfRegNum<[72]>;
 258 def B9    : AArch64Reg<9,   "b9">, DwarfRegNum<[73]>;
 259 def B10   : AArch64Reg<10, "b10">, DwarfRegNum<[74]>;
 260 def B11   : AArch64Reg<11, "b11">, DwarfRegNum<[75]>;
 261 def B12   : AArch64Reg<12, "b12">, DwarfRegNum<[76]>;
 262 def B13   : AArch64Reg<13, "b13">, DwarfRegNum<[77]>;
 263 def B14   : AArch64Reg<14, "b14">, DwarfRegNum<[78]>;
 264 def B15   : AArch64Reg<15, "b15">, DwarfRegNum<[79]>;
 265 def B16   : AArch64Reg<16, "b16">, DwarfRegNum<[80]>;
 266 def B17   : AArch64Reg<17, "b17">, DwarfRegNum<[81]>;
 267 def B18   : AArch64Reg<18, "b18">, DwarfRegNum<[82]>;
 268 def B19   : AArch64Reg<19, "b19">, DwarfRegNum<[83]>;
 269 def B20   : AArch64Reg<20, "b20">, DwarfRegNum<[84]>;
 270 def B21   : AArch64Reg<21, "b21">, DwarfRegNum<[85]>;
 271 def B22   : AArch64Reg<22, "b22">, DwarfRegNum<[86]>;
 272 def B23   : AArch64Reg<23, "b23">, DwarfRegNum<[87]>;
 273 def B24   : AArch64Reg<24, "b24">, DwarfRegNum<[88]>;
 274 def B25   : AArch64Reg<25, "b25">, DwarfRegNum<[89]>;
 275 def B26   : AArch64Reg<26, "b26">, DwarfRegNum<[90]>;
 276 def B27   : AArch64Reg<27, "b27">, DwarfRegNum<[91]>;
 277 def B28   : AArch64Reg<28, "b28">, DwarfRegNum<[92]>;
 278 def B29   : AArch64Reg<29, "b29">, DwarfRegNum<[93]>;
 279 def B30   : AArch64Reg<30, "b30">, DwarfRegNum<[94]>;
 280 def B31   : AArch64Reg<31, "b31">, DwarfRegNum<[95]>;
 281
 282 let SubRegIndices = [bsub] in {
 283 def H0    : AArch64Reg<0,   "h0", [B0]>, DwarfRegAlias<B0>;
 284 def H1    : AArch64Reg<1,   "h1", [B1]>, DwarfRegAlias<B1>;
 285 def H2    : AArch64Reg<2,   "h2", [B2]>, DwarfRegAlias<B2>;
 286 def H3    : AArch64Reg<3,   "h3", [B3]>, DwarfRegAlias<B3>;
 287 def H4    : AArch64Reg<4,   "h4", [B4]>, DwarfRegAlias<B4>;
 288 def H5    : AArch64Reg<5,   "h5", [B5]>, DwarfRegAlias<B5>;
 289 def H6    : AArch64Reg<6,   "h6", [B6]>, DwarfRegAlias<B6>;
 290 def H7    : AArch64Reg<7,   "h7", [B7]>, DwarfRegAlias<B7>;
 291 def H8    : AArch64Reg<8,   "h8", [B8]>, DwarfRegAlias<B8>;
 292 def H9    : AArch64Reg<9,   "h9", [B9]>, DwarfRegAlias<B9>;
 293 def H10   : AArch64Reg<10, "h10", [B10]>, DwarfRegAlias<B10>;
 294 def H11   : AArch64Reg<11, "h11", [B11]>, DwarfRegAlias<B11>;
 295 def H12   : AArch64Reg<12, "h12", [B12]>, DwarfRegAlias<B12>;
 296 def H13   : AArch64Reg<13, "h13", [B13]>, DwarfRegAlias<B13>;
 297 def H14   : AArch64Reg<14, "h14", [B14]>, DwarfRegAlias<B14>;
 298 def H15   : AArch64Reg<15, "h15", [B15]>, DwarfRegAlias<B15>;
 299 def H16   : AArch64Reg<16, "h16", [B16]>, DwarfRegAlias<B16>;
 300 def H17   : AArch64Reg<17, "h17", [B17]>, DwarfRegAlias<B17>;
 301 def H18   : AArch64Reg<18, "h18", [B18]>, DwarfRegAlias<B18>;
 302 def H19   : AArch64Reg<19, "h19", [B19]>, DwarfRegAlias<B19>;
 303 def H20   : AArch64Reg<20, "h20", [B20]>, DwarfRegAlias<B20>;
 304 def H21   : AArch64Reg<21, "h21", [B21]>, DwarfRegAlias<B21>;
 305 def H22   : AArch64Reg<22, "h22", [B22]>, DwarfRegAlias<B22>;
 306 def H23   : AArch64Reg<23, "h23", [B23]>, DwarfRegAlias<B23>;
 307 def H24   : AArch64Reg<24, "h24", [B24]>, DwarfRegAlias<B24>;
 308 def H25   : AArch64Reg<25, "h25", [B25]>, DwarfRegAlias<B25>;
 309 def H26   : AArch64Reg<26, "h26", [B26]>, DwarfRegAlias<B26>;
 310 def H27   : AArch64Reg<27, "h27", [B27]>, DwarfRegAlias<B27>;
 311 def H28   : AArch64Reg<28, "h28", [B28]>, DwarfRegAlias<B28>;
 312 def H29   : AArch64Reg<29, "h29", [B29]>, DwarfRegAlias<B29>;
 313 def H30   : AArch64Reg<30, "h30", [B30]>, DwarfRegAlias<B30>;
 314 def H31   : AArch64Reg<31, "h31", [B31]>, DwarfRegAlias<B31>;
 315 }
 316
 317 let SubRegIndices = [hsub] in {
 318 def S0    : AArch64Reg<0,   "s0", [H0]>, DwarfRegAlias<B0>;
 319 def S1    : AArch64Reg<1,   "s1", [H1]>, DwarfRegAlias<B1>;
 320 def S2    : AArch64Reg<2,   "s2", [H2]>, DwarfRegAlias<B2>;
 321 def S3    : AArch64Reg<3,   "s3", [H3]>, DwarfRegAlias<B3>;
 322 def S4    : AArch64Reg<4,   "s4", [H4]>, DwarfRegAlias<B4>;
 323 def S5    : AArch64Reg<5,   "s5", [H5]>, DwarfRegAlias<B5>;
 324 def S6    : AArch64Reg<6,   "s6", [H6]>, DwarfRegAlias<B6>;
 325 def S7    : AArch64Reg<7,   "s7", [H7]>, DwarfRegAlias<B7>;
 326 def S8    : AArch64Reg<8,   "s8", [H8]>, DwarfRegAlias<B8>;
 327 def S9    : AArch64Reg<9,   "s9", [H9]>, DwarfRegAlias<B9>;
 328 def S10   : AArch64Reg<10, "s10", [H10]>, DwarfRegAlias<B10>;
 329 def S11   : AArch64Reg<11, "s11", [H11]>, DwarfRegAlias<B11>;
 330 def S12   : AArch64Reg<12, "s12", [H12]>, DwarfRegAlias<B12>;
 331 def S13   : AArch64Reg<13, "s13", [H13]>, DwarfRegAlias<B13>;
 332 def S14   : AArch64Reg<14, "s14", [H14]>, DwarfRegAlias<B14>;
 333 def S15   : AArch64Reg<15, "s15", [H15]>, DwarfRegAlias<B15>;
 334 def S16   : AArch64Reg<16, "s16", [H16]>, DwarfRegAlias<B16>;
 335 def S17   : AArch64Reg<17, "s17", [H17]>, DwarfRegAlias<B17>;
 336 def S18   : AArch64Reg<18, "s18", [H18]>, DwarfRegAlias<B18>;
 337 def S19   : AArch64Reg<19, "s19", [H19]>, DwarfRegAlias<B19>;
 338 def S20   : AArch64Reg<20, "s20", [H20]>, DwarfRegAlias<B20>;
 339 def S21   : AArch64Reg<21, "s21", [H21]>, DwarfRegAlias<B21>;
 340 def S22   : AArch64Reg<22, "s22", [H22]>, DwarfRegAlias<B22>;
 341 def S23   : AArch64Reg<23, "s23", [H23]>, DwarfRegAlias<B23>;
 342 def S24   : AArch64Reg<24, "s24", [H24]>, DwarfRegAlias<B24>;
 343 def S25   : AArch64Reg<25, "s25", [H25]>, DwarfRegAlias<B25>;
 344 def S26   : AArch64Reg<26, "s26", [H26]>, DwarfRegAlias<B26>;
 345 def S27   : AArch64Reg<27, "s27", [H27]>, DwarfRegAlias<B27>;
 346 def S28   : AArch64Reg<28, "s28", [H28]>, DwarfRegAlias<B28>;
 347 def S29   : AArch64Reg<29, "s29", [H29]>, DwarfRegAlias<B29>;
 348 def S30   : AArch64Reg<30, "s30", [H30]>, DwarfRegAlias<B30>;
 349 def S31   : AArch64Reg<31, "s31", [H31]>, DwarfRegAlias<B31>;
 350 }
 351
 352 let SubRegIndices = [ssub], RegAltNameIndices = [vreg, vlist1] in {
 353 def D0    : AArch64Reg<0,   "d0", [S0], ["v0", ""]>, DwarfRegAlias<B0>;
 354 def D1    : AArch64Reg<1,   "d1", [S1], ["v1", ""]>, DwarfRegAlias<B1>;
 355 def D2    : AArch64Reg<2,   "d2", [S2], ["v2", ""]>, DwarfRegAlias<B2>;
 356 def D3    : AArch64Reg<3,   "d3", [S3], ["v3", ""]>, DwarfRegAlias<B3>;
 357 def D4    : AArch64Reg<4,   "d4", [S4], ["v4", ""]>, DwarfRegAlias<B4>;
 358 def D5    : AArch64Reg<5,   "d5", [S5], ["v5", ""]>, DwarfRegAlias<B5>;
 359 def D6    : AArch64Reg<6,   "d6", [S6], ["v6", ""]>, DwarfRegAlias<B6>;
 360 def D7    : AArch64Reg<7,   "d7", [S7], ["v7", ""]>, DwarfRegAlias<B7>;
 361 def D8    : AArch64Reg<8,   "d8", [S8], ["v8", ""]>, DwarfRegAlias<B8>;
 362 def D9    : AArch64Reg<9,   "d9", [S9], ["v9", ""]>, DwarfRegAlias<B9>;
 363 def D10   : AArch64Reg<10, "d10", [S10], ["v10", ""]>, DwarfRegAlias<B10>;
 364 def D11   : AArch64Reg<11, "d11", [S11], ["v11", ""]>, DwarfRegAlias<B11>;
 365 def D12   : AArch64Reg<12, "d12", [S12], ["v12", ""]>, DwarfRegAlias<B12>;
 366 def D13   : AArch64Reg<13, "d13", [S13], ["v13", ""]>, DwarfRegAlias<B13>;
 367 def D14   : AArch64Reg<14, "d14", [S14], ["v14", ""]>, DwarfRegAlias<B14>;
 368 def D15   : AArch64Reg<15, "d15", [S15], ["v15", ""]>, DwarfRegAlias<B15>;
 369 def D16   : AArch64Reg<16, "d16", [S16], ["v16", ""]>, DwarfRegAlias<B16>;
 370 def D17   : AArch64Reg<17, "d17", [S17], ["v17", ""]>, DwarfRegAlias<B17>;
 371 def D18   : AArch64Reg<18, "d18", [S18], ["v18", ""]>, DwarfRegAlias<B18>;
 372 def D19   : AArch64Reg<19, "d19", [S19], ["v19", ""]>, DwarfRegAlias<B19>;
 373 def D20   : AArch64Reg<20, "d20", [S20], ["v20", ""]>, DwarfRegAlias<B20>;
 374 def D21   : AArch64Reg<21, "d21", [S21], ["v21", ""]>, DwarfRegAlias<B21>;
 375 def D22   : AArch64Reg<22, "d22", [S22], ["v22", ""]>, DwarfRegAlias<B22>;
 376 def D23   : AArch64Reg<23, "d23", [S23], ["v23", ""]>, DwarfRegAlias<B23>;
 377 def D24   : AArch64Reg<24, "d24", [S24], ["v24", ""]>, DwarfRegAlias<B24>;
 378 def D25   : AArch64Reg<25, "d25", [S25], ["v25", ""]>, DwarfRegAlias<B25>;
 379 def D26   : AArch64Reg<26, "d26", [S26], ["v26", ""]>, DwarfRegAlias<B26>;
 380 def D27   : AArch64Reg<27, "d27", [S27], ["v27", ""]>, DwarfRegAlias<B27>;
 381 def D28   : AArch64Reg<28, "d28", [S28], ["v28", ""]>, DwarfRegAlias<B28>;
 382 def D29   : AArch64Reg<29, "d29", [S29], ["v29", ""]>, DwarfRegAlias<B29>;
 383 def D30   : AArch64Reg<30, "d30", [S30], ["v30", ""]>, DwarfRegAlias<B30>;
 384 def D31   : AArch64Reg<31, "d31", [S31], ["v31", ""]>, DwarfRegAlias<B31>;
 385 }
 386
 387 let SubRegIndices = [dsub], RegAltNameIndices = [vreg, vlist1] in {
 388 def Q0    : AArch64Reg<0,   "q0", [D0], ["v0", ""]>, DwarfRegAlias<B0>;
 389 def Q1    : AArch64Reg<1,   "q1", [D1], ["v1", ""]>, DwarfRegAlias<B1>;
 390 def Q2    : AArch64Reg<2,   "q2", [D2], ["v2", ""]>, DwarfRegAlias<B2>;
 391 def Q3    : AArch64Reg<3,   "q3", [D3], ["v3", ""]>, DwarfRegAlias<B3>;
 392 def Q4    : AArch64Reg<4,   "q4", [D4], ["v4", ""]>, DwarfRegAlias<B4>;
 393 def Q5    : AArch64Reg<5,   "q5", [D5], ["v5", ""]>, DwarfRegAlias<B5>;
 394 def Q6    : AArch64Reg<6,   "q6", [D6], ["v6", ""]>, DwarfRegAlias<B6>;
 395 def Q7    : AArch64Reg<7,   "q7", [D7], ["v7", ""]>, DwarfRegAlias<B7>;
 396 def Q8    : AArch64Reg<8,   "q8", [D8], ["v8", ""]>, DwarfRegAlias<B8>;
 397 def Q9    : AArch64Reg<9,   "q9", [D9], ["v9", ""]>, DwarfRegAlias<B9>;
 398 def Q10   : AArch64Reg<10, "q10", [D10], ["v10", ""]>, DwarfRegAlias<B10>;
 399 def Q11   : AArch64Reg<11, "q11", [D11], ["v11", ""]>, DwarfRegAlias<B11>;
 400 def Q12   : AArch64Reg<12, "q12", [D12], ["v12", ""]>, DwarfRegAlias<B12>;
 401 def Q13   : AArch64Reg<13, "q13", [D13], ["v13", ""]>, DwarfRegAlias<B13>;
 402 def Q14   : AArch64Reg<14, "q14", [D14], ["v14", ""]>, DwarfRegAlias<B14>;
 403 def Q15   : AArch64Reg<15, "q15", [D15], ["v15", ""]>, DwarfRegAlias<B15>;
 404 def Q16   : AArch64Reg<16, "q16", [D16], ["v16", ""]>, DwarfRegAlias<B16>;
 405 def Q17   : AArch64Reg<17, "q17", [D17], ["v17", ""]>, DwarfRegAlias<B17>;
 406 def Q18   : AArch64Reg<18, "q18", [D18], ["v18", ""]>, DwarfRegAlias<B18>;
 407 def Q19   : AArch64Reg<19, "q19", [D19], ["v19", ""]>, DwarfRegAlias<B19>;
 408 def Q20   : AArch64Reg<20, "q20", [D20], ["v20", ""]>, DwarfRegAlias<B20>;
 409 def Q21   : AArch64Reg<21, "q21", [D21], ["v21", ""]>, DwarfRegAlias<B21>;
 410 def Q22   : AArch64Reg<22, "q22", [D22], ["v22", ""]>, DwarfRegAlias<B22>;
 411 def Q23   : AArch64Reg<23, "q23", [D23], ["v23", ""]>, DwarfRegAlias<B23>;
 412 def Q24   : AArch64Reg<24, "q24", [D24], ["v24", ""]>, DwarfRegAlias<B24>;
 413 def Q25   : AArch64Reg<25, "q25", [D25], ["v25", ""]>, DwarfRegAlias<B25>;
 414 def Q26   : AArch64Reg<26, "q26", [D26], ["v26", ""]>, DwarfRegAlias<B26>;
 415 def Q27   : AArch64Reg<27, "q27", [D27], ["v27", ""]>, DwarfRegAlias<B27>;
 416 def Q28   : AArch64Reg<28, "q28", [D28], ["v28", ""]>, DwarfRegAlias<B28>;
 417 def Q29   : AArch64Reg<29, "q29", [D29], ["v29", ""]>, DwarfRegAlias<B29>;
 418 def Q30   : AArch64Reg<30, "q30", [D30], ["v30", ""]>, DwarfRegAlias<B30>;
 419 def Q31   : AArch64Reg<31, "q31", [D31], ["v31", ""]>, DwarfRegAlias<B31>;
 420 }
 421
 422 def FPR8  : RegisterClass<"AArch64", [untyped], 8, (sequence "B%u", 0, 31)> {
 423   let Size = 8;
 424 }
 425 def FPR16 : RegisterClass<"AArch64", [f16], 16, (sequence "H%u", 0, 31)> {
 426   let Size = 16;
 427 }
 428 def FPR32 : RegisterClass<"AArch64", [f32, i32], 32,(sequence "S%u", 0, 31)>;
 429 def FPR64 : RegisterClass<"AArch64", [f64, i64, v2f32, v1f64, v8i8, v4i16, v2i32,
 430                                     v1i64, v4f16],
 431                                     64, (sequence "D%u", 0, 31)>;
 432 // We don't (yet) have an f128 legal type, so don't use that here. We
 433 // normalize 128-bit vectors to v2f64 for arg passing and such, so use
 434 // that here.
 435 def FPR128 : RegisterClass<"AArch64",
 436                            [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, f128,
 437                             v8f16],
 438                            128, (sequence "Q%u", 0, 31)>;
 439
 440 // The lower 16 vector registers.  Some instructions can only take registers
 441 // in this range.
 442 def FPR128_lo : RegisterClass<"AArch64",
 443                               [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64, v8f16],
 444                               128, (trunc FPR128, 16)>;
 445
 446 // Pairs, triples, and quads of 64-bit vector registers.
 447 def DSeqPairs : RegisterTuples<[dsub0, dsub1], [(rotl FPR64, 0), (rotl FPR64, 1)]>;
 448 def DSeqTriples : RegisterTuples<[dsub0, dsub1, dsub2],
 449                                  [(rotl FPR64, 0), (rotl FPR64, 1),
 450                                   (rotl FPR64, 2)]>;
 451 def DSeqQuads : RegisterTuples<[dsub0, dsub1, dsub2, dsub3],
 452                                [(rotl FPR64, 0), (rotl FPR64, 1),
 453                                 (rotl FPR64, 2), (rotl FPR64, 3)]>;
 454 def DD   : RegisterClass<"AArch64", [untyped], 64, (add DSeqPairs)> {
 455   let Size = 128;
 456 }
 457 def DDD  : RegisterClass<"AArch64", [untyped], 64, (add DSeqTriples)> {
 458   let Size = 192;
 459 }
 460 def DDDD : RegisterClass<"AArch64", [untyped], 64, (add DSeqQuads)> {
 461   let Size = 256;
 462 }
 463
 464 // Pairs, triples, and quads of 128-bit vector registers.
 465 def QSeqPairs : RegisterTuples<[qsub0, qsub1], [(rotl FPR128, 0), (rotl FPR128, 1)]>;
 466 def QSeqTriples : RegisterTuples<[qsub0, qsub1, qsub2],
 467                                  [(rotl FPR128, 0), (rotl FPR128, 1),
 468                                   (rotl FPR128, 2)]>;
 469 def QSeqQuads : RegisterTuples<[qsub0, qsub1, qsub2, qsub3],
 470                                [(rotl FPR128, 0), (rotl FPR128, 1),
 471                                 (rotl FPR128, 2), (rotl FPR128, 3)]>;
 472 def QQ   : RegisterClass<"AArch64", [untyped], 128, (add QSeqPairs)> {
 473   let Size = 256;
 474 }
 475 def QQQ  : RegisterClass<"AArch64", [untyped], 128, (add QSeqTriples)> {
 476   let Size = 384;
 477 }
 478 def QQQQ : RegisterClass<"AArch64", [untyped], 128, (add QSeqQuads)> {
 479   let Size = 512;
 480 }
 481
 482
 483 // Vector operand versions of the FP registers. Alternate name printing and
 484 // assmebler matching.
 485 def VectorReg64AsmOperand : AsmOperandClass {
 486   let Name = "VectorReg64";
 487   let PredicateMethod = "isNeonVectorReg";
 488 }
 489 def VectorReg128AsmOperand : AsmOperandClass {
 490   let Name = "VectorReg128";
 491   let PredicateMethod = "isNeonVectorReg";
 492 }
 493
 494 def V64  : RegisterOperand<FPR64, "printVRegOperand"> {
 495   let ParserMatchClass = VectorReg64AsmOperand;
 496 }
 497
 498 def V128 : RegisterOperand<FPR128, "printVRegOperand"> {
 499   let ParserMatchClass = VectorReg128AsmOperand;
 500 }
 501
 502 def VectorRegLoAsmOperand : AsmOperandClass {
 503   let Name = "VectorRegLo";
 504   let PredicateMethod = "isNeonVectorRegLo";
 505 }
 506 def V128_lo : RegisterOperand<FPR128_lo, "printVRegOperand"> {
 507   let ParserMatchClass = VectorRegLoAsmOperand;
 508 }
 509
 510 class TypedVecListAsmOperand<int count, string vecty, int lanes, int eltsize>
 511     : AsmOperandClass {
 512   let Name = "TypedVectorList" # count # "_" # lanes # eltsize;
 513
 514   let PredicateMethod
 515       = "isTypedVectorList<RegKind::NeonVector, " # count # ", " # lanes # ", " # eltsize # ">";
 516   let RenderMethod = "addVectorListOperands<" # vecty  # ", "  # count # ">";
 517 }
 518
 519 class TypedVecListRegOperand<RegisterClass Reg, int lanes, string eltsize>
 520     : RegisterOperand<Reg, "printTypedVectorList<" # lanes # ", '"
 521                                                    # eltsize # "'>">;
 522
 523 multiclass VectorList<int count, RegisterClass Reg64, RegisterClass Reg128> {
 524   // With implicit types (probably on instruction instead). E.g. { v0, v1 }
 525   def _64AsmOperand : AsmOperandClass {
 526     let Name = NAME # "64";
 527     let PredicateMethod = "isImplicitlyTypedVectorList<RegKind::NeonVector, " # count # ">";
 528     let RenderMethod = "addVectorListOperands<AArch64Operand::VecListIdx_DReg, " # count # ">";
 529   }
 530
 531   def "64" : RegisterOperand<Reg64, "printImplicitlyTypedVectorList"> {
 532     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_64AsmOperand");
 533   }
 534
 535   def _128AsmOperand : AsmOperandClass {
 536     let Name = NAME # "128";
 537     let PredicateMethod = "isImplicitlyTypedVectorList<RegKind::NeonVector, " # count # ">";
 538     let RenderMethod = "addVectorListOperands<AArch64Operand::VecListIdx_QReg, " # count # ">";
 539   }
 540
 541   def "128" : RegisterOperand<Reg128, "printImplicitlyTypedVectorList"> {
 542     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_128AsmOperand");
 543   }
 544
 545   // 64-bit register lists with explicit type.
 546
 547   // { v0.8b, v1.8b }
 548   def _8bAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_DReg", 8, 8>;
 549   def "8b" : TypedVecListRegOperand<Reg64, 8, "b"> {
 550     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_8bAsmOperand");
 551   }
 552
 553   // { v0.4h, v1.4h }
 554   def _4hAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_DReg", 4, 16>;
 555   def "4h" : TypedVecListRegOperand<Reg64, 4, "h"> {
 556     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_4hAsmOperand");
 557   }
 558
 559   // { v0.2s, v1.2s }
 560   def _2sAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_DReg", 2, 32>;
 561   def "2s" : TypedVecListRegOperand<Reg64, 2, "s"> {
 562     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_2sAsmOperand");
 563   }
 564
 565   // { v0.1d, v1.1d }
 566   def _1dAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_DReg", 1, 64>;
 567   def "1d" : TypedVecListRegOperand<Reg64, 1, "d"> {
 568     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_1dAsmOperand");
 569   }
 570
 571   // 128-bit register lists with explicit type
 572
 573   // { v0.16b, v1.16b }
 574   def _16bAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 16, 8>;
 575   def "16b" : TypedVecListRegOperand<Reg128, 16, "b"> {
 576     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_16bAsmOperand");
 577   }
 578
 579   // { v0.8h, v1.8h }
 580   def _8hAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 8, 16>;
 581   def "8h" : TypedVecListRegOperand<Reg128, 8, "h"> {
 582     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_8hAsmOperand");
 583   }
 584
 585   // { v0.4s, v1.4s }
 586   def _4sAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 4, 32>;
 587   def "4s" : TypedVecListRegOperand<Reg128, 4, "s"> {
 588     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_4sAsmOperand");
 589   }
 590
 591   // { v0.2d, v1.2d }
 592   def _2dAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 2, 64>;
 593   def "2d" : TypedVecListRegOperand<Reg128, 2, "d"> {
 594     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_2dAsmOperand");
 595   }
 596
 597   // { v0.b, v1.b }
 598   def _bAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 0, 8>;
 599   def "b" : TypedVecListRegOperand<Reg128, 0, "b"> {
 600     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_bAsmOperand");
 601   }
 602
 603   // { v0.h, v1.h }
 604   def _hAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 0, 16>;
 605   def "h" : TypedVecListRegOperand<Reg128, 0, "h"> {
 606     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_hAsmOperand");
 607   }
 608
 609   // { v0.s, v1.s }
 610   def _sAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 0, 32>;
 611   def "s" : TypedVecListRegOperand<Reg128, 0, "s"> {
 612     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_sAsmOperand");
 613   }
 614
 615   // { v0.d, v1.d }
 616   def _dAsmOperand : TypedVecListAsmOperand<count, "AArch64Operand::VecListIdx_QReg", 0, 64>;
 617   def "d" : TypedVecListRegOperand<Reg128, 0, "d"> {
 618     let ParserMatchClass = !cast<AsmOperandClass>(NAME # "_dAsmOperand");
 619   }
 620
 621
 622 }
 623
 624 defm VecListOne   : VectorList<1, FPR64, FPR128>;
 625 defm VecListTwo   : VectorList<2, DD,    QQ>;
 626 defm VecListThree : VectorList<3, DDD,   QQQ>;
 627 defm VecListFour  : VectorList<4, DDDD,  QQQQ>;
 628
 629 class FPRAsmOperand<string RC> : AsmOperandClass {
 630   let Name = "FPRAsmOperand" # RC;
 631   let PredicateMethod = "isGPR64<AArch64::" # RC # "RegClassID>";
 632   let RenderMethod = "addRegOperands";
 633 }
 634
 635 // Register operand versions of the scalar FP registers.
 636 def FPR8Op  : RegisterOperand<FPR8, "printOperand"> {
 637   let ParserMatchClass = FPRAsmOperand<"FPR8">;
 638 }
 639
 640 def FPR16Op  : RegisterOperand<FPR16, "printOperand"> {
 641   let ParserMatchClass = FPRAsmOperand<"FPR16">;
 642 }
 643
 644 def FPR32Op  : RegisterOperand<FPR32, "printOperand"> {
 645   let ParserMatchClass = FPRAsmOperand<"FPR32">;
 646 }
 647
 648 def FPR64Op  : RegisterOperand<FPR64, "printOperand"> {
 649   let ParserMatchClass = FPRAsmOperand<"FPR64">;
 650 }
 651
 652 def FPR128Op : RegisterOperand<FPR128, "printOperand"> {
 653   let ParserMatchClass = FPRAsmOperand<"FPR128">;
 654 }
 655
 656 //===----------------------------------------------------------------------===//
 657 // ARMv8.1a atomic CASP register operands
 658
 659
 660 def WSeqPairs : RegisterTuples<[sube32, subo32],
 661                                [(decimate (rotl GPR32, 0), 2),
 662                                 (decimate (rotl GPR32, 1), 2)]>;
 663 def XSeqPairs : RegisterTuples<[sube64, subo64],
 664                                [(decimate (rotl GPR64, 0), 2),
 665                                 (decimate (rotl GPR64, 1), 2)]>;
 666
 667 def WSeqPairsClass   : RegisterClass<"AArch64", [untyped], 32,
 668                                      (add WSeqPairs)>{
 669   let Size = 64;
 670 }
 671 def XSeqPairsClass   : RegisterClass<"AArch64", [untyped], 64,
 672                                      (add XSeqPairs)>{
 673   let Size = 128;
 674 }
 675
 676
 677 let RenderMethod = "addRegOperands", ParserMethod="tryParseGPRSeqPair" in {
 678   def WSeqPairsAsmOperandClass : AsmOperandClass { let Name = "WSeqPair"; }
 679   def XSeqPairsAsmOperandClass : AsmOperandClass { let Name = "XSeqPair"; }
 680 }
 681
 682 def WSeqPairClassOperand :
 683     RegisterOperand<WSeqPairsClass, "printGPRSeqPairsClassOperand<32>"> {
 684   let ParserMatchClass = WSeqPairsAsmOperandClass;
 685 }
 686 def XSeqPairClassOperand :
 687     RegisterOperand<XSeqPairsClass, "printGPRSeqPairsClassOperand<64>"> {
 688   let ParserMatchClass = XSeqPairsAsmOperandClass;
 689 }
 690
 691
 692 //===----- END: v8.1a atomic CASP register operands -----------------------===//
 693
 694 // SVE predicate registers
 695 def P0    : AArch64Reg<0,   "p0">, DwarfRegNum<[48]>;
 696 def P1    : AArch64Reg<1,   "p1">, DwarfRegNum<[49]>;
 697 def P2    : AArch64Reg<2,   "p2">, DwarfRegNum<[50]>;
 698 def P3    : AArch64Reg<3,   "p3">, DwarfRegNum<[51]>;
 699 def P4    : AArch64Reg<4,   "p4">, DwarfRegNum<[52]>;
 700 def P5    : AArch64Reg<5,   "p5">, DwarfRegNum<[53]>;
 701 def P6    : AArch64Reg<6,   "p6">, DwarfRegNum<[54]>;
 702 def P7    : AArch64Reg<7,   "p7">, DwarfRegNum<[55]>;
 703 def P8    : AArch64Reg<8,   "p8">, DwarfRegNum<[56]>;
 704 def P9    : AArch64Reg<9,   "p9">, DwarfRegNum<[57]>;
 705 def P10   : AArch64Reg<10, "p10">, DwarfRegNum<[58]>;
 706 def P11   : AArch64Reg<11, "p11">, DwarfRegNum<[59]>;
 707 def P12   : AArch64Reg<12, "p12">, DwarfRegNum<[60]>;
 708 def P13   : AArch64Reg<13, "p13">, DwarfRegNum<[61]>;
 709 def P14   : AArch64Reg<14, "p14">, DwarfRegNum<[62]>;
 710 def P15   : AArch64Reg<15, "p15">, DwarfRegNum<[63]>;
 711
 712 // The part of SVE registers that don't overlap Neon registers.
 713 // These are only used as part of clobber lists.
 714 def Z0_HI    : AArch64Reg<0,   "z0_hi">;
 715 def Z1_HI    : AArch64Reg<1,   "z1_hi">;
 716 def Z2_HI    : AArch64Reg<2,   "z2_hi">;
 717 def Z3_HI    : AArch64Reg<3,   "z3_hi">;
 718 def Z4_HI    : AArch64Reg<4,   "z4_hi">;
 719 def Z5_HI    : AArch64Reg<5,   "z5_hi">;
 720 def Z6_HI    : AArch64Reg<6,   "z6_hi">;
 721 def Z7_HI    : AArch64Reg<7,   "z7_hi">;
 722 def Z8_HI    : AArch64Reg<8,   "z8_hi">;
 723 def Z9_HI    : AArch64Reg<9,   "z9_hi">;
 724 def Z10_HI   : AArch64Reg<10, "z10_hi">;
 725 def Z11_HI   : AArch64Reg<11, "z11_hi">;
 726 def Z12_HI   : AArch64Reg<12, "z12_hi">;
 727 def Z13_HI   : AArch64Reg<13, "z13_hi">;
 728 def Z14_HI   : AArch64Reg<14, "z14_hi">;
 729 def Z15_HI   : AArch64Reg<15, "z15_hi">;
 730 def Z16_HI   : AArch64Reg<16, "z16_hi">;
 731 def Z17_HI   : AArch64Reg<17, "z17_hi">;
 732 def Z18_HI   : AArch64Reg<18, "z18_hi">;
 733 def Z19_HI   : AArch64Reg<19, "z19_hi">;
 734 def Z20_HI   : AArch64Reg<20, "z20_hi">;
 735 def Z21_HI   : AArch64Reg<21, "z21_hi">;
 736 def Z22_HI   : AArch64Reg<22, "z22_hi">;
 737 def Z23_HI   : AArch64Reg<23, "z23_hi">;
 738 def Z24_HI   : AArch64Reg<24, "z24_hi">;
 739 def Z25_HI   : AArch64Reg<25, "z25_hi">;
 740 def Z26_HI   : AArch64Reg<26, "z26_hi">;
 741 def Z27_HI   : AArch64Reg<27, "z27_hi">;
 742 def Z28_HI   : AArch64Reg<28, "z28_hi">;
 743 def Z29_HI   : AArch64Reg<29, "z29_hi">;
 744 def Z30_HI   : AArch64Reg<30, "z30_hi">;
 745 def Z31_HI   : AArch64Reg<31, "z31_hi">;
 746
 747 // SVE variable-size vector registers
 748 let SubRegIndices = [zsub,zsub_hi] in {
 749 def Z0    : AArch64Reg<0,   "z0",  [Q0,  Z0_HI]>, DwarfRegNum<[96]>;
 750 def Z1    : AArch64Reg<1,   "z1",  [Q1,  Z1_HI]>, DwarfRegNum<[97]>;
 751 def Z2    : AArch64Reg<2,   "z2",  [Q2,  Z2_HI]>, DwarfRegNum<[98]>;
 752 def Z3    : AArch64Reg<3,   "z3",  [Q3,  Z3_HI]>, DwarfRegNum<[99]>;
 753 def Z4    : AArch64Reg<4,   "z4",  [Q4,  Z4_HI]>, DwarfRegNum<[100]>;
 754 def Z5    : AArch64Reg<5,   "z5",  [Q5,  Z5_HI]>, DwarfRegNum<[101]>;
 755 def Z6    : AArch64Reg<6,   "z6",  [Q6,  Z6_HI]>, DwarfRegNum<[102]>;
 756 def Z7    : AArch64Reg<7,   "z7",  [Q7,  Z7_HI]>, DwarfRegNum<[103]>;
 757 def Z8    : AArch64Reg<8,   "z8",  [Q8,  Z8_HI]>, DwarfRegNum<[104]>;
 758 def Z9    : AArch64Reg<9,   "z9",  [Q9,  Z9_HI]>, DwarfRegNum<[105]>;
 759 def Z10   : AArch64Reg<10, "z10", [Q10, Z10_HI]>, DwarfRegNum<[106]>;
 760 def Z11   : AArch64Reg<11, "z11", [Q11, Z11_HI]>, DwarfRegNum<[107]>;
 761 def Z12   : AArch64Reg<12, "z12", [Q12, Z12_HI]>, DwarfRegNum<[108]>;
 762 def Z13   : AArch64Reg<13, "z13", [Q13, Z13_HI]>, DwarfRegNum<[109]>;
 763 def Z14   : AArch64Reg<14, "z14", [Q14, Z14_HI]>, DwarfRegNum<[110]>;
 764 def Z15   : AArch64Reg<15, "z15", [Q15, Z15_HI]>, DwarfRegNum<[111]>;
 765 def Z16   : AArch64Reg<16, "z16", [Q16, Z16_HI]>, DwarfRegNum<[112]>;
 766 def Z17   : AArch64Reg<17, "z17", [Q17, Z17_HI]>, DwarfRegNum<[113]>;
 767 def Z18   : AArch64Reg<18, "z18", [Q18, Z18_HI]>, DwarfRegNum<[114]>;
 768 def Z19   : AArch64Reg<19, "z19", [Q19, Z19_HI]>, DwarfRegNum<[115]>;
 769 def Z20   : AArch64Reg<20, "z20", [Q20, Z20_HI]>, DwarfRegNum<[116]>;
 770 def Z21   : AArch64Reg<21, "z21", [Q21, Z21_HI]>, DwarfRegNum<[117]>;
 771 def Z22   : AArch64Reg<22, "z22", [Q22, Z22_HI]>, DwarfRegNum<[118]>;
 772 def Z23   : AArch64Reg<23, "z23", [Q23, Z23_HI]>, DwarfRegNum<[119]>;
 773 def Z24   : AArch64Reg<24, "z24", [Q24, Z24_HI]>, DwarfRegNum<[120]>;
 774 def Z25   : AArch64Reg<25, "z25", [Q25, Z25_HI]>, DwarfRegNum<[121]>;
 775 def Z26   : AArch64Reg<26, "z26", [Q26, Z26_HI]>, DwarfRegNum<[122]>;
 776 def Z27   : AArch64Reg<27, "z27", [Q27, Z27_HI]>, DwarfRegNum<[123]>;
 777 def Z28   : AArch64Reg<28, "z28", [Q28, Z28_HI]>, DwarfRegNum<[124]>;
 778 def Z29   : AArch64Reg<29, "z29", [Q29, Z29_HI]>, DwarfRegNum<[125]>;
 779 def Z30   : AArch64Reg<30, "z30", [Q30, Z30_HI]>, DwarfRegNum<[126]>;
 780 def Z31   : AArch64Reg<31, "z31", [Q31, Z31_HI]>, DwarfRegNum<[127]>;
 781 }
 782
 783 // Enum descibing the element size for destructive
 784 // operations.
 785 class ElementSizeEnum<bits<3> val> {
 786   bits<3> Value = val;
 787 }
 788
 789 def ElementSizeNone : ElementSizeEnum<0>;
 790 def ElementSizeB    : ElementSizeEnum<1>;
 791 def ElementSizeH    : ElementSizeEnum<2>;
 792 def ElementSizeS    : ElementSizeEnum<3>;
 793 def ElementSizeD    : ElementSizeEnum<4>;
 794 def ElementSizeQ    : ElementSizeEnum<5>;  // Unused
 795
 796 class SVERegOp <string Suffix, AsmOperandClass C,
 797                 ElementSizeEnum Size,
 798                 RegisterClass RC> : RegisterOperand<RC> {
 799   ElementSizeEnum ElementSize;
 800
 801   let ElementSize = Size;
 802   let PrintMethod = !if(!eq(Suffix, ""),
 803                         "printSVERegOp<>",
 804                         "printSVERegOp<'" # Suffix # "'>");
 805   let ParserMatchClass = C;
 806 }
 807
 808 class PPRRegOp <string Suffix, AsmOperandClass C, ElementSizeEnum Size,
 809                 RegisterClass RC> : SVERegOp<Suffix, C, Size, RC> {}
 810 class ZPRRegOp <string Suffix, AsmOperandClass C, ElementSizeEnum Size,
 811                 RegisterClass RC> : SVERegOp<Suffix, C, Size, RC> {}
 812
 813 //******************************************************************************
 814
 815 // SVE predicate register classes.
 816 class PPRClass<int lastreg> : RegisterClass<
 817                                   "AArch64",
 818                                   [ nxv16i1, nxv8i1, nxv4i1, nxv2i1 ], 16,
 819                                   (sequence "P%u", 0, lastreg)> {
 820   let Size = 16;
 821 }
 822
 823 def PPR    : PPRClass<15>;
 824 def PPR_3b : PPRClass<7>; // Restricted 3 bit SVE predicate register class.
 825
 826 class PPRAsmOperand <string name, string RegClass, int Width>: AsmOperandClass {
 827   let Name = "SVE" # name # "Reg";
 828   let PredicateMethod = "isSVEPredicateVectorRegOfWidth<"
 829                             # Width # ", " # "AArch64::" # RegClass # "RegClassID>";
 830   let DiagnosticType = "InvalidSVE" # name # "Reg";
 831   let RenderMethod = "addRegOperands";
 832   let ParserMethod = "tryParseSVEPredicateVector";
 833 }
 834
 835 def PPRAsmOpAny : PPRAsmOperand<"PredicateAny", "PPR",  0>;
 836 def PPRAsmOp8   : PPRAsmOperand<"PredicateB",   "PPR",  8>;
 837 def PPRAsmOp16  : PPRAsmOperand<"PredicateH",   "PPR", 16>;
 838 def PPRAsmOp32  : PPRAsmOperand<"PredicateS",   "PPR", 32>;
 839 def PPRAsmOp64  : PPRAsmOperand<"PredicateD",   "PPR", 64>;
 840
 841 def PPRAny : PPRRegOp<"",  PPRAsmOpAny, ElementSizeNone, PPR>;
 842 def PPR8   : PPRRegOp<"b", PPRAsmOp8,   ElementSizeB,  PPR>;
 843 def PPR16  : PPRRegOp<"h", PPRAsmOp16,  ElementSizeH,  PPR>;
 844 def PPR32  : PPRRegOp<"s", PPRAsmOp32,  ElementSizeS,  PPR>;
 845 def PPR64  : PPRRegOp<"d", PPRAsmOp64,  ElementSizeD,  PPR>;
 846
 847 def PPRAsmOp3bAny : PPRAsmOperand<"Predicate3bAny", "PPR_3b",  0>;
 848 def PPRAsmOp3b8   : PPRAsmOperand<"Predicate3bB",   "PPR_3b",  8>;
 849 def PPRAsmOp3b16  : PPRAsmOperand<"Predicate3bH",   "PPR_3b", 16>;
 850 def PPRAsmOp3b32  : PPRAsmOperand<"Predicate3bS",   "PPR_3b", 32>;
 851 def PPRAsmOp3b64  : PPRAsmOperand<"Predicate3bD",   "PPR_3b", 64>;
 852
 853 def PPR3bAny : PPRRegOp<"",  PPRAsmOp3bAny, ElementSizeNone, PPR_3b>;
 854 def PPR3b8   : PPRRegOp<"b", PPRAsmOp3b8,   ElementSizeB, PPR_3b>;
 855 def PPR3b16  : PPRRegOp<"h", PPRAsmOp3b16,  ElementSizeH, PPR_3b>;
 856 def PPR3b32  : PPRRegOp<"s", PPRAsmOp3b32,  ElementSizeS, PPR_3b>;
 857 def PPR3b64  : PPRRegOp<"d", PPRAsmOp3b64,  ElementSizeD, PPR_3b>;
 858
 859 //******************************************************************************
 860
 861 // SVE vector register class
 862 def ZPR : RegisterClass<"AArch64",
 863                         [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
 864                          nxv2f16, nxv4f16, nxv8f16,
 865                          nxv1f32, nxv2f32, nxv4f32,
 866                          nxv1f64, nxv2f64],
 867                         128, (sequence "Z%u", 0, 31)> {
 868   let Size = 128;
 869 }
 870
 871 // SVE restricted 4 bit scalable vector register class
 872 def ZPR_4b : RegisterClass<"AArch64",
 873                          [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
 874                           nxv2f16, nxv4f16, nxv8f16,
 875                           nxv1f32, nxv2f32, nxv4f32,
 876                           nxv1f64, nxv2f64],
 877                          128, (sequence "Z%u", 0, 15)> {
 878   let Size = 128;
 879 }
 880
 881 // SVE restricted 3 bit scalable vector register class
 882 def ZPR_3b : RegisterClass<"AArch64",
 883                          [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
 884                           nxv2f16, nxv4f16, nxv8f16,
 885                           nxv1f32, nxv2f32, nxv4f32,
 886                           nxv1f64, nxv2f64],
 887                          128, (sequence "Z%u", 0, 7)> {
 888   let Size = 128;
 889 }
 890
 891 class ZPRAsmOperand<string name, int Width, string RegClassSuffix = "">
 892     : AsmOperandClass {
 893   let Name = "SVE" # name # "Reg";
 894   let PredicateMethod = "isSVEDataVectorRegOfWidth<"
 895                             # Width # ", AArch64::ZPR"
 896                             # RegClassSuffix # "RegClassID>";
 897   let RenderMethod = "addRegOperands";
 898   let DiagnosticType = "InvalidZPR" # RegClassSuffix # Width;
 899   let ParserMethod = "tryParseSVEDataVector<false, "
 900                                # !if(!eq(Width, 0), "false", "true") # ">";
 901 }
 902
 903 def ZPRAsmOpAny : ZPRAsmOperand<"VectorAny", 0>;
 904 def ZPRAsmOp8   : ZPRAsmOperand<"VectorB",   8>;
 905 def ZPRAsmOp16  : ZPRAsmOperand<"VectorH",   16>;
 906 def ZPRAsmOp32  : ZPRAsmOperand<"VectorS",   32>;
 907 def ZPRAsmOp64  : ZPRAsmOperand<"VectorD",   64>;
 908 def ZPRAsmOp128 : ZPRAsmOperand<"VectorQ",   128>;
 909
 910 def ZPRAny  : ZPRRegOp<"",  ZPRAsmOpAny, ElementSizeNone, ZPR>;
 911 def ZPR8    : ZPRRegOp<"b", ZPRAsmOp8,   ElementSizeB, ZPR>;
 912 def ZPR16   : ZPRRegOp<"h", ZPRAsmOp16,  ElementSizeH, ZPR>;
 913 def ZPR32   : ZPRRegOp<"s", ZPRAsmOp32,  ElementSizeS, ZPR>;
 914 def ZPR64   : ZPRRegOp<"d", ZPRAsmOp64,  ElementSizeD, ZPR>;
 915 def ZPR128  : ZPRRegOp<"q", ZPRAsmOp128, ElementSizeQ, ZPR>;
 916
 917 def ZPRAsmOp3b8   : ZPRAsmOperand<"Vector3bB", 8, "_3b">;
 918 def ZPRAsmOp3b16  : ZPRAsmOperand<"Vector3bH", 16, "_3b">;
 919 def ZPRAsmOp3b32  : ZPRAsmOperand<"Vector3bS", 32, "_3b">;
 920
 921 def ZPR3b8  : ZPRRegOp<"b", ZPRAsmOp3b8,  ElementSizeB, ZPR_3b>;
 922 def ZPR3b16 : ZPRRegOp<"h", ZPRAsmOp3b16, ElementSizeH, ZPR_3b>;
 923 def ZPR3b32 : ZPRRegOp<"s", ZPRAsmOp3b32, ElementSizeS, ZPR_3b>;
 924
 925 def ZPRAsmOp4b16  : ZPRAsmOperand<"Vector4bH", 16, "_4b">;
 926 def ZPRAsmOp4b32  : ZPRAsmOperand<"Vector4bS", 32, "_4b">;
 927 def ZPRAsmOp4b64  : ZPRAsmOperand<"Vector4bD", 64, "_4b">;
 928
 929 def ZPR4b16 : ZPRRegOp<"h", ZPRAsmOp4b16, ElementSizeH, ZPR_4b>;
 930 def ZPR4b32 : ZPRRegOp<"s", ZPRAsmOp4b32, ElementSizeS, ZPR_4b>;
 931 def ZPR4b64 : ZPRRegOp<"d", ZPRAsmOp4b64, ElementSizeD, ZPR_4b>;
 932
 933 class FPRasZPR<int Width> : AsmOperandClass{
 934   let Name = "FPR" # Width # "asZPR";
 935   let PredicateMethod = "isFPRasZPR<AArch64::FPR" # Width # "RegClassID>";
 936   let RenderMethod = "addFPRasZPRRegOperands<" # Width # ">";
 937 }
 938
 939 class FPRasZPROperand<int Width> : RegisterOperand<ZPR> {
 940   let ParserMatchClass = FPRasZPR<Width>;
 941   let PrintMethod = "printZPRasFPR<" # Width # ">";
 942 }
 943
 944 def FPR8asZPR   : FPRasZPROperand<8>;
 945 def FPR16asZPR  : FPRasZPROperand<16>;
 946 def FPR32asZPR  : FPRasZPROperand<32>;
 947 def FPR64asZPR  : FPRasZPROperand<64>;
 948 def FPR128asZPR : FPRasZPROperand<128>;
 949
 950 let Namespace = "AArch64" in {
 951   def zsub0 : SubRegIndex<128, -1>;
 952   def zsub1 : SubRegIndex<128, -1>;
 953   def zsub2 : SubRegIndex<128, -1>;
 954   def zsub3 : SubRegIndex<128, -1>;
 955 }
 956
 957 // Pairs, triples, and quads of SVE vector registers.
 958 def ZSeqPairs   : RegisterTuples<[zsub0, zsub1], [(rotl ZPR, 0), (rotl ZPR, 1)]>;
 959 def ZSeqTriples : RegisterTuples<[zsub0, zsub1, zsub2], [(rotl ZPR, 0), (rotl ZPR, 1), (rotl ZPR, 2)]>;
 960 def ZSeqQuads   : RegisterTuples<[zsub0, zsub1, zsub2, zsub3], [(rotl ZPR, 0), (rotl ZPR, 1), (rotl ZPR, 2), (rotl ZPR, 3)]>;
 961
 962 def ZPR2   : RegisterClass<"AArch64", [untyped], 128, (add ZSeqPairs)>  {
 963   let Size = 256;
 964 }
 965 def ZPR3  : RegisterClass<"AArch64", [untyped], 128, (add ZSeqTriples)> {
 966   let Size = 384;
 967 }
 968 def ZPR4 : RegisterClass<"AArch64", [untyped], 128, (add ZSeqQuads)> {
 969   let Size = 512;
 970 }
 971
 972 class ZPRVectorList<int ElementWidth, int NumRegs> : AsmOperandClass {
 973   let Name = "SVEVectorList" # NumRegs # ElementWidth;
 974   let ParserMethod = "tryParseVectorList<RegKind::SVEDataVector>";
 975   let PredicateMethod =
 976       "isTypedVectorList<RegKind::SVEDataVector, " #NumRegs #", 0, " #ElementWidth #">";
 977   let RenderMethod = "addVectorListOperands<AArch64Operand::VecListIdx_ZReg, " # NumRegs # ">";
 978 }
 979
 980 def Z_b  : RegisterOperand<ZPR,  "printTypedVectorList<0,'b'>"> {
 981   let ParserMatchClass = ZPRVectorList<8, 1>;
 982 }
 983
 984 def Z_h  : RegisterOperand<ZPR,  "printTypedVectorList<0,'h'>"> {
 985   let ParserMatchClass = ZPRVectorList<16, 1>;
 986 }
 987
 988 def Z_s  : RegisterOperand<ZPR,  "printTypedVectorList<0,'s'>"> {
 989   let ParserMatchClass = ZPRVectorList<32, 1>;
 990 }
 991
 992 def Z_d  : RegisterOperand<ZPR,  "printTypedVectorList<0,'d'>"> {
 993   let ParserMatchClass = ZPRVectorList<64, 1>;
 994 }
 995
 996 def ZZ_b  : RegisterOperand<ZPR2, "printTypedVectorList<0,'b'>"> {
 997   let ParserMatchClass = ZPRVectorList<8, 2>;
 998 }
 999
1000 def ZZ_h  : RegisterOperand<ZPR2, "printTypedVectorList<0,'h'>"> {
1001   let ParserMatchClass = ZPRVectorList<16, 2>;
1002 }
1003
1004 def ZZ_s  : RegisterOperand<ZPR2, "printTypedVectorList<0,'s'>"> {
1005   let ParserMatchClass = ZPRVectorList<32, 2>;
1006 }
1007
1008 def ZZ_d  : RegisterOperand<ZPR2, "printTypedVectorList<0,'d'>"> {
1009   let ParserMatchClass = ZPRVectorList<64, 2>;
1010 }
1011
1012 def ZZZ_b  : RegisterOperand<ZPR3, "printTypedVectorList<0,'b'>"> {
1013   let ParserMatchClass = ZPRVectorList<8, 3>;
1014 }
1015
1016 def ZZZ_h  : RegisterOperand<ZPR3, "printTypedVectorList<0,'h'>"> {
1017   let ParserMatchClass = ZPRVectorList<16, 3>;
1018 }
1019
1020 def ZZZ_s  : RegisterOperand<ZPR3, "printTypedVectorList<0,'s'>"> {
1021   let ParserMatchClass = ZPRVectorList<32, 3>;
1022 }
1023
1024 def ZZZ_d  : RegisterOperand<ZPR3, "printTypedVectorList<0,'d'>"> {
1025   let ParserMatchClass = ZPRVectorList<64, 3>;
1026 }
1027
1028 def ZZZZ_b : RegisterOperand<ZPR4, "printTypedVectorList<0,'b'>"> {
1029   let ParserMatchClass = ZPRVectorList<8, 4>;
1030 }
1031
1032 def ZZZZ_h : RegisterOperand<ZPR4, "printTypedVectorList<0,'h'>"> {
1033   let ParserMatchClass = ZPRVectorList<16, 4>;
1034 }
1035
1036 def ZZZZ_s : RegisterOperand<ZPR4, "printTypedVectorList<0,'s'>"> {
1037   let ParserMatchClass = ZPRVectorList<32, 4>;
1038 }
1039
1040 def ZZZZ_d : RegisterOperand<ZPR4, "printTypedVectorList<0,'d'>"> {
1041   let ParserMatchClass = ZPRVectorList<64, 4>;
1042 }
1043
1044 class ZPRExtendAsmOperand<string ShiftExtend, int RegWidth, int Scale,
1045                           bit ScaleAlwaysSame = 0b0> : AsmOperandClass {
1046   let Name = "ZPRExtend" # ShiftExtend # RegWidth # Scale
1047                          # !if(ScaleAlwaysSame, "Only", "");
1048
1049   let PredicateMethod = "isSVEDataVectorRegWithShiftExtend<"
1050                           # RegWidth # ", AArch64::ZPRRegClassID, "
1051                           # "AArch64_AM::" # ShiftExtend # ", "
1052                           # Scale # ", "
1053                           # !if(ScaleAlwaysSame, "true", "false")
1054                           # ">";
1055   let DiagnosticType = "InvalidZPR" # RegWidth # ShiftExtend # Scale;
1056   let RenderMethod = "addRegOperands";
1057   let ParserMethod = "tryParseSVEDataVector<true, true>";
1058 }
1059
1060 class ZPRExtendRegisterOperand<bit SignExtend, bit IsLSL, string Repr,
1061                                int RegWidth, int Scale, string Suffix = "">
1062     : RegisterOperand<ZPR> {
1063   let ParserMatchClass =
1064     !cast<AsmOperandClass>("ZPR" # RegWidth # "AsmOpndExt" # Repr # Scale # Suffix);
1065   let PrintMethod = "printRegWithShiftExtend<"
1066                           # !if(SignExtend, "true", "false") # ", "
1067                           # Scale # ", "
1068                           # !if(IsLSL, "'x'", "'w'") # ", "
1069                           # !if(!eq(RegWidth, 32), "'s'", "'d'") # ">";
1070 }
1071
1072 foreach RegWidth = [32, 64] in {
1073   // UXTW(8|16|32|64)
1074   def ZPR#RegWidth#AsmOpndExtUXTW8Only : ZPRExtendAsmOperand<"UXTW", RegWidth, 8, 0b1>;
1075   def ZPR#RegWidth#AsmOpndExtUXTW8     : ZPRExtendAsmOperand<"UXTW", RegWidth, 8>;
1076   def ZPR#RegWidth#AsmOpndExtUXTW16    : ZPRExtendAsmOperand<"UXTW", RegWidth, 16>;
1077   def ZPR#RegWidth#AsmOpndExtUXTW32    : ZPRExtendAsmOperand<"UXTW", RegWidth, 32>;
1078   def ZPR#RegWidth#AsmOpndExtUXTW64    : ZPRExtendAsmOperand<"UXTW", RegWidth, 64>;
1079
1080   def ZPR#RegWidth#ExtUXTW8Only        : ZPRExtendRegisterOperand<0b0, 0b0, "UXTW", RegWidth, 8, "Only">;
1081   def ZPR#RegWidth#ExtUXTW8            : ZPRExtendRegisterOperand<0b0, 0b0, "UXTW", RegWidth, 8>;
1082   def ZPR#RegWidth#ExtUXTW16           : ZPRExtendRegisterOperand<0b0, 0b0, "UXTW", RegWidth, 16>;
1083   def ZPR#RegWidth#ExtUXTW32           : ZPRExtendRegisterOperand<0b0, 0b0, "UXTW", RegWidth, 32>;
1084   def ZPR#RegWidth#ExtUXTW64           : ZPRExtendRegisterOperand<0b0, 0b0, "UXTW", RegWidth, 64>;
1085
1086   // SXTW(8|16|32|64)
1087   def ZPR#RegWidth#AsmOpndExtSXTW8Only : ZPRExtendAsmOperand<"SXTW", RegWidth, 8, 0b1>;
1088   def ZPR#RegWidth#AsmOpndExtSXTW8     : ZPRExtendAsmOperand<"SXTW", RegWidth, 8>;
1089   def ZPR#RegWidth#AsmOpndExtSXTW16    : ZPRExtendAsmOperand<"SXTW", RegWidth, 16>;
1090   def ZPR#RegWidth#AsmOpndExtSXTW32    : ZPRExtendAsmOperand<"SXTW", RegWidth, 32>;
1091   def ZPR#RegWidth#AsmOpndExtSXTW64    : ZPRExtendAsmOperand<"SXTW", RegWidth, 64>;
1092
1093   def ZPR#RegWidth#ExtSXTW8Only        : ZPRExtendRegisterOperand<0b1, 0b0, "SXTW", RegWidth, 8, "Only">;
1094   def ZPR#RegWidth#ExtSXTW8            : ZPRExtendRegisterOperand<0b1, 0b0, "SXTW", RegWidth, 8>;
1095   def ZPR#RegWidth#ExtSXTW16           : ZPRExtendRegisterOperand<0b1, 0b0, "SXTW", RegWidth, 16>;
1096   def ZPR#RegWidth#ExtSXTW32           : ZPRExtendRegisterOperand<0b1, 0b0, "SXTW", RegWidth, 32>;
1097   def ZPR#RegWidth#ExtSXTW64           : ZPRExtendRegisterOperand<0b1, 0b0, "SXTW", RegWidth, 64>;
1098
1099   // LSL(8|16|32|64)
1100   def ZPR#RegWidth#AsmOpndExtLSL8      : ZPRExtendAsmOperand<"LSL", RegWidth, 8>;
1101   def ZPR#RegWidth#AsmOpndExtLSL16     : ZPRExtendAsmOperand<"LSL", RegWidth, 16>;
1102   def ZPR#RegWidth#AsmOpndExtLSL32     : ZPRExtendAsmOperand<"LSL", RegWidth, 32>;
1103   def ZPR#RegWidth#AsmOpndExtLSL64     : ZPRExtendAsmOperand<"LSL", RegWidth, 64>;
1104   def ZPR#RegWidth#ExtLSL8             : ZPRExtendRegisterOperand<0b0, 0b1, "LSL", RegWidth, 8>;
1105   def ZPR#RegWidth#ExtLSL16            : ZPRExtendRegisterOperand<0b0, 0b1, "LSL", RegWidth, 16>;
1106   def ZPR#RegWidth#ExtLSL32            : ZPRExtendRegisterOperand<0b0, 0b1, "LSL", RegWidth, 32>;
1107   def ZPR#RegWidth#ExtLSL64            : ZPRExtendRegisterOperand<0b0, 0b1, "LSL", RegWidth, 64>;
1108 }
1109
1110 class GPR64ShiftExtendAsmOperand <string AsmOperandName, int Scale, string RegClass> : AsmOperandClass {
1111   let Name = AsmOperandName # Scale;
1112   let PredicateMethod = "isGPR64WithShiftExtend<AArch64::"#RegClass#"RegClassID, " # Scale # ">";
1113   let DiagnosticType = "Invalid" # AsmOperandName # Scale;
1114   let RenderMethod = "addRegOperands";
1115   let ParserMethod = "tryParseGPROperand<true>";
1116 }
1117
1118 class GPR64ExtendRegisterOperand<string Name, int Scale, RegisterClass RegClass> : RegisterOperand<RegClass>{
1119   let ParserMatchClass = !cast<AsmOperandClass>(Name);
1120   let PrintMethod = "printRegWithShiftExtend<false, " # Scale # ", 'x', 0>";
1121 }
1122
1123 foreach Scale = [8, 16, 32, 64] in {
1124   def GPR64shiftedAsmOpnd # Scale : GPR64ShiftExtendAsmOperand<"GPR64shifted", Scale, "GPR64">;
1125   def GPR64shifted # Scale : GPR64ExtendRegisterOperand<"GPR64shiftedAsmOpnd" # Scale, Scale, GPR64>;
1126
1127   def GPR64NoXZRshiftedAsmOpnd # Scale : GPR64ShiftExtendAsmOperand<"GPR64NoXZRshifted", Scale, "GPR64common">;
1128   def GPR64NoXZRshifted # Scale : GPR64ExtendRegisterOperand<"GPR64NoXZRshiftedAsmOpnd" # Scale, Scale, GPR64common>;
1129 }