contrib/llvm-project/llvm/lib/Target/AArch64/AArch64InstrFormats.td

   1 //===- AArch64InstrFormats.td - AArch64 Instruction Formats --*- tblgen -*-===//
   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 //  Describe AArch64 instructions format here
  11 //
  12
  13 // Format specifies the encoding used by the instruction.  This is part of the
  14 // ad-hoc solution used to emit machine instruction encodings by our machine
  15 // code emitter.
  16 class Format<bits<2> val> {
  17   bits<2> Value = val;
  18 }
  19
  20 def PseudoFrm   : Format<0>;
  21 def NormalFrm   : Format<1>; // Do we need any others?
  22
  23 // AArch64 Instruction Format
  24 class AArch64Inst<Format f, string cstr> : Instruction {
  25   field bits<32> Inst; // Instruction encoding.
  26   // Mask of bits that cause an encoding to be UNPREDICTABLE.
  27   // If a bit is set, then if the corresponding bit in the
  28   // target encoding differs from its value in the "Inst" field,
  29   // the instruction is UNPREDICTABLE (SoftFail in abstract parlance).
  30   field bits<32> Unpredictable = 0;
  31   // SoftFail is the generic name for this field, but we alias it so
  32   // as to make it more obvious what it means in ARM-land.
  33   field bits<32> SoftFail = Unpredictable;
  34   let Namespace   = "AArch64";
  35   Format F        = f;
  36   bits<2> Form    = F.Value;
  37   let Pattern     = [];
  38   let Constraints = cstr;
  39 }
  40
  41 class InstSubst<string Asm, dag Result, bit EmitPriority = 0>
  42   : InstAlias<Asm, Result, EmitPriority>, Requires<[UseNegativeImmediates]>;
  43
  44 // Pseudo instructions (don't have encoding information)
  45 class Pseudo<dag oops, dag iops, list<dag> pattern, string cstr = "">
  46     : AArch64Inst<PseudoFrm, cstr> {
  47   dag OutOperandList = oops;
  48   dag InOperandList  = iops;
  49   let Pattern        = pattern;
  50   let isCodeGenOnly  = 1;
  51 }
  52
  53 // Real instructions (have encoding information)
  54 class EncodedI<string cstr, list<dag> pattern> : AArch64Inst<NormalFrm, cstr> {
  55   let Pattern = pattern;
  56   let Size = 4;
  57 }
  58
  59 // Enum describing whether an instruction is
  60 // destructive in its first source operand.
  61 class DestructiveInstTypeEnum<bits<1> val> {
  62   bits<1> Value = val;
  63 }
  64 def NotDestructive  : DestructiveInstTypeEnum<0>;
  65 def Destructive     : DestructiveInstTypeEnum<1>;
  66
  67 // Normal instructions
  68 class I<dag oops, dag iops, string asm, string operands, string cstr,
  69         list<dag> pattern>
  70     : EncodedI<cstr, pattern> {
  71   dag OutOperandList = oops;
  72   dag InOperandList  = iops;
  73   let AsmString      = !strconcat(asm, operands);
  74
  75   // Destructive operations (SVE)
  76   DestructiveInstTypeEnum DestructiveInstType = NotDestructive;
  77   ElementSizeEnum ElementSize = ElementSizeB;
  78
  79   let TSFlags{3} = DestructiveInstType.Value;
  80   let TSFlags{2-0} = ElementSize.Value;
  81 }
  82
  83 class TriOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$MHS, node:$RHS), res>;
  84 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
  85 class UnOpFrag<dag res>  : PatFrag<(ops node:$LHS), res>;
  86
  87 // Helper fragment for an extract of the high portion of a 128-bit vector.
  88 def extract_high_v16i8 :
  89    UnOpFrag<(extract_subvector (v16i8 node:$LHS), (i64 8))>;
  90 def extract_high_v8i16 :
  91    UnOpFrag<(extract_subvector (v8i16 node:$LHS), (i64 4))>;
  92 def extract_high_v4i32 :
  93    UnOpFrag<(extract_subvector (v4i32 node:$LHS), (i64 2))>;
  94 def extract_high_v2i64 :
  95    UnOpFrag<(extract_subvector (v2i64 node:$LHS), (i64 1))>;
  96
  97 //===----------------------------------------------------------------------===//
  98 // Asm Operand Classes.
  99 //
 100
 101 // Shifter operand for arithmetic shifted encodings.
 102 def ShifterOperand : AsmOperandClass {
 103   let Name = "Shifter";
 104 }
 105
 106 // Shifter operand for mov immediate encodings.
 107 def MovImm32ShifterOperand : AsmOperandClass {
 108   let SuperClasses = [ShifterOperand];
 109   let Name = "MovImm32Shifter";
 110   let RenderMethod = "addShifterOperands";
 111   let DiagnosticType = "InvalidMovImm32Shift";
 112 }
 113 def MovImm64ShifterOperand : AsmOperandClass {
 114   let SuperClasses = [ShifterOperand];
 115   let Name = "MovImm64Shifter";
 116   let RenderMethod = "addShifterOperands";
 117   let DiagnosticType = "InvalidMovImm64Shift";
 118 }
 119
 120 // Shifter operand for arithmetic register shifted encodings.
 121 class ArithmeticShifterOperand<int width> : AsmOperandClass {
 122   let SuperClasses = [ShifterOperand];
 123   let Name = "ArithmeticShifter" # width;
 124   let PredicateMethod = "isArithmeticShifter<" # width # ">";
 125   let RenderMethod = "addShifterOperands";
 126   let DiagnosticType = "AddSubRegShift" # width;
 127 }
 128
 129 def ArithmeticShifterOperand32 : ArithmeticShifterOperand<32>;
 130 def ArithmeticShifterOperand64 : ArithmeticShifterOperand<64>;
 131
 132 // Shifter operand for logical register shifted encodings.
 133 class LogicalShifterOperand<int width> : AsmOperandClass {
 134   let SuperClasses = [ShifterOperand];
 135   let Name = "LogicalShifter" # width;
 136   let PredicateMethod = "isLogicalShifter<" # width # ">";
 137   let RenderMethod = "addShifterOperands";
 138   let DiagnosticType = "AddSubRegShift" # width;
 139 }
 140
 141 def LogicalShifterOperand32 : LogicalShifterOperand<32>;
 142 def LogicalShifterOperand64 : LogicalShifterOperand<64>;
 143
 144 // Shifter operand for logical vector 128/64-bit shifted encodings.
 145 def LogicalVecShifterOperand : AsmOperandClass {
 146   let SuperClasses = [ShifterOperand];
 147   let Name = "LogicalVecShifter";
 148   let RenderMethod = "addShifterOperands";
 149 }
 150 def LogicalVecHalfWordShifterOperand : AsmOperandClass {
 151   let SuperClasses = [LogicalVecShifterOperand];
 152   let Name = "LogicalVecHalfWordShifter";
 153   let RenderMethod = "addShifterOperands";
 154 }
 155
 156 // The "MSL" shifter on the vector MOVI instruction.
 157 def MoveVecShifterOperand : AsmOperandClass {
 158   let SuperClasses = [ShifterOperand];
 159   let Name = "MoveVecShifter";
 160   let RenderMethod = "addShifterOperands";
 161 }
 162
 163 // Extend operand for arithmetic encodings.
 164 def ExtendOperand : AsmOperandClass {
 165   let Name = "Extend";
 166   let DiagnosticType = "AddSubRegExtendLarge";
 167 }
 168 def ExtendOperand64 : AsmOperandClass {
 169   let SuperClasses = [ExtendOperand];
 170   let Name = "Extend64";
 171   let DiagnosticType = "AddSubRegExtendSmall";
 172 }
 173 // 'extend' that's a lsl of a 64-bit register.
 174 def ExtendOperandLSL64 : AsmOperandClass {
 175   let SuperClasses = [ExtendOperand];
 176   let Name = "ExtendLSL64";
 177   let RenderMethod = "addExtend64Operands";
 178   let DiagnosticType = "AddSubRegExtendLarge";
 179 }
 180
 181 // 8-bit floating-point immediate encodings.
 182 def FPImmOperand : AsmOperandClass {
 183   let Name = "FPImm";
 184   let ParserMethod = "tryParseFPImm<true>";
 185   let DiagnosticType = "InvalidFPImm";
 186 }
 187
 188 def CondCode : AsmOperandClass {
 189   let Name = "CondCode";
 190   let DiagnosticType = "InvalidCondCode";
 191 }
 192
 193 // A 32-bit register pasrsed as 64-bit
 194 def GPR32as64Operand : AsmOperandClass {
 195   let Name = "GPR32as64";
 196   let ParserMethod =
 197       "tryParseGPROperand<false, RegConstraintEqualityTy::EqualsSubReg>";
 198 }
 199 def GPR32as64 : RegisterOperand<GPR32> {
 200   let ParserMatchClass = GPR32as64Operand;
 201 }
 202
 203 // A 64-bit register pasrsed as 32-bit
 204 def GPR64as32Operand : AsmOperandClass {
 205   let Name = "GPR64as32";
 206   let ParserMethod =
 207       "tryParseGPROperand<false, RegConstraintEqualityTy::EqualsSuperReg>";
 208 }
 209 def GPR64as32 : RegisterOperand<GPR64, "printGPR64as32"> {
 210   let ParserMatchClass = GPR64as32Operand;
 211 }
 212
 213 // 8-bit immediate for AdvSIMD where 64-bit values of the form:
 214 // aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh
 215 // are encoded as the eight bit value 'abcdefgh'.
 216 def SIMDImmType10Operand : AsmOperandClass { let Name = "SIMDImmType10"; }
 217
 218 class UImmScaledMemoryIndexed<int Width, int Scale> : AsmOperandClass {
 219   let Name = "UImm" # Width # "s" # Scale;
 220   let DiagnosticType = "InvalidMemoryIndexed" # Scale # "UImm" # Width;
 221   let RenderMethod = "addImmScaledOperands<" # Scale # ">";
 222   let PredicateMethod = "isUImmScaled<" # Width # ", " # Scale # ">";
 223 }
 224
 225 class SImmScaledMemoryIndexed<int Width, int Scale> : AsmOperandClass {
 226   let Name = "SImm" # Width # "s" # Scale;
 227   let DiagnosticType = "InvalidMemoryIndexed" # Scale # "SImm" # Width;
 228   let RenderMethod = "addImmScaledOperands<" # Scale # ">";
 229   let PredicateMethod = "isSImmScaled<" # Width # ", " # Scale # ">";
 230 }
 231
 232 //===----------------------------------------------------------------------===//
 233 // Operand Definitions.
 234 //
 235
 236 // ADR[P] instruction labels.
 237 def AdrpOperand : AsmOperandClass {
 238   let Name = "AdrpLabel";
 239   let ParserMethod = "tryParseAdrpLabel";
 240   let DiagnosticType = "InvalidLabel";
 241 }
 242 def adrplabel : Operand<i64> {
 243   let EncoderMethod = "getAdrLabelOpValue";
 244   let PrintMethod = "printAdrpLabel";
 245   let ParserMatchClass = AdrpOperand;
 246 }
 247
 248 def AdrOperand : AsmOperandClass {
 249   let Name = "AdrLabel";
 250   let ParserMethod = "tryParseAdrLabel";
 251   let DiagnosticType = "InvalidLabel";
 252 }
 253 def adrlabel : Operand<i64> {
 254   let EncoderMethod = "getAdrLabelOpValue";
 255   let ParserMatchClass = AdrOperand;
 256 }
 257
 258 class SImmOperand<int width> : AsmOperandClass {
 259   let Name = "SImm" # width;
 260   let DiagnosticType = "InvalidMemoryIndexedSImm" # width;
 261   let RenderMethod = "addImmOperands";
 262   let PredicateMethod = "isSImm<" # width # ">";
 263 }
 264
 265
 266 class AsmImmRange<int Low, int High> : AsmOperandClass {
 267   let Name = "Imm" # Low # "_" # High;
 268   let DiagnosticType = "InvalidImm" # Low # "_" # High;
 269   let RenderMethod = "addImmOperands";
 270   let PredicateMethod = "isImmInRange<" # Low # "," # High # ">";
 271 }
 272
 273 // Authenticated loads for v8.3 can have scaled 10-bit immediate offsets.
 274 def SImm10s8Operand : SImmScaledMemoryIndexed<10, 8>;
 275 def simm10Scaled : Operand<i64> {
 276   let ParserMatchClass = SImm10s8Operand;
 277   let DecoderMethod = "DecodeSImm<10>";
 278   let PrintMethod = "printImmScale<8>";
 279 }
 280
 281 def simm9s16 : Operand<i64> {
 282   let ParserMatchClass = SImmScaledMemoryIndexed<9, 16>;
 283   let DecoderMethod = "DecodeSImm<9>";
 284   let PrintMethod = "printImmScale<16>";
 285 }
 286
 287 // uimm6 predicate - True if the immediate is in the range [0, 63].
 288 def UImm6Operand : AsmOperandClass {
 289   let Name = "UImm6";
 290   let DiagnosticType = "InvalidImm0_63";
 291 }
 292
 293 def uimm6 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= 0 && Imm < 64; }]> {
 294   let ParserMatchClass = UImm6Operand;
 295 }
 296
 297 def uimm16 : Operand<i16>, ImmLeaf<i16, [{return Imm >= 0 && Imm < 65536;}]>{
 298   let ParserMatchClass = AsmImmRange<0, 65535>;
 299 }
 300
 301 def SImm9Operand : SImmOperand<9>;
 302 def simm9 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= -256 && Imm < 256; }]> {
 303   let ParserMatchClass = SImm9Operand;
 304   let DecoderMethod = "DecodeSImm<9>";
 305 }
 306
 307 def SImm8Operand : SImmOperand<8>;
 308 def simm8 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= -128 && Imm < 127; }]> {
 309   let ParserMatchClass = SImm8Operand;
 310   let DecoderMethod = "DecodeSImm<8>";
 311 }
 312
 313 def SImm6Operand : SImmOperand<6>;
 314 def simm6_32b : Operand<i32>, ImmLeaf<i32, [{ return Imm >= -32 && Imm < 32; }]> {
 315   let ParserMatchClass = SImm6Operand;
 316   let DecoderMethod = "DecodeSImm<6>";
 317 }
 318
 319 def SImm5Operand : SImmOperand<5>;
 320 def simm5_64b : Operand<i64>, ImmLeaf<i64, [{ return Imm >= -16 && Imm < 16; }]> {
 321   let ParserMatchClass = SImm5Operand;
 322   let DecoderMethod = "DecodeSImm<5>";
 323 }
 324
 325 def simm5_32b : Operand<i32>, ImmLeaf<i32, [{ return Imm >= -16 && Imm < 16; }]> {
 326   let ParserMatchClass = SImm5Operand;
 327   let DecoderMethod = "DecodeSImm<5>";
 328 }
 329
 330 // simm7sN predicate - True if the immediate is a multiple of N in the range
 331 // [-64 * N, 63 * N].
 332
 333 def SImm7s4Operand : SImmScaledMemoryIndexed<7, 4>;
 334 def SImm7s8Operand : SImmScaledMemoryIndexed<7, 8>;
 335 def SImm7s16Operand : SImmScaledMemoryIndexed<7, 16>;
 336
 337 def simm7s4 : Operand<i32> {
 338   let ParserMatchClass = SImm7s4Operand;
 339   let PrintMethod = "printImmScale<4>";
 340 }
 341
 342 def simm7s8 : Operand<i32> {
 343   let ParserMatchClass = SImm7s8Operand;
 344   let PrintMethod = "printImmScale<8>";
 345 }
 346
 347 def simm7s16 : Operand<i32> {
 348   let ParserMatchClass = SImm7s16Operand;
 349   let PrintMethod = "printImmScale<16>";
 350 }
 351
 352 def am_indexed7s8   : ComplexPattern<i64, 2, "SelectAddrModeIndexed7S8", []>;
 353 def am_indexed7s16  : ComplexPattern<i64, 2, "SelectAddrModeIndexed7S16", []>;
 354 def am_indexed7s32  : ComplexPattern<i64, 2, "SelectAddrModeIndexed7S32", []>;
 355 def am_indexed7s64  : ComplexPattern<i64, 2, "SelectAddrModeIndexed7S64", []>;
 356 def am_indexed7s128 : ComplexPattern<i64, 2, "SelectAddrModeIndexed7S128", []>;
 357
 358 def am_indexedu6s128 : ComplexPattern<i64, 2, "SelectAddrModeIndexedU6S128", []>;
 359 def am_indexeds9s128 : ComplexPattern<i64, 2, "SelectAddrModeIndexedS9S128", []>;
 360
 361 // uimm5sN predicate - True if the immediate is a multiple of N in the range
 362 // [0 * N, 32 * N].
 363 def UImm5s2Operand : UImmScaledMemoryIndexed<5, 2>;
 364 def UImm5s4Operand : UImmScaledMemoryIndexed<5, 4>;
 365 def UImm5s8Operand : UImmScaledMemoryIndexed<5, 8>;
 366
 367 def uimm5s2 : Operand<i64>, ImmLeaf<i64,
 368                 [{ return Imm >= 0 && Imm < (32*2) && ((Imm % 2) == 0); }]> {
 369   let ParserMatchClass = UImm5s2Operand;
 370   let PrintMethod = "printImmScale<2>";
 371 }
 372 def uimm5s4 : Operand<i64>, ImmLeaf<i64,
 373                 [{ return Imm >= 0 && Imm < (32*4) && ((Imm % 4) == 0); }]> {
 374   let ParserMatchClass = UImm5s4Operand;
 375   let PrintMethod = "printImmScale<4>";
 376 }
 377 def uimm5s8 : Operand<i64>, ImmLeaf<i64,
 378                 [{ return Imm >= 0 && Imm < (32*8) && ((Imm % 8) == 0); }]> {
 379   let ParserMatchClass = UImm5s8Operand;
 380   let PrintMethod = "printImmScale<8>";
 381 }
 382
 383 // uimm6sN predicate - True if the immediate is a multiple of N in the range
 384 // [0 * N, 64 * N].
 385 def UImm6s1Operand : UImmScaledMemoryIndexed<6, 1>;
 386 def UImm6s2Operand : UImmScaledMemoryIndexed<6, 2>;
 387 def UImm6s4Operand : UImmScaledMemoryIndexed<6, 4>;
 388 def UImm6s8Operand : UImmScaledMemoryIndexed<6, 8>;
 389 def UImm6s16Operand : UImmScaledMemoryIndexed<6, 16>;
 390
 391 def uimm6s1 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= 0 && Imm < 64; }]> {
 392   let ParserMatchClass = UImm6s1Operand;
 393 }
 394 def uimm6s2 : Operand<i64>, ImmLeaf<i64,
 395 [{ return Imm >= 0 && Imm < (64*2) && ((Imm % 2) == 0); }]> {
 396   let PrintMethod = "printImmScale<2>";
 397   let ParserMatchClass = UImm6s2Operand;
 398 }
 399 def uimm6s4 : Operand<i64>, ImmLeaf<i64,
 400 [{ return Imm >= 0 && Imm < (64*4) && ((Imm % 4) == 0); }]> {
 401   let PrintMethod = "printImmScale<4>";
 402   let ParserMatchClass = UImm6s4Operand;
 403 }
 404 def uimm6s8 : Operand<i64>, ImmLeaf<i64,
 405 [{ return Imm >= 0 && Imm < (64*8) && ((Imm % 8) == 0); }]> {
 406   let PrintMethod = "printImmScale<8>";
 407   let ParserMatchClass = UImm6s8Operand;
 408 }
 409 def uimm6s16 : Operand<i64>, ImmLeaf<i64,
 410 [{ return Imm >= 0 && Imm < (64*16) && ((Imm % 16) == 0); }]> {
 411   let PrintMethod = "printImmScale<16>";
 412   let ParserMatchClass = UImm6s16Operand;
 413 }
 414
 415 // simm6sN predicate - True if the immediate is a multiple of N in the range
 416 // [-32 * N, 31 * N].
 417 def SImm6s1Operand : SImmScaledMemoryIndexed<6, 1>;
 418 def simm6s1 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= -32 && Imm < 32; }]> {
 419   let ParserMatchClass = SImm6s1Operand;
 420   let DecoderMethod = "DecodeSImm<6>";
 421 }
 422
 423 // simm4sN predicate - True if the immediate is a multiple of N in the range
 424 // [ -8* N, 7 * N].
 425 def SImm4s1Operand  : SImmScaledMemoryIndexed<4, 1>;
 426 def SImm4s2Operand  : SImmScaledMemoryIndexed<4, 2>;
 427 def SImm4s3Operand  : SImmScaledMemoryIndexed<4, 3>;
 428 def SImm4s4Operand  : SImmScaledMemoryIndexed<4, 4>;
 429 def SImm4s16Operand : SImmScaledMemoryIndexed<4, 16>;
 430
 431 def simm4s1 : Operand<i64>, ImmLeaf<i64,
 432 [{ return Imm >=-8  && Imm <= 7; }]> {
 433   let ParserMatchClass = SImm4s1Operand;
 434   let DecoderMethod = "DecodeSImm<4>";
 435 }
 436
 437 def simm4s2 : Operand<i64>, ImmLeaf<i64,
 438 [{ return Imm >=-16  && Imm <= 14 && (Imm % 2) == 0x0; }]> {
 439   let PrintMethod = "printImmScale<2>";
 440   let ParserMatchClass = SImm4s2Operand;
 441   let DecoderMethod = "DecodeSImm<4>";
 442 }
 443
 444 def simm4s3 : Operand<i64>, ImmLeaf<i64,
 445 [{ return Imm >=-24  && Imm <= 21 && (Imm % 3) == 0x0; }]> {
 446   let PrintMethod = "printImmScale<3>";
 447   let ParserMatchClass = SImm4s3Operand;
 448   let DecoderMethod = "DecodeSImm<4>";
 449 }
 450
 451 def simm4s4 : Operand<i64>, ImmLeaf<i64,
 452 [{ return Imm >=-32  && Imm <= 28 && (Imm % 4) == 0x0; }]> {
 453   let PrintMethod = "printImmScale<4>";
 454   let ParserMatchClass = SImm4s4Operand;
 455   let DecoderMethod = "DecodeSImm<4>";
 456 }
 457 def simm4s16 : Operand<i64>, ImmLeaf<i64,
 458 [{ return Imm >=-128  && Imm <= 112 && (Imm % 16) == 0x0; }]> {
 459   let PrintMethod = "printImmScale<16>";
 460   let ParserMatchClass = SImm4s16Operand;
 461   let DecoderMethod = "DecodeSImm<4>";
 462 }
 463
 464 def Imm1_8Operand : AsmImmRange<1, 8>;
 465 def Imm1_16Operand : AsmImmRange<1, 16>;
 466 def Imm1_32Operand : AsmImmRange<1, 32>;
 467 def Imm1_64Operand : AsmImmRange<1, 64>;
 468
 469 class BranchTarget<int N> : AsmOperandClass {
 470   let Name = "BranchTarget" # N;
 471   let DiagnosticType = "InvalidLabel";
 472   let PredicateMethod = "isBranchTarget<" # N # ">";
 473 }
 474
 475 class PCRelLabel<int N> : BranchTarget<N> {
 476   let Name = "PCRelLabel" # N;
 477 }
 478
 479 def BranchTarget14Operand : BranchTarget<14>;
 480 def BranchTarget26Operand : BranchTarget<26>;
 481 def PCRelLabel19Operand   : PCRelLabel<19>;
 482
 483 def MovZSymbolG3AsmOperand : AsmOperandClass {
 484   let Name = "MovZSymbolG3";
 485   let RenderMethod = "addImmOperands";
 486 }
 487
 488 def movz_symbol_g3 : Operand<i32> {
 489   let ParserMatchClass = MovZSymbolG3AsmOperand;
 490 }
 491
 492 def MovZSymbolG2AsmOperand : AsmOperandClass {
 493   let Name = "MovZSymbolG2";
 494   let RenderMethod = "addImmOperands";
 495 }
 496
 497 def movz_symbol_g2 : Operand<i32> {
 498   let ParserMatchClass = MovZSymbolG2AsmOperand;
 499 }
 500
 501 def MovZSymbolG1AsmOperand : AsmOperandClass {
 502   let Name = "MovZSymbolG1";
 503   let RenderMethod = "addImmOperands";
 504 }
 505
 506 def movz_symbol_g1 : Operand<i32> {
 507   let ParserMatchClass = MovZSymbolG1AsmOperand;
 508 }
 509
 510 def MovZSymbolG0AsmOperand : AsmOperandClass {
 511   let Name = "MovZSymbolG0";
 512   let RenderMethod = "addImmOperands";
 513 }
 514
 515 def movz_symbol_g0 : Operand<i32> {
 516   let ParserMatchClass = MovZSymbolG0AsmOperand;
 517 }
 518
 519 def MovKSymbolG3AsmOperand : AsmOperandClass {
 520   let Name = "MovKSymbolG3";
 521   let RenderMethod = "addImmOperands";
 522 }
 523
 524 def movk_symbol_g3 : Operand<i32> {
 525   let ParserMatchClass = MovKSymbolG3AsmOperand;
 526 }
 527
 528 def MovKSymbolG2AsmOperand : AsmOperandClass {
 529   let Name = "MovKSymbolG2";
 530   let RenderMethod = "addImmOperands";
 531 }
 532
 533 def movk_symbol_g2 : Operand<i32> {
 534   let ParserMatchClass = MovKSymbolG2AsmOperand;
 535 }
 536
 537 def MovKSymbolG1AsmOperand : AsmOperandClass {
 538   let Name = "MovKSymbolG1";
 539   let RenderMethod = "addImmOperands";
 540 }
 541
 542 def movk_symbol_g1 : Operand<i32> {
 543   let ParserMatchClass = MovKSymbolG1AsmOperand;
 544 }
 545
 546 def MovKSymbolG0AsmOperand : AsmOperandClass {
 547   let Name = "MovKSymbolG0";
 548   let RenderMethod = "addImmOperands";
 549 }
 550
 551 def movk_symbol_g0 : Operand<i32> {
 552   let ParserMatchClass = MovKSymbolG0AsmOperand;
 553 }
 554
 555 class fixedpoint_i32<ValueType FloatVT>
 556   : Operand<FloatVT>,
 557     ComplexPattern<FloatVT, 1, "SelectCVTFixedPosOperand<32>", [fpimm, ld]> {
 558   let EncoderMethod = "getFixedPointScaleOpValue";
 559   let DecoderMethod = "DecodeFixedPointScaleImm32";
 560   let ParserMatchClass = Imm1_32Operand;
 561 }
 562
 563 class fixedpoint_i64<ValueType FloatVT>
 564   : Operand<FloatVT>,
 565     ComplexPattern<FloatVT, 1, "SelectCVTFixedPosOperand<64>", [fpimm, ld]> {
 566   let EncoderMethod = "getFixedPointScaleOpValue";
 567   let DecoderMethod = "DecodeFixedPointScaleImm64";
 568   let ParserMatchClass = Imm1_64Operand;
 569 }
 570
 571 def fixedpoint_f16_i32 : fixedpoint_i32<f16>;
 572 def fixedpoint_f32_i32 : fixedpoint_i32<f32>;
 573 def fixedpoint_f64_i32 : fixedpoint_i32<f64>;
 574
 575 def fixedpoint_f16_i64 : fixedpoint_i64<f16>;
 576 def fixedpoint_f32_i64 : fixedpoint_i64<f32>;
 577 def fixedpoint_f64_i64 : fixedpoint_i64<f64>;
 578
 579 def vecshiftR8 : Operand<i32>, ImmLeaf<i32, [{
 580   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 9);
 581 }]> {
 582   let EncoderMethod = "getVecShiftR8OpValue";
 583   let DecoderMethod = "DecodeVecShiftR8Imm";
 584   let ParserMatchClass = Imm1_8Operand;
 585 }
 586 def vecshiftR16 : Operand<i32>, ImmLeaf<i32, [{
 587   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 17);
 588 }]> {
 589   let EncoderMethod = "getVecShiftR16OpValue";
 590   let DecoderMethod = "DecodeVecShiftR16Imm";
 591   let ParserMatchClass = Imm1_16Operand;
 592 }
 593 def vecshiftR16Narrow : Operand<i32>, ImmLeaf<i32, [{
 594   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 9);
 595 }]> {
 596   let EncoderMethod = "getVecShiftR16OpValue";
 597   let DecoderMethod = "DecodeVecShiftR16ImmNarrow";
 598   let ParserMatchClass = Imm1_8Operand;
 599 }
 600 def vecshiftR32 : Operand<i32>, ImmLeaf<i32, [{
 601   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 33);
 602 }]> {
 603   let EncoderMethod = "getVecShiftR32OpValue";
 604   let DecoderMethod = "DecodeVecShiftR32Imm";
 605   let ParserMatchClass = Imm1_32Operand;
 606 }
 607 def vecshiftR32Narrow : Operand<i32>, ImmLeaf<i32, [{
 608   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 17);
 609 }]> {
 610   let EncoderMethod = "getVecShiftR32OpValue";
 611   let DecoderMethod = "DecodeVecShiftR32ImmNarrow";
 612   let ParserMatchClass = Imm1_16Operand;
 613 }
 614 def vecshiftR64 : Operand<i32>, ImmLeaf<i32, [{
 615   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 65);
 616 }]> {
 617   let EncoderMethod = "getVecShiftR64OpValue";
 618   let DecoderMethod = "DecodeVecShiftR64Imm";
 619   let ParserMatchClass = Imm1_64Operand;
 620 }
 621 def vecshiftR64Narrow : Operand<i32>, ImmLeaf<i32, [{
 622   return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 33);
 623 }]> {
 624   let EncoderMethod = "getVecShiftR64OpValue";
 625   let DecoderMethod = "DecodeVecShiftR64ImmNarrow";
 626   let ParserMatchClass = Imm1_32Operand;
 627 }
 628
 629 def Imm0_1Operand : AsmImmRange<0, 1>;
 630 def Imm0_7Operand : AsmImmRange<0, 7>;
 631 def Imm0_15Operand : AsmImmRange<0, 15>;
 632 def Imm0_31Operand : AsmImmRange<0, 31>;
 633 def Imm0_63Operand : AsmImmRange<0, 63>;
 634
 635 def vecshiftL8 : Operand<i32>, ImmLeaf<i32, [{
 636   return (((uint32_t)Imm) < 8);
 637 }]> {
 638   let EncoderMethod = "getVecShiftL8OpValue";
 639   let DecoderMethod = "DecodeVecShiftL8Imm";
 640   let ParserMatchClass = Imm0_7Operand;
 641 }
 642 def vecshiftL16 : Operand<i32>, ImmLeaf<i32, [{
 643   return (((uint32_t)Imm) < 16);
 644 }]> {
 645   let EncoderMethod = "getVecShiftL16OpValue";
 646   let DecoderMethod = "DecodeVecShiftL16Imm";
 647   let ParserMatchClass = Imm0_15Operand;
 648 }
 649 def vecshiftL32 : Operand<i32>, ImmLeaf<i32, [{
 650   return (((uint32_t)Imm) < 32);
 651 }]> {
 652   let EncoderMethod = "getVecShiftL32OpValue";
 653   let DecoderMethod = "DecodeVecShiftL32Imm";
 654   let ParserMatchClass = Imm0_31Operand;
 655 }
 656 def vecshiftL64 : Operand<i32>, ImmLeaf<i32, [{
 657   return (((uint32_t)Imm) < 64);
 658 }]> {
 659   let EncoderMethod = "getVecShiftL64OpValue";
 660   let DecoderMethod = "DecodeVecShiftL64Imm";
 661   let ParserMatchClass = Imm0_63Operand;
 662 }
 663
 664
 665 // Crazy immediate formats used by 32-bit and 64-bit logical immediate
 666 // instructions for splatting repeating bit patterns across the immediate.
 667 def logical_imm32_XFORM : SDNodeXForm<imm, [{
 668   uint64_t enc = AArch64_AM::encodeLogicalImmediate(N->getZExtValue(), 32);
 669   return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
 670 }]>;
 671 def logical_imm64_XFORM : SDNodeXForm<imm, [{
 672   uint64_t enc = AArch64_AM::encodeLogicalImmediate(N->getZExtValue(), 64);
 673   return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
 674 }]>;
 675
 676 let DiagnosticType = "LogicalSecondSource" in {
 677   def LogicalImm32Operand : AsmOperandClass {
 678     let Name = "LogicalImm32";
 679     let PredicateMethod = "isLogicalImm<int32_t>";
 680     let RenderMethod = "addLogicalImmOperands<int32_t>";
 681   }
 682   def LogicalImm64Operand : AsmOperandClass {
 683     let Name = "LogicalImm64";
 684     let PredicateMethod = "isLogicalImm<int64_t>";
 685     let RenderMethod = "addLogicalImmOperands<int64_t>";
 686   }
 687   def LogicalImm32NotOperand : AsmOperandClass {
 688     let Name = "LogicalImm32Not";
 689     let PredicateMethod = "isLogicalImm<int32_t>";
 690     let RenderMethod = "addLogicalImmNotOperands<int32_t>";
 691   }
 692   def LogicalImm64NotOperand : AsmOperandClass {
 693     let Name = "LogicalImm64Not";
 694     let PredicateMethod = "isLogicalImm<int64_t>";
 695     let RenderMethod = "addLogicalImmNotOperands<int64_t>";
 696   }
 697 }
 698 def logical_imm32 : Operand<i32>, IntImmLeaf<i32, [{
 699   return AArch64_AM::isLogicalImmediate(Imm.getZExtValue(), 32);
 700 }], logical_imm32_XFORM> {
 701   let PrintMethod = "printLogicalImm<int32_t>";
 702   let ParserMatchClass = LogicalImm32Operand;
 703 }
 704 def logical_imm64 : Operand<i64>, IntImmLeaf<i64, [{
 705   return AArch64_AM::isLogicalImmediate(Imm.getZExtValue(), 64);
 706 }], logical_imm64_XFORM> {
 707   let PrintMethod = "printLogicalImm<int64_t>";
 708   let ParserMatchClass = LogicalImm64Operand;
 709 }
 710 def logical_imm32_not : Operand<i32> {
 711   let ParserMatchClass = LogicalImm32NotOperand;
 712 }
 713 def logical_imm64_not : Operand<i64> {
 714   let ParserMatchClass = LogicalImm64NotOperand;
 715 }
 716
 717 // imm0_65535 predicate - True if the immediate is in the range [0,65535].
 718 def imm0_65535 : Operand<i32>, ImmLeaf<i32, [{
 719   return ((uint32_t)Imm) < 65536;
 720 }]> {
 721   let ParserMatchClass = AsmImmRange<0, 65535>;
 722   let PrintMethod = "printImmHex";
 723 }
 724
 725 // imm0_255 predicate - True if the immediate is in the range [0,255].
 726 def Imm0_255Operand : AsmImmRange<0,255>;
 727
 728 def imm0_255 : Operand<i32>, ImmLeaf<i32, [{
 729   return ((uint32_t)Imm) < 256;
 730 }]> {
 731   let ParserMatchClass = Imm0_255Operand;
 732   let PrintMethod = "printImm";
 733 }
 734
 735 // imm0_127 predicate - True if the immediate is in the range [0,127]
 736 def Imm0_127Operand : AsmImmRange<0, 127>;
 737 def imm0_127 : Operand<i32>, ImmLeaf<i32, [{
 738   return ((uint32_t)Imm) < 128;
 739 }]> {
 740   let ParserMatchClass = Imm0_127Operand;
 741   let PrintMethod = "printImm";
 742 }
 743
 744 // NOTE: These imm0_N operands have to be of type i64 because i64 is the size
 745 // for all shift-amounts.
 746
 747 // imm0_63 predicate - True if the immediate is in the range [0,63]
 748 def imm0_63 : Operand<i64>, ImmLeaf<i64, [{
 749   return ((uint64_t)Imm) < 64;
 750 }]> {
 751   let ParserMatchClass = Imm0_63Operand;
 752 }
 753
 754 // imm0_31 predicate - True if the immediate is in the range [0,31]
 755 def imm0_31 : Operand<i64>, ImmLeaf<i64, [{
 756   return ((uint64_t)Imm) < 32;
 757 }]> {
 758   let ParserMatchClass = Imm0_31Operand;
 759 }
 760
 761 // True if the 32-bit immediate is in the range [0,31]
 762 def imm32_0_31 : Operand<i32>, ImmLeaf<i32, [{
 763   return ((uint64_t)Imm) < 32;
 764 }]> {
 765   let ParserMatchClass = Imm0_31Operand;
 766 }
 767
 768 // imm0_1 predicate - True if the immediate is in the range [0,1]
 769 def imm0_1 : Operand<i64>, ImmLeaf<i64, [{
 770   return ((uint64_t)Imm) < 2;
 771 }]> {
 772   let ParserMatchClass = Imm0_1Operand;
 773 }
 774
 775 // imm0_15 predicate - True if the immediate is in the range [0,15]
 776 def imm0_15 : Operand<i64>, ImmLeaf<i64, [{
 777   return ((uint64_t)Imm) < 16;
 778 }]> {
 779   let ParserMatchClass = Imm0_15Operand;
 780 }
 781
 782 // imm0_7 predicate - True if the immediate is in the range [0,7]
 783 def imm0_7 : Operand<i64>, ImmLeaf<i64, [{
 784   return ((uint64_t)Imm) < 8;
 785 }]> {
 786   let ParserMatchClass = Imm0_7Operand;
 787 }
 788
 789 // imm32_0_15 predicate - True if the 32-bit immediate is in the range [0,15]
 790 def imm32_0_15 : Operand<i32>, ImmLeaf<i32, [{
 791   return ((uint32_t)Imm) < 16;
 792 }]> {
 793   let ParserMatchClass = Imm0_15Operand;
 794 }
 795
 796 // An arithmetic shifter operand:
 797 //  {7-6} - shift type: 00 = lsl, 01 = lsr, 10 = asr
 798 //  {5-0} - imm6
 799 class arith_shift<ValueType Ty, int width> : Operand<Ty> {
 800   let PrintMethod = "printShifter";
 801   let ParserMatchClass = !cast<AsmOperandClass>(
 802                          "ArithmeticShifterOperand" # width);
 803 }
 804
 805 def arith_shift32 : arith_shift<i32, 32>;
 806 def arith_shift64 : arith_shift<i64, 64>;
 807
 808 class arith_shifted_reg<ValueType Ty, RegisterClass regclass, int width>
 809     : Operand<Ty>,
 810       ComplexPattern<Ty, 2, "SelectArithShiftedRegister", []> {
 811   let PrintMethod = "printShiftedRegister";
 812   let MIOperandInfo = (ops regclass, !cast<Operand>("arith_shift" # width));
 813 }
 814
 815 def arith_shifted_reg32 : arith_shifted_reg<i32, GPR32, 32>;
 816 def arith_shifted_reg64 : arith_shifted_reg<i64, GPR64, 64>;
 817
 818 // An arithmetic shifter operand:
 819 //  {7-6} - shift type: 00 = lsl, 01 = lsr, 10 = asr, 11 = ror
 820 //  {5-0} - imm6
 821 class logical_shift<int width> : Operand<i32> {
 822   let PrintMethod = "printShifter";
 823   let ParserMatchClass = !cast<AsmOperandClass>(
 824                          "LogicalShifterOperand" # width);
 825 }
 826
 827 def logical_shift32 : logical_shift<32>;
 828 def logical_shift64 : logical_shift<64>;
 829
 830 class logical_shifted_reg<ValueType Ty, RegisterClass regclass, Operand shiftop>
 831     : Operand<Ty>,
 832       ComplexPattern<Ty, 2, "SelectLogicalShiftedRegister", []> {
 833   let PrintMethod = "printShiftedRegister";
 834   let MIOperandInfo = (ops regclass, shiftop);
 835 }
 836
 837 def logical_shifted_reg32 : logical_shifted_reg<i32, GPR32, logical_shift32>;
 838 def logical_shifted_reg64 : logical_shifted_reg<i64, GPR64, logical_shift64>;
 839
 840 // A logical vector shifter operand:
 841 //  {7-6} - shift type: 00 = lsl
 842 //  {5-0} - imm6: #0, #8, #16, or #24
 843 def logical_vec_shift : Operand<i32> {
 844   let PrintMethod = "printShifter";
 845   let EncoderMethod = "getVecShifterOpValue";
 846   let ParserMatchClass = LogicalVecShifterOperand;
 847 }
 848
 849 // A logical vector half-word shifter operand:
 850 //  {7-6} - shift type: 00 = lsl
 851 //  {5-0} - imm6: #0 or #8
 852 def logical_vec_hw_shift : Operand<i32> {
 853   let PrintMethod = "printShifter";
 854   let EncoderMethod = "getVecShifterOpValue";
 855   let ParserMatchClass = LogicalVecHalfWordShifterOperand;
 856 }
 857
 858 // A vector move shifter operand:
 859 //  {0} - imm1: #8 or #16
 860 def move_vec_shift : Operand<i32> {
 861   let PrintMethod = "printShifter";
 862   let EncoderMethod = "getMoveVecShifterOpValue";
 863   let ParserMatchClass = MoveVecShifterOperand;
 864 }
 865
 866 let DiagnosticType = "AddSubSecondSource" in {
 867   def AddSubImmOperand : AsmOperandClass {
 868     let Name = "AddSubImm";
 869     let ParserMethod = "tryParseImmWithOptionalShift";
 870     let RenderMethod = "addImmWithOptionalShiftOperands<12>";
 871   }
 872   def AddSubImmNegOperand : AsmOperandClass {
 873     let Name = "AddSubImmNeg";
 874     let ParserMethod = "tryParseImmWithOptionalShift";
 875     let RenderMethod = "addImmNegWithOptionalShiftOperands<12>";
 876   }
 877 }
 878 // An ADD/SUB immediate shifter operand:
 879 //  second operand:
 880 //  {7-6} - shift type: 00 = lsl
 881 //  {5-0} - imm6: #0 or #12
 882 class addsub_shifted_imm<ValueType Ty>
 883     : Operand<Ty>, ComplexPattern<Ty, 2, "SelectArithImmed", [imm]> {
 884   let PrintMethod = "printAddSubImm";
 885   let EncoderMethod = "getAddSubImmOpValue";
 886   let ParserMatchClass = AddSubImmOperand;
 887   let MIOperandInfo = (ops i32imm, i32imm);
 888 }
 889
 890 class addsub_shifted_imm_neg<ValueType Ty>
 891     : Operand<Ty> {
 892   let EncoderMethod = "getAddSubImmOpValue";
 893   let ParserMatchClass = AddSubImmNegOperand;
 894   let MIOperandInfo = (ops i32imm, i32imm);
 895 }
 896
 897 def addsub_shifted_imm32 : addsub_shifted_imm<i32>;
 898 def addsub_shifted_imm64 : addsub_shifted_imm<i64>;
 899 def addsub_shifted_imm32_neg : addsub_shifted_imm_neg<i32>;
 900 def addsub_shifted_imm64_neg : addsub_shifted_imm_neg<i64>;
 901
 902 def gi_addsub_shifted_imm32 :
 903     GIComplexOperandMatcher<s32, "selectArithImmed">,
 904     GIComplexPatternEquiv<addsub_shifted_imm32>;
 905
 906 def gi_addsub_shifted_imm64 :
 907     GIComplexOperandMatcher<s64, "selectArithImmed">,
 908     GIComplexPatternEquiv<addsub_shifted_imm64>;
 909
 910 class neg_addsub_shifted_imm<ValueType Ty>
 911     : Operand<Ty>, ComplexPattern<Ty, 2, "SelectNegArithImmed", [imm]> {
 912   let PrintMethod = "printAddSubImm";
 913   let EncoderMethod = "getAddSubImmOpValue";
 914   let ParserMatchClass = AddSubImmOperand;
 915   let MIOperandInfo = (ops i32imm, i32imm);
 916 }
 917
 918 def neg_addsub_shifted_imm32 : neg_addsub_shifted_imm<i32>;
 919 def neg_addsub_shifted_imm64 : neg_addsub_shifted_imm<i64>;
 920
 921 // An extend operand:
 922 //  {5-3} - extend type
 923 //  {2-0} - imm3
 924 def arith_extend : Operand<i32> {
 925   let PrintMethod = "printArithExtend";
 926   let ParserMatchClass = ExtendOperand;
 927 }
 928 def arith_extend64 : Operand<i32> {
 929   let PrintMethod = "printArithExtend";
 930   let ParserMatchClass = ExtendOperand64;
 931 }
 932
 933 // 'extend' that's a lsl of a 64-bit register.
 934 def arith_extendlsl64 : Operand<i32> {
 935   let PrintMethod = "printArithExtend";
 936   let ParserMatchClass = ExtendOperandLSL64;
 937 }
 938
 939 class arith_extended_reg32<ValueType Ty> : Operand<Ty>,
 940                     ComplexPattern<Ty, 2, "SelectArithExtendedRegister", []> {
 941   let PrintMethod = "printExtendedRegister";
 942   let MIOperandInfo = (ops GPR32, arith_extend);
 943 }
 944
 945 class arith_extended_reg32to64<ValueType Ty> : Operand<Ty>,
 946                     ComplexPattern<Ty, 2, "SelectArithExtendedRegister", []> {
 947   let PrintMethod = "printExtendedRegister";
 948   let MIOperandInfo = (ops GPR32, arith_extend64);
 949 }
 950
 951 // Floating-point immediate.
 952 def fpimm16 : Operand<f16>,
 953               FPImmLeaf<f16, [{
 954       return AArch64_AM::getFP16Imm(Imm) != -1;
 955     }], SDNodeXForm<fpimm, [{
 956       APFloat InVal = N->getValueAPF();
 957       uint32_t enc = AArch64_AM::getFP16Imm(InVal);
 958       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
 959     }]>> {
 960   let ParserMatchClass = FPImmOperand;
 961   let PrintMethod = "printFPImmOperand";
 962 }
 963 def fpimm32 : Operand<f32>,
 964               FPImmLeaf<f32, [{
 965       return AArch64_AM::getFP32Imm(Imm) != -1;
 966     }], SDNodeXForm<fpimm, [{
 967       APFloat InVal = N->getValueAPF();
 968       uint32_t enc = AArch64_AM::getFP32Imm(InVal);
 969       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
 970     }]>> {
 971   let ParserMatchClass = FPImmOperand;
 972   let PrintMethod = "printFPImmOperand";
 973 }
 974 def fpimm64 : Operand<f64>,
 975               FPImmLeaf<f64, [{
 976       return AArch64_AM::getFP64Imm(Imm) != -1;
 977     }], SDNodeXForm<fpimm, [{
 978       APFloat InVal = N->getValueAPF();
 979       uint32_t enc = AArch64_AM::getFP64Imm(InVal);
 980       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
 981     }]>> {
 982   let ParserMatchClass = FPImmOperand;
 983   let PrintMethod = "printFPImmOperand";
 984 }
 985
 986 def fpimm8 : Operand<i32> {
 987   let ParserMatchClass = FPImmOperand;
 988   let PrintMethod = "printFPImmOperand";
 989 }
 990
 991 def fpimm0 : FPImmLeaf<fAny, [{
 992   return Imm.isExactlyValue(+0.0);
 993 }]>;
 994
 995 // Vector lane operands
 996 class AsmVectorIndex<int Min, int Max, string NamePrefix=""> : AsmOperandClass {
 997   let Name = NamePrefix # "IndexRange" # Min # "_" # Max;
 998   let DiagnosticType = "Invalid" # Name;
 999   let PredicateMethod = "isVectorIndex<" # Min # ", " # Max #  ">";
1000   let RenderMethod = "addVectorIndexOperands";
1001 }
1002
1003 class AsmVectorIndexOpnd<AsmOperandClass mc, code pred>
1004     : Operand<i64>, ImmLeaf<i64, pred> {
1005   let ParserMatchClass = mc;
1006   let PrintMethod = "printVectorIndex";
1007 }
1008
1009 def VectorIndex1Operand : AsmVectorIndex<1, 1>;
1010 def VectorIndexBOperand : AsmVectorIndex<0, 15>;
1011 def VectorIndexHOperand : AsmVectorIndex<0, 7>;
1012 def VectorIndexSOperand : AsmVectorIndex<0, 3>;
1013 def VectorIndexDOperand : AsmVectorIndex<0, 1>;
1014
1015 def VectorIndex1 : AsmVectorIndexOpnd<VectorIndex1Operand, [{ return ((uint64_t)Imm) == 1; }]>;
1016 def VectorIndexB : AsmVectorIndexOpnd<VectorIndexBOperand, [{ return ((uint64_t)Imm) < 16; }]>;
1017 def VectorIndexH : AsmVectorIndexOpnd<VectorIndexHOperand, [{ return ((uint64_t)Imm) < 8; }]>;
1018 def VectorIndexS : AsmVectorIndexOpnd<VectorIndexSOperand, [{ return ((uint64_t)Imm) < 4; }]>;
1019 def VectorIndexD : AsmVectorIndexOpnd<VectorIndexDOperand, [{ return ((uint64_t)Imm) < 2; }]>;
1020
1021 def SVEVectorIndexExtDupBOperand : AsmVectorIndex<0, 63, "SVE">;
1022 def SVEVectorIndexExtDupHOperand : AsmVectorIndex<0, 31, "SVE">;
1023 def SVEVectorIndexExtDupSOperand : AsmVectorIndex<0, 15, "SVE">;
1024 def SVEVectorIndexExtDupDOperand : AsmVectorIndex<0, 7, "SVE">;
1025 def SVEVectorIndexExtDupQOperand : AsmVectorIndex<0, 3, "SVE">;
1026
1027 def sve_elm_idx_extdup_b
1028   : AsmVectorIndexOpnd<SVEVectorIndexExtDupBOperand, [{ return ((uint64_t)Imm) < 64; }]>;
1029 def sve_elm_idx_extdup_h
1030   : AsmVectorIndexOpnd<SVEVectorIndexExtDupHOperand, [{ return ((uint64_t)Imm) < 32; }]>;
1031 def sve_elm_idx_extdup_s
1032   : AsmVectorIndexOpnd<SVEVectorIndexExtDupSOperand, [{ return ((uint64_t)Imm) < 16; }]>;
1033 def sve_elm_idx_extdup_d
1034   : AsmVectorIndexOpnd<SVEVectorIndexExtDupDOperand, [{ return ((uint64_t)Imm) < 8; }]>;
1035 def sve_elm_idx_extdup_q
1036   : AsmVectorIndexOpnd<SVEVectorIndexExtDupQOperand, [{ return ((uint64_t)Imm) < 4; }]>;
1037
1038 // 8-bit immediate for AdvSIMD where 64-bit values of the form:
1039 // aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh
1040 // are encoded as the eight bit value 'abcdefgh'.
1041 def simdimmtype10 : Operand<i32>,
1042                     FPImmLeaf<f64, [{
1043       return AArch64_AM::isAdvSIMDModImmType10(
1044                  Imm.bitcastToAPInt().getZExtValue());
1045     }], SDNodeXForm<fpimm, [{
1046       APFloat InVal = N->getValueAPF();
1047       uint32_t enc = AArch64_AM::encodeAdvSIMDModImmType10(N->getValueAPF()
1048                                                            .bitcastToAPInt()
1049                                                            .getZExtValue());
1050       return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
1051     }]>> {
1052   let ParserMatchClass = SIMDImmType10Operand;
1053   let PrintMethod = "printSIMDType10Operand";
1054 }
1055
1056
1057 //---
1058 // System management
1059 //---
1060
1061 // Base encoding for system instruction operands.
1062 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
1063 class BaseSystemI<bit L, dag oops, dag iops, string asm, string operands,
1064                   list<dag> pattern = []>
1065     : I<oops, iops, asm, operands, "", pattern> {
1066   let Inst{31-22} = 0b1101010100;
1067   let Inst{21}    = L;
1068 }
1069
1070 // System instructions which do not have an Rt register.
1071 class SimpleSystemI<bit L, dag iops, string asm, string operands,
1072                     list<dag> pattern = []>
1073     : BaseSystemI<L, (outs), iops, asm, operands, pattern> {
1074   let Inst{4-0} = 0b11111;
1075 }
1076
1077 // System instructions which have an Rt register.
1078 class RtSystemI<bit L, dag oops, dag iops, string asm, string operands>
1079     : BaseSystemI<L, oops, iops, asm, operands>,
1080       Sched<[WriteSys]> {
1081   bits<5> Rt;
1082   let Inst{4-0} = Rt;
1083 }
1084
1085 // Hint instructions that take both a CRm and a 3-bit immediate.
1086 // NOTE: ideally, this would have mayStore = 0, mayLoad = 0, but we cannot
1087 // model patterns with sufficiently fine granularity
1088 let mayStore = 1, mayLoad = 1, hasSideEffects = 1 in
1089   class HintI<string mnemonic>
1090       : SimpleSystemI<0, (ins imm0_127:$imm), mnemonic#"\t$imm", "",
1091                       [(int_aarch64_hint imm0_127:$imm)]>,
1092         Sched<[WriteHint]> {
1093     bits <7> imm;
1094     let Inst{20-12} = 0b000110010;
1095     let Inst{11-5} = imm;
1096   }
1097
1098 // System instructions taking a single literal operand which encodes into
1099 // CRm. op2 differentiates the opcodes.
1100 def BarrierAsmOperand : AsmOperandClass {
1101   let Name = "Barrier";
1102   let ParserMethod = "tryParseBarrierOperand";
1103 }
1104 def barrier_op : Operand<i32> {
1105   let PrintMethod = "printBarrierOption";
1106   let ParserMatchClass = BarrierAsmOperand;
1107 }
1108 class CRmSystemI<Operand crmtype, bits<3> opc, string asm,
1109                  list<dag> pattern = []>
1110     : SimpleSystemI<0, (ins crmtype:$CRm), asm, "\t$CRm", pattern>,
1111       Sched<[WriteBarrier]> {
1112   bits<4> CRm;
1113   let Inst{20-12} = 0b000110011;
1114   let Inst{11-8} = CRm;
1115   let Inst{7-5} = opc;
1116 }
1117
1118 class SystemNoOperands<bits<3> op2, string asm, list<dag> pattern = []>
1119     : SimpleSystemI<0, (ins), asm, "", pattern>,
1120       Sched<[]> {
1121   bits<4> CRm;
1122   let CRm = 0b0011;
1123   let Inst{31-12} = 0b11010101000000110010;
1124   let Inst{11-8} = CRm;
1125   let Inst{7-5} = op2;
1126   let Inst{4-0} = 0b11111;
1127 }
1128
1129 // MRS/MSR system instructions. These have different operand classes because
1130 // a different subset of registers can be accessed through each instruction.
1131 def MRSSystemRegisterOperand : AsmOperandClass {
1132   let Name = "MRSSystemRegister";
1133   let ParserMethod = "tryParseSysReg";
1134   let DiagnosticType = "MRS";
1135 }
1136 // concatenation of op0, op1, CRn, CRm, op2. 16-bit immediate.
1137 def mrs_sysreg_op : Operand<i32> {
1138   let ParserMatchClass = MRSSystemRegisterOperand;
1139   let DecoderMethod = "DecodeMRSSystemRegister";
1140   let PrintMethod = "printMRSSystemRegister";
1141 }
1142
1143 def MSRSystemRegisterOperand : AsmOperandClass {
1144   let Name = "MSRSystemRegister";
1145   let ParserMethod = "tryParseSysReg";
1146   let DiagnosticType = "MSR";
1147 }
1148 def msr_sysreg_op : Operand<i32> {
1149   let ParserMatchClass = MSRSystemRegisterOperand;
1150   let DecoderMethod = "DecodeMSRSystemRegister";
1151   let PrintMethod = "printMSRSystemRegister";
1152 }
1153
1154 def PSBHintOperand : AsmOperandClass {
1155   let Name = "PSBHint";
1156   let ParserMethod = "tryParsePSBHint";
1157 }
1158 def psbhint_op : Operand<i32> {
1159   let ParserMatchClass = PSBHintOperand;
1160   let PrintMethod = "printPSBHintOp";
1161   let MCOperandPredicate = [{
1162     // Check, if operand is valid, to fix exhaustive aliasing in disassembly.
1163     // "psb" is an alias to "hint" only for certain values of CRm:Op2 fields.
1164     if (!MCOp.isImm())
1165       return false;
1166     return AArch64PSBHint::lookupPSBByEncoding(MCOp.getImm()) != nullptr;
1167   }];
1168 }
1169
1170 def BTIHintOperand : AsmOperandClass {
1171   let Name = "BTIHint";
1172   let ParserMethod = "tryParseBTIHint";
1173 }
1174 def btihint_op : Operand<i32> {
1175   let ParserMatchClass = BTIHintOperand;
1176   let PrintMethod = "printBTIHintOp";
1177   let MCOperandPredicate = [{
1178     // "bti" is an alias to "hint" only for certain values of CRm:Op2 fields.
1179     if (!MCOp.isImm())
1180       return false;
1181     return AArch64BTIHint::lookupBTIByEncoding((MCOp.getImm() ^ 32) >> 1) != nullptr;
1182   }];
1183 }
1184
1185 class MRSI : RtSystemI<1, (outs GPR64:$Rt), (ins mrs_sysreg_op:$systemreg),
1186                        "mrs", "\t$Rt, $systemreg"> {
1187   bits<16> systemreg;
1188   let Inst{20-5} = systemreg;
1189 }
1190
1191 // FIXME: Some of these def NZCV, others don't. Best way to model that?
1192 // Explicitly modeling each of the system register as a register class
1193 // would do it, but feels like overkill at this point.
1194 class MSRI : RtSystemI<0, (outs), (ins msr_sysreg_op:$systemreg, GPR64:$Rt),
1195                        "msr", "\t$systemreg, $Rt"> {
1196   bits<16> systemreg;
1197   let Inst{20-5} = systemreg;
1198 }
1199
1200 def SystemPStateFieldWithImm0_15Operand : AsmOperandClass {
1201   let Name = "SystemPStateFieldWithImm0_15";
1202   let ParserMethod = "tryParseSysReg";
1203 }
1204 def pstatefield4_op : Operand<i32> {
1205   let ParserMatchClass = SystemPStateFieldWithImm0_15Operand;
1206   let PrintMethod = "printSystemPStateField";
1207 }
1208
1209 // Instructions to modify PSTATE, no input reg
1210 let Defs = [NZCV] in
1211 class PstateWriteSimple<dag iops, string asm, string operands>
1212   : SimpleSystemI<0, iops, asm, operands> {
1213
1214   let Inst{20-19} = 0b00;
1215   let Inst{15-12} = 0b0100;
1216 }
1217
1218 class MSRpstateImm0_15
1219   : PstateWriteSimple<(ins pstatefield4_op:$pstatefield, imm0_15:$imm), "msr",
1220                   "\t$pstatefield, $imm">,
1221     Sched<[WriteSys]> {
1222
1223   bits<6> pstatefield;
1224   bits<4> imm;
1225   let Inst{18-16} = pstatefield{5-3};
1226   let Inst{11-8} = imm;
1227   let Inst{7-5} = pstatefield{2-0};
1228
1229   let DecoderMethod = "DecodeSystemPStateInstruction";
1230   // MSRpstateI aliases with MSRI. When the MSRpstateI decoder method returns
1231   // Fail the decoder should attempt to decode the instruction as MSRI.
1232   let hasCompleteDecoder = 0;
1233 }
1234
1235 def SystemPStateFieldWithImm0_1Operand : AsmOperandClass {
1236   let Name = "SystemPStateFieldWithImm0_1";
1237   let ParserMethod = "tryParseSysReg";
1238 }
1239 def pstatefield1_op : Operand<i32> {
1240   let ParserMatchClass = SystemPStateFieldWithImm0_1Operand;
1241   let PrintMethod = "printSystemPStateField";
1242 }
1243
1244 class MSRpstateImm0_1
1245   : PstateWriteSimple<(ins pstatefield1_op:$pstatefield, imm0_1:$imm), "msr",
1246                  "\t$pstatefield, $imm">,
1247     Sched<[WriteSys]> {
1248
1249   bits<6> pstatefield;
1250   bit imm;
1251   let Inst{18-16} = pstatefield{5-3};
1252   let Inst{11-9} = 0b000;
1253   let Inst{8} = imm;
1254   let Inst{7-5} = pstatefield{2-0};
1255
1256   let DecoderMethod = "DecodeSystemPStateInstruction";
1257   // MSRpstateI aliases with MSRI. When the MSRpstateI decoder method returns
1258   // Fail the decoder should attempt to decode the instruction as MSRI.
1259   let hasCompleteDecoder = 0;
1260 }
1261
1262 // SYS and SYSL generic system instructions.
1263 def SysCRAsmOperand : AsmOperandClass {
1264   let Name = "SysCR";
1265   let ParserMethod = "tryParseSysCROperand";
1266 }
1267
1268 def sys_cr_op : Operand<i32> {
1269   let PrintMethod = "printSysCROperand";
1270   let ParserMatchClass = SysCRAsmOperand;
1271 }
1272
1273 class SystemXtI<bit L, string asm>
1274   : RtSystemI<L, (outs),
1275        (ins imm0_7:$op1, sys_cr_op:$Cn, sys_cr_op:$Cm, imm0_7:$op2, GPR64:$Rt),
1276        asm, "\t$op1, $Cn, $Cm, $op2, $Rt"> {
1277   bits<3> op1;
1278   bits<4> Cn;
1279   bits<4> Cm;
1280   bits<3> op2;
1281   let Inst{20-19} = 0b01;
1282   let Inst{18-16} = op1;
1283   let Inst{15-12} = Cn;
1284   let Inst{11-8}  = Cm;
1285   let Inst{7-5}   = op2;
1286 }
1287
1288 class SystemLXtI<bit L, string asm>
1289   : RtSystemI<L, (outs),
1290        (ins GPR64:$Rt, imm0_7:$op1, sys_cr_op:$Cn, sys_cr_op:$Cm, imm0_7:$op2),
1291        asm, "\t$Rt, $op1, $Cn, $Cm, $op2"> {
1292   bits<3> op1;
1293   bits<4> Cn;
1294   bits<4> Cm;
1295   bits<3> op2;
1296   let Inst{20-19} = 0b01;
1297   let Inst{18-16} = op1;
1298   let Inst{15-12} = Cn;
1299   let Inst{11-8}  = Cm;
1300   let Inst{7-5}   = op2;
1301 }
1302
1303
1304 // Branch (register) instructions:
1305 //
1306 //  case opc of
1307 //    0001 blr
1308 //    0000 br
1309 //    0101 dret
1310 //    0100 eret
1311 //    0010 ret
1312 //    otherwise UNDEFINED
1313 class BaseBranchReg<bits<4> opc, dag oops, dag iops, string asm,
1314                     string operands, list<dag> pattern>
1315     : I<oops, iops, asm, operands, "", pattern>, Sched<[WriteBrReg]> {
1316   let Inst{31-25} = 0b1101011;
1317   let Inst{24-21} = opc;
1318   let Inst{20-16} = 0b11111;
1319   let Inst{15-10} = 0b000000;
1320   let Inst{4-0}   = 0b00000;
1321 }
1322
1323 class BranchReg<bits<4> opc, string asm, list<dag> pattern>
1324     : BaseBranchReg<opc, (outs), (ins GPR64:$Rn), asm, "\t$Rn", pattern> {
1325   bits<5> Rn;
1326   let Inst{9-5} = Rn;
1327 }
1328
1329 let mayLoad = 0, mayStore = 0, hasSideEffects = 1, isReturn = 1 in
1330 class SpecialReturn<bits<4> opc, string asm>
1331     : BaseBranchReg<opc, (outs), (ins), asm, "", []> {
1332   let Inst{9-5} = 0b11111;
1333 }
1334
1335 let mayLoad = 1 in
1336 class RCPCLoad<bits<2> sz, string asm, RegisterClass RC>
1337   : I<(outs RC:$Rt), (ins GPR64sp0:$Rn), asm, "\t$Rt, [$Rn]", "", []>,
1338   Sched<[]> {
1339   bits<5> Rn;
1340   bits<5> Rt;
1341   let Inst{31-30} = sz;
1342   let Inst{29-10} = 0b11100010111111110000;
1343   let Inst{9-5} = Rn;
1344   let Inst{4-0} = Rt;
1345 }
1346
1347 class AuthBase<bits<1> M, dag oops, dag iops, string asm, string operands,
1348                list<dag> pattern>
1349   : I<oops, iops, asm, operands, "", pattern>, Sched<[]> {
1350   let Inst{31-25} = 0b1101011;
1351   let Inst{20-11} = 0b1111100001;
1352   let Inst{10} = M;
1353   let Inst{4-0} = 0b11111;
1354 }
1355
1356 class AuthBranchTwoOperands<bits<1> op, bits<1> M, string asm>
1357   : AuthBase<M, (outs), (ins GPR64:$Rn, GPR64sp:$Rm), asm, "\t$Rn, $Rm", []> {
1358   bits<5> Rn;
1359   bits<5> Rm;
1360   let Inst{24-22} = 0b100;
1361   let Inst{21} = op;
1362   let Inst{9-5} = Rn;
1363   let Inst{4-0} = Rm;
1364 }
1365
1366 class AuthOneOperand<bits<3> opc, bits<1> M, string asm>
1367   : AuthBase<M, (outs), (ins GPR64:$Rn), asm, "\t$Rn", []> {
1368   bits<5> Rn;
1369   let Inst{24} = 0;
1370   let Inst{23-21} = opc;
1371   let Inst{9-5} = Rn;
1372 }
1373
1374 class AuthReturn<bits<3> op, bits<1> M, string asm>
1375   : AuthBase<M, (outs), (ins), asm, "", []> {
1376   let Inst{24} = 0;
1377   let Inst{23-21} = op;
1378   let Inst{9-0} = 0b1111111111;
1379 }
1380
1381 let mayLoad = 1 in
1382 class BaseAuthLoad<bit M, bit W, dag oops, dag iops, string asm,
1383                    string operands, string cstr, Operand opr>
1384   : I<oops, iops, asm, operands, cstr, []>, Sched<[]> {
1385   bits<10> offset;
1386   bits<5> Rn;
1387   bits<5> Rt;
1388   let Inst{31-24} = 0b11111000;
1389   let Inst{23} = M;
1390   let Inst{22} = offset{9};
1391   let Inst{21} = 1;
1392   let Inst{20-12} = offset{8-0};
1393   let Inst{11} = W;
1394   let Inst{10} = 1;
1395   let Inst{9-5} = Rn;
1396   let Inst{4-0} = Rt;
1397 }
1398
1399 multiclass AuthLoad<bit M, string asm, Operand opr> {
1400   def indexed   : BaseAuthLoad<M, 0, (outs GPR64:$Rt),
1401                                (ins GPR64sp:$Rn, opr:$offset),
1402                                asm, "\t$Rt, [$Rn, $offset]", "", opr>;
1403   def writeback : BaseAuthLoad<M, 1, (outs GPR64sp:$wback, GPR64:$Rt),
1404                                (ins GPR64sp:$Rn, opr:$offset),
1405                                asm, "\t$Rt, [$Rn, $offset]!",
1406                                "$Rn = $wback,@earlyclobber $wback", opr>;
1407
1408   def : InstAlias<asm # "\t$Rt, [$Rn]",
1409                   (!cast<Instruction>(NAME # "indexed") GPR64:$Rt, GPR64sp:$Rn, 0)>;
1410 }
1411
1412 //---
1413 // Conditional branch instruction.
1414 //---
1415
1416 // Condition code.
1417 // 4-bit immediate. Pretty-printed as <cc>
1418 def ccode : Operand<i32> {
1419   let PrintMethod = "printCondCode";
1420   let ParserMatchClass = CondCode;
1421 }
1422 def inv_ccode : Operand<i32> {
1423   // AL and NV are invalid in the aliases which use inv_ccode
1424   let PrintMethod = "printInverseCondCode";
1425   let ParserMatchClass = CondCode;
1426   let MCOperandPredicate = [{
1427     return MCOp.isImm() &&
1428            MCOp.getImm() != AArch64CC::AL &&
1429            MCOp.getImm() != AArch64CC::NV;
1430   }];
1431 }
1432
1433 // Conditional branch target. 19-bit immediate. The low two bits of the target
1434 // offset are implied zero and so are not part of the immediate.
1435 def am_brcond : Operand<OtherVT> {
1436   let EncoderMethod = "getCondBranchTargetOpValue";
1437   let DecoderMethod = "DecodePCRelLabel19";
1438   let PrintMethod = "printAlignedLabel";
1439   let ParserMatchClass = PCRelLabel19Operand;
1440   let OperandType = "OPERAND_PCREL";
1441 }
1442
1443 class BranchCond : I<(outs), (ins ccode:$cond, am_brcond:$target),
1444                      "b", ".$cond\t$target", "",
1445                      [(AArch64brcond bb:$target, imm:$cond, NZCV)]>,
1446                    Sched<[WriteBr]> {
1447   let isBranch = 1;
1448   let isTerminator = 1;
1449   let Uses = [NZCV];
1450
1451   bits<4> cond;
1452   bits<19> target;
1453   let Inst{31-24} = 0b01010100;
1454   let Inst{23-5} = target;
1455   let Inst{4} = 0;
1456   let Inst{3-0} = cond;
1457 }
1458
1459 //---
1460 // Compare-and-branch instructions.
1461 //---
1462 class BaseCmpBranch<RegisterClass regtype, bit op, string asm, SDNode node>
1463     : I<(outs), (ins regtype:$Rt, am_brcond:$target),
1464          asm, "\t$Rt, $target", "",
1465          [(node regtype:$Rt, bb:$target)]>,
1466       Sched<[WriteBr]> {
1467   let isBranch = 1;
1468   let isTerminator = 1;
1469
1470   bits<5> Rt;
1471   bits<19> target;
1472   let Inst{30-25} = 0b011010;
1473   let Inst{24}    = op;
1474   let Inst{23-5}  = target;
1475   let Inst{4-0}   = Rt;
1476 }
1477
1478 multiclass CmpBranch<bit op, string asm, SDNode node> {
1479   def W : BaseCmpBranch<GPR32, op, asm, node> {
1480     let Inst{31} = 0;
1481   }
1482   def X : BaseCmpBranch<GPR64, op, asm, node> {
1483     let Inst{31} = 1;
1484   }
1485 }
1486
1487 //---
1488 // Test-bit-and-branch instructions.
1489 //---
1490 // Test-and-branch target. 14-bit sign-extended immediate. The low two bits of
1491 // the target offset are implied zero and so are not part of the immediate.
1492 def am_tbrcond : Operand<OtherVT> {
1493   let EncoderMethod = "getTestBranchTargetOpValue";
1494   let PrintMethod = "printAlignedLabel";
1495   let ParserMatchClass = BranchTarget14Operand;
1496   let OperandType = "OPERAND_PCREL";
1497 }
1498
1499 // AsmOperand classes to emit (or not) special diagnostics
1500 def TBZImm0_31Operand : AsmOperandClass {
1501   let Name = "TBZImm0_31";
1502   let PredicateMethod = "isImmInRange<0,31>";
1503   let RenderMethod = "addImmOperands";
1504 }
1505 def TBZImm32_63Operand : AsmOperandClass {
1506   let Name = "Imm32_63";
1507   let PredicateMethod = "isImmInRange<32,63>";
1508   let DiagnosticType = "InvalidImm0_63";
1509   let RenderMethod = "addImmOperands";
1510 }
1511
1512 class tbz_imm0_31<AsmOperandClass matcher> : Operand<i64>, ImmLeaf<i64, [{
1513   return (((uint32_t)Imm) < 32);
1514 }]> {
1515   let ParserMatchClass = matcher;
1516 }
1517
1518 def tbz_imm0_31_diag : tbz_imm0_31<Imm0_31Operand>;
1519 def tbz_imm0_31_nodiag : tbz_imm0_31<TBZImm0_31Operand>;
1520
1521 def tbz_imm32_63 : Operand<i64>, ImmLeaf<i64, [{
1522   return (((uint32_t)Imm) > 31) && (((uint32_t)Imm) < 64);
1523 }]> {
1524   let ParserMatchClass = TBZImm32_63Operand;
1525 }
1526
1527 class BaseTestBranch<RegisterClass regtype, Operand immtype,
1528                      bit op, string asm, SDNode node>
1529     : I<(outs), (ins regtype:$Rt, immtype:$bit_off, am_tbrcond:$target),
1530        asm, "\t$Rt, $bit_off, $target", "",
1531        [(node regtype:$Rt, immtype:$bit_off, bb:$target)]>,
1532       Sched<[WriteBr]> {
1533   let isBranch = 1;
1534   let isTerminator = 1;
1535
1536   bits<5> Rt;
1537   bits<6> bit_off;
1538   bits<14> target;
1539
1540   let Inst{30-25} = 0b011011;
1541   let Inst{24}    = op;
1542   let Inst{23-19} = bit_off{4-0};
1543   let Inst{18-5}  = target;
1544   let Inst{4-0}   = Rt;
1545
1546   let DecoderMethod = "DecodeTestAndBranch";
1547 }
1548
1549 multiclass TestBranch<bit op, string asm, SDNode node> {
1550   def W : BaseTestBranch<GPR32, tbz_imm0_31_diag, op, asm, node> {
1551     let Inst{31} = 0;
1552   }
1553
1554   def X : BaseTestBranch<GPR64, tbz_imm32_63, op, asm, node> {
1555     let Inst{31} = 1;
1556   }
1557
1558   // Alias X-reg with 0-31 imm to W-Reg.
1559   def : InstAlias<asm # "\t$Rd, $imm, $target",
1560                   (!cast<Instruction>(NAME#"W") GPR32as64:$Rd,
1561                   tbz_imm0_31_nodiag:$imm, am_tbrcond:$target), 0>;
1562   def : Pat<(node GPR64:$Rn, tbz_imm0_31_diag:$imm, bb:$target),
1563             (!cast<Instruction>(NAME#"W") (EXTRACT_SUBREG GPR64:$Rn, sub_32),
1564             tbz_imm0_31_diag:$imm, bb:$target)>;
1565 }
1566
1567 //---
1568 // Unconditional branch (immediate) instructions.
1569 //---
1570 def am_b_target : Operand<OtherVT> {
1571   let EncoderMethod = "getBranchTargetOpValue";
1572   let PrintMethod = "printAlignedLabel";
1573   let ParserMatchClass = BranchTarget26Operand;
1574   let OperandType = "OPERAND_PCREL";
1575 }
1576 def am_bl_target : Operand<i64> {
1577   let EncoderMethod = "getBranchTargetOpValue";
1578   let PrintMethod = "printAlignedLabel";
1579   let ParserMatchClass = BranchTarget26Operand;
1580   let OperandType = "OPERAND_PCREL";
1581 }
1582
1583 class BImm<bit op, dag iops, string asm, list<dag> pattern>
1584     : I<(outs), iops, asm, "\t$addr", "", pattern>, Sched<[WriteBr]> {
1585   bits<26> addr;
1586   let Inst{31}    = op;
1587   let Inst{30-26} = 0b00101;
1588   let Inst{25-0}  = addr;
1589
1590   let DecoderMethod = "DecodeUnconditionalBranch";
1591 }
1592
1593 class BranchImm<bit op, string asm, list<dag> pattern>
1594     : BImm<op, (ins am_b_target:$addr), asm, pattern>;
1595 class CallImm<bit op, string asm, list<dag> pattern>
1596     : BImm<op, (ins am_bl_target:$addr), asm, pattern>;
1597
1598 //---
1599 // Basic one-operand data processing instructions.
1600 //---
1601
1602 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1603 class BaseOneOperandData<bits<3> opc, RegisterClass regtype, string asm,
1604                          SDPatternOperator node>
1605   : I<(outs regtype:$Rd), (ins regtype:$Rn), asm, "\t$Rd, $Rn", "",
1606       [(set regtype:$Rd, (node regtype:$Rn))]>,
1607     Sched<[WriteI, ReadI]> {
1608   bits<5> Rd;
1609   bits<5> Rn;
1610
1611   let Inst{30-13} = 0b101101011000000000;
1612   let Inst{12-10} = opc;
1613   let Inst{9-5}   = Rn;
1614   let Inst{4-0}   = Rd;
1615 }
1616
1617 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1618 multiclass OneOperandData<bits<3> opc, string asm,
1619                           SDPatternOperator node = null_frag> {
1620   def Wr : BaseOneOperandData<opc, GPR32, asm, node> {
1621     let Inst{31} = 0;
1622   }
1623
1624   def Xr : BaseOneOperandData<opc, GPR64, asm, node> {
1625     let Inst{31} = 1;
1626   }
1627 }
1628
1629 class OneWRegData<bits<3> opc, string asm, SDPatternOperator node>
1630     : BaseOneOperandData<opc, GPR32, asm, node> {
1631   let Inst{31} = 0;
1632 }
1633
1634 class OneXRegData<bits<3> opc, string asm, SDPatternOperator node>
1635     : BaseOneOperandData<opc, GPR64, asm, node> {
1636   let Inst{31} = 1;
1637 }
1638
1639 class SignAuthOneData<bits<3> opcode_prefix, bits<2> opcode, string asm>
1640   : I<(outs GPR64:$Rd), (ins GPR64sp:$Rn), asm, "\t$Rd, $Rn", "",
1641       []>,
1642     Sched<[WriteI, ReadI]> {
1643   bits<5> Rd;
1644   bits<5> Rn;
1645   let Inst{31-15} = 0b11011010110000010;
1646   let Inst{14-12} = opcode_prefix;
1647   let Inst{11-10} = opcode;
1648   let Inst{9-5} = Rn;
1649   let Inst{4-0} = Rd;
1650 }
1651
1652 class SignAuthZero<bits<3> opcode_prefix, bits<2> opcode, string asm>
1653   : I<(outs GPR64:$Rd), (ins), asm, "\t$Rd", "", []>, Sched<[]> {
1654   bits<5> Rd;
1655   let Inst{31-15} = 0b11011010110000010;
1656   let Inst{14-12} = opcode_prefix;
1657   let Inst{11-10} = opcode;
1658   let Inst{9-5} = 0b11111;
1659   let Inst{4-0} = Rd;
1660 }
1661
1662 class SignAuthTwoOperand<bits<4> opc, string asm,
1663                          SDPatternOperator OpNode>
1664   : I<(outs GPR64:$Rd), (ins GPR64:$Rn, GPR64sp:$Rm),
1665       asm, "\t$Rd, $Rn, $Rm", "",
1666       [(set GPR64:$Rd, (OpNode GPR64:$Rn, GPR64sp:$Rm))]>,
1667     Sched<[WriteI, ReadI, ReadI]> {
1668   bits<5> Rd;
1669   bits<5> Rn;
1670   bits<5> Rm;
1671   let Inst{31-21} = 0b10011010110;
1672   let Inst{20-16} = Rm;
1673   let Inst{15-14} = 0b00;
1674   let Inst{13-10} = opc;
1675   let Inst{9-5}   = Rn;
1676   let Inst{4-0}   = Rd;
1677 }
1678
1679 // Base class for the Armv8.4-A 8 and 16-bit flag manipulation instructions
1680 class BaseFlagManipulation<bit sf, bit sz, dag iops, string asm, string ops>
1681     : I<(outs), iops, asm, ops, "", []>,
1682       Sched<[WriteI, ReadI, ReadI]> {
1683   let Uses = [NZCV];
1684   bits<5> Rn;
1685   let Inst{31}    = sf;
1686   let Inst{30-15} = 0b0111010000000000;
1687   let Inst{14}    = sz;
1688   let Inst{13-10} = 0b0010;
1689   let Inst{9-5}   = Rn;
1690   let Inst{4-0}   = 0b01101;
1691 }
1692
1693 class FlagRotate<dag iops, string asm, string ops>
1694     : BaseFlagManipulation<0b1, 0b0, iops, asm, ops> {
1695   bits<6> imm;
1696   bits<4> mask;
1697   let Inst{20-15} = imm;
1698   let Inst{13-10} = 0b0001;
1699   let Inst{4}     = 0b0;
1700   let Inst{3-0}   = mask;
1701 }
1702
1703 //---
1704 // Basic two-operand data processing instructions.
1705 //---
1706 class BaseBaseAddSubCarry<bit isSub, RegisterClass regtype, string asm,
1707                           list<dag> pattern>
1708     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
1709         asm, "\t$Rd, $Rn, $Rm", "", pattern>,
1710       Sched<[WriteI, ReadI, ReadI]> {
1711   let Uses = [NZCV];
1712   bits<5> Rd;
1713   bits<5> Rn;
1714   bits<5> Rm;
1715   let Inst{30}    = isSub;
1716   let Inst{28-21} = 0b11010000;
1717   let Inst{20-16} = Rm;
1718   let Inst{15-10} = 0;
1719   let Inst{9-5}   = Rn;
1720   let Inst{4-0}   = Rd;
1721 }
1722
1723 class BaseAddSubCarry<bit isSub, RegisterClass regtype, string asm,
1724                       SDNode OpNode>
1725     : BaseBaseAddSubCarry<isSub, regtype, asm,
1726         [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm, NZCV))]>;
1727
1728 class BaseAddSubCarrySetFlags<bit isSub, RegisterClass regtype, string asm,
1729                               SDNode OpNode>
1730     : BaseBaseAddSubCarry<isSub, regtype, asm,
1731         [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm, NZCV)),
1732          (implicit NZCV)]> {
1733   let Defs = [NZCV];
1734 }
1735
1736 multiclass AddSubCarry<bit isSub, string asm, string asm_setflags,
1737                        SDNode OpNode, SDNode OpNode_setflags> {
1738   def Wr : BaseAddSubCarry<isSub, GPR32, asm, OpNode> {
1739     let Inst{31} = 0;
1740     let Inst{29} = 0;
1741   }
1742   def Xr : BaseAddSubCarry<isSub, GPR64, asm, OpNode> {
1743     let Inst{31} = 1;
1744     let Inst{29} = 0;
1745   }
1746
1747   // Sets flags.
1748   def SWr : BaseAddSubCarrySetFlags<isSub, GPR32, asm_setflags,
1749                                     OpNode_setflags> {
1750     let Inst{31} = 0;
1751     let Inst{29} = 1;
1752   }
1753   def SXr : BaseAddSubCarrySetFlags<isSub, GPR64, asm_setflags,
1754                                     OpNode_setflags> {
1755     let Inst{31} = 1;
1756     let Inst{29} = 1;
1757   }
1758 }
1759
1760 class BaseTwoOperand<bits<4> opc, RegisterClass regtype, string asm,
1761                      SDPatternOperator OpNode,
1762                      RegisterClass in1regtype = regtype,
1763                      RegisterClass in2regtype = regtype>
1764   : I<(outs regtype:$Rd), (ins in1regtype:$Rn, in2regtype:$Rm),
1765       asm, "\t$Rd, $Rn, $Rm", "",
1766       [(set regtype:$Rd, (OpNode in1regtype:$Rn, in2regtype:$Rm))]> {
1767   bits<5> Rd;
1768   bits<5> Rn;
1769   bits<5> Rm;
1770   let Inst{30-21} = 0b0011010110;
1771   let Inst{20-16} = Rm;
1772   let Inst{15-14} = 0b00;
1773   let Inst{13-10} = opc;
1774   let Inst{9-5}   = Rn;
1775   let Inst{4-0}   = Rd;
1776 }
1777
1778 class BaseDiv<bit isSigned, RegisterClass regtype, string asm,
1779               SDPatternOperator OpNode>
1780     : BaseTwoOperand<{0,0,1,?}, regtype, asm, OpNode> {
1781   let Inst{10}    = isSigned;
1782 }
1783
1784 multiclass Div<bit isSigned, string asm, SDPatternOperator OpNode> {
1785   def Wr : BaseDiv<isSigned, GPR32, asm, OpNode>,
1786            Sched<[WriteID32, ReadID, ReadID]> {
1787     let Inst{31} = 0;
1788   }
1789   def Xr : BaseDiv<isSigned, GPR64, asm, OpNode>,
1790            Sched<[WriteID64, ReadID, ReadID]> {
1791     let Inst{31} = 1;
1792   }
1793 }
1794
1795 class BaseShift<bits<2> shift_type, RegisterClass regtype, string asm,
1796                 SDPatternOperator OpNode = null_frag>
1797   : BaseTwoOperand<{1,0,?,?}, regtype, asm, OpNode>,
1798     Sched<[WriteIS, ReadI]> {
1799   let Inst{11-10} = shift_type;
1800 }
1801
1802 multiclass Shift<bits<2> shift_type, string asm, SDNode OpNode> {
1803   def Wr : BaseShift<shift_type, GPR32, asm> {
1804     let Inst{31} = 0;
1805   }
1806
1807   def Xr : BaseShift<shift_type, GPR64, asm, OpNode> {
1808     let Inst{31} = 1;
1809   }
1810
1811   def : Pat<(i32 (OpNode GPR32:$Rn, i64:$Rm)),
1812             (!cast<Instruction>(NAME # "Wr") GPR32:$Rn,
1813                                              (EXTRACT_SUBREG i64:$Rm, sub_32))>;
1814
1815   def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (zext GPR32:$Rm)))),
1816             (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1817
1818   def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (anyext GPR32:$Rm)))),
1819             (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1820
1821   def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (sext GPR32:$Rm)))),
1822             (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1823
1824   def : Pat<(i64 (OpNode GPR64:$Rn, (i64 (sext GPR32:$Rm)))),
1825             (!cast<Instruction>(NAME # "Xr") GPR64:$Rn,
1826                 (SUBREG_TO_REG (i32 0), GPR32:$Rm, sub_32))>;
1827
1828   def : Pat<(i64 (OpNode GPR64:$Rn, (i64 (zext GPR32:$Rm)))),
1829             (!cast<Instruction>(NAME # "Xr") GPR64:$Rn,
1830                 (SUBREG_TO_REG (i32 0), GPR32:$Rm, sub_32))>;
1831 }
1832
1833 class ShiftAlias<string asm, Instruction inst, RegisterClass regtype>
1834     : InstAlias<asm#"\t$dst, $src1, $src2",
1835                 (inst regtype:$dst, regtype:$src1, regtype:$src2), 0>;
1836
1837 class BaseMulAccum<bit isSub, bits<3> opc, RegisterClass multype,
1838                        RegisterClass addtype, string asm,
1839                        list<dag> pattern>
1840   : I<(outs addtype:$Rd), (ins multype:$Rn, multype:$Rm, addtype:$Ra),
1841       asm, "\t$Rd, $Rn, $Rm, $Ra", "", pattern> {
1842   bits<5> Rd;
1843   bits<5> Rn;
1844   bits<5> Rm;
1845   bits<5> Ra;
1846   let Inst{30-24} = 0b0011011;
1847   let Inst{23-21} = opc;
1848   let Inst{20-16} = Rm;
1849   let Inst{15}    = isSub;
1850   let Inst{14-10} = Ra;
1851   let Inst{9-5}   = Rn;
1852   let Inst{4-0}   = Rd;
1853 }
1854
1855 multiclass MulAccum<bit isSub, string asm, SDNode AccNode> {
1856   // MADD/MSUB generation is decided by MachineCombiner.cpp
1857   def Wrrr : BaseMulAccum<isSub, 0b000, GPR32, GPR32, asm,
1858       [/*(set GPR32:$Rd, (AccNode GPR32:$Ra, (mul GPR32:$Rn, GPR32:$Rm)))*/]>,
1859       Sched<[WriteIM32, ReadIM, ReadIM, ReadIMA]> {
1860     let Inst{31} = 0;
1861   }
1862
1863   def Xrrr : BaseMulAccum<isSub, 0b000, GPR64, GPR64, asm,
1864       [/*(set GPR64:$Rd, (AccNode GPR64:$Ra, (mul GPR64:$Rn, GPR64:$Rm)))*/]>,
1865       Sched<[WriteIM64, ReadIM, ReadIM, ReadIMA]> {
1866     let Inst{31} = 1;
1867   }
1868 }
1869
1870 class WideMulAccum<bit isSub, bits<3> opc, string asm,
1871                    SDNode AccNode, SDNode ExtNode>
1872   : BaseMulAccum<isSub, opc, GPR32, GPR64, asm,
1873     [(set GPR64:$Rd, (AccNode GPR64:$Ra,
1874                             (mul (ExtNode GPR32:$Rn), (ExtNode GPR32:$Rm))))]>,
1875     Sched<[WriteIM32, ReadIM, ReadIM, ReadIMA]> {
1876   let Inst{31} = 1;
1877 }
1878
1879 class MulHi<bits<3> opc, string asm, SDNode OpNode>
1880   : I<(outs GPR64:$Rd), (ins GPR64:$Rn, GPR64:$Rm),
1881       asm, "\t$Rd, $Rn, $Rm", "",
1882       [(set GPR64:$Rd, (OpNode GPR64:$Rn, GPR64:$Rm))]>,
1883     Sched<[WriteIM64, ReadIM, ReadIM]> {
1884   bits<5> Rd;
1885   bits<5> Rn;
1886   bits<5> Rm;
1887   let Inst{31-24} = 0b10011011;
1888   let Inst{23-21} = opc;
1889   let Inst{20-16} = Rm;
1890   let Inst{15}    = 0;
1891   let Inst{9-5}   = Rn;
1892   let Inst{4-0}   = Rd;
1893
1894   // The Ra field of SMULH and UMULH is unused: it should be assembled as 31
1895   // (i.e. all bits 1) but is ignored by the processor.
1896   let PostEncoderMethod = "fixMulHigh";
1897 }
1898
1899 class MulAccumWAlias<string asm, Instruction inst>
1900     : InstAlias<asm#"\t$dst, $src1, $src2",
1901                 (inst GPR32:$dst, GPR32:$src1, GPR32:$src2, WZR)>;
1902 class MulAccumXAlias<string asm, Instruction inst>
1903     : InstAlias<asm#"\t$dst, $src1, $src2",
1904                 (inst GPR64:$dst, GPR64:$src1, GPR64:$src2, XZR)>;
1905 class WideMulAccumAlias<string asm, Instruction inst>
1906     : InstAlias<asm#"\t$dst, $src1, $src2",
1907                 (inst GPR64:$dst, GPR32:$src1, GPR32:$src2, XZR)>;
1908
1909 class BaseCRC32<bit sf, bits<2> sz, bit C, RegisterClass StreamReg,
1910               SDPatternOperator OpNode, string asm>
1911   : I<(outs GPR32:$Rd), (ins GPR32:$Rn, StreamReg:$Rm),
1912       asm, "\t$Rd, $Rn, $Rm", "",
1913       [(set GPR32:$Rd, (OpNode GPR32:$Rn, StreamReg:$Rm))]>,
1914     Sched<[WriteISReg, ReadI, ReadISReg]> {
1915   bits<5> Rd;
1916   bits<5> Rn;
1917   bits<5> Rm;
1918
1919   let Inst{31} = sf;
1920   let Inst{30-21} = 0b0011010110;
1921   let Inst{20-16} = Rm;
1922   let Inst{15-13} = 0b010;
1923   let Inst{12} = C;
1924   let Inst{11-10} = sz;
1925   let Inst{9-5} = Rn;
1926   let Inst{4-0} = Rd;
1927   let Predicates = [HasCRC];
1928 }
1929
1930 //---
1931 // Address generation.
1932 //---
1933
1934 class ADRI<bit page, string asm, Operand adr, list<dag> pattern>
1935     : I<(outs GPR64:$Xd), (ins adr:$label), asm, "\t$Xd, $label", "",
1936         pattern>,
1937       Sched<[WriteI]> {
1938   bits<5>  Xd;
1939   bits<21> label;
1940   let Inst{31}    = page;
1941   let Inst{30-29} = label{1-0};
1942   let Inst{28-24} = 0b10000;
1943   let Inst{23-5}  = label{20-2};
1944   let Inst{4-0}   = Xd;
1945
1946   let DecoderMethod = "DecodeAdrInstruction";
1947 }
1948
1949 //---
1950 // Move immediate.
1951 //---
1952
1953 def movimm32_imm : Operand<i32> {
1954   let ParserMatchClass = AsmImmRange<0, 65535>;
1955   let EncoderMethod = "getMoveWideImmOpValue";
1956   let PrintMethod = "printImm";
1957 }
1958 def movimm32_shift : Operand<i32> {
1959   let PrintMethod = "printShifter";
1960   let ParserMatchClass = MovImm32ShifterOperand;
1961 }
1962 def movimm64_shift : Operand<i32> {
1963   let PrintMethod = "printShifter";
1964   let ParserMatchClass = MovImm64ShifterOperand;
1965 }
1966
1967 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1968 class BaseMoveImmediate<bits<2> opc, RegisterClass regtype, Operand shifter,
1969                         string asm>
1970   : I<(outs regtype:$Rd), (ins movimm32_imm:$imm, shifter:$shift),
1971        asm, "\t$Rd, $imm$shift", "", []>,
1972     Sched<[WriteImm]> {
1973   bits<5> Rd;
1974   bits<16> imm;
1975   bits<6> shift;
1976   let Inst{30-29} = opc;
1977   let Inst{28-23} = 0b100101;
1978   let Inst{22-21} = shift{5-4};
1979   let Inst{20-5}  = imm;
1980   let Inst{4-0}   = Rd;
1981
1982   let DecoderMethod = "DecodeMoveImmInstruction";
1983 }
1984
1985 multiclass MoveImmediate<bits<2> opc, string asm> {
1986   def Wi : BaseMoveImmediate<opc, GPR32, movimm32_shift, asm> {
1987     let Inst{31} = 0;
1988   }
1989
1990   def Xi : BaseMoveImmediate<opc, GPR64, movimm64_shift, asm> {
1991     let Inst{31} = 1;
1992   }
1993 }
1994
1995 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1996 class BaseInsertImmediate<bits<2> opc, RegisterClass regtype, Operand shifter,
1997                           string asm>
1998   : I<(outs regtype:$Rd),
1999       (ins regtype:$src, movimm32_imm:$imm, shifter:$shift),
2000        asm, "\t$Rd, $imm$shift", "$src = $Rd", []>,
2001     Sched<[WriteI, ReadI]> {
2002   bits<5> Rd;
2003   bits<16> imm;
2004   bits<6> shift;
2005   let Inst{30-29} = opc;
2006   let Inst{28-23} = 0b100101;
2007   let Inst{22-21} = shift{5-4};
2008   let Inst{20-5}  = imm;
2009   let Inst{4-0}   = Rd;
2010
2011   let DecoderMethod = "DecodeMoveImmInstruction";
2012 }
2013
2014 multiclass InsertImmediate<bits<2> opc, string asm> {
2015   def Wi : BaseInsertImmediate<opc, GPR32, movimm32_shift, asm> {
2016     let Inst{31} = 0;
2017   }
2018
2019   def Xi : BaseInsertImmediate<opc, GPR64, movimm64_shift, asm> {
2020     let Inst{31} = 1;
2021   }
2022 }
2023
2024 //---
2025 // Add/Subtract
2026 //---
2027
2028 class BaseAddSubImm<bit isSub, bit setFlags, RegisterClass dstRegtype,
2029                     string asm_inst, string asm_ops,
2030                     dag inputs, dag pattern>
2031     : I<(outs dstRegtype:$Rd), inputs, asm_inst, asm_ops, "", [pattern]>,
2032       Sched<[WriteI, ReadI]> {
2033   bits<5>  Rd;
2034   bits<5>  Rn;
2035   let Inst{30}    = isSub;
2036   let Inst{29}    = setFlags;
2037   let Inst{28-24} = 0b10001;
2038   let Inst{9-5}   = Rn;
2039   let Inst{4-0}   = Rd;
2040 }
2041
2042 class AddSubImmShift<bit isSub, bit setFlags, RegisterClass dstRegtype,
2043                      RegisterClass srcRegtype, addsub_shifted_imm immtype,
2044                      string asm_inst, SDPatternOperator OpNode>
2045     : BaseAddSubImm<isSub, setFlags, dstRegtype, asm_inst, "\t$Rd, $Rn, $imm",
2046                     (ins srcRegtype:$Rn, immtype:$imm),
2047                     (set dstRegtype:$Rd, (OpNode srcRegtype:$Rn, immtype:$imm))> {
2048   bits<14> imm;
2049   let Inst{23-22} = imm{13-12}; // '00' => lsl #0, '01' => lsl #12
2050   let Inst{21-10} = imm{11-0};
2051   let DecoderMethod = "DecodeAddSubImmShift";
2052 }
2053
2054 class BaseAddSubRegPseudo<RegisterClass regtype,
2055                           SDPatternOperator OpNode>
2056     : Pseudo<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
2057              [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm))]>,
2058       Sched<[WriteI, ReadI, ReadI]>;
2059
2060 class BaseAddSubSReg<bit isSub, bit setFlags, RegisterClass regtype,
2061                      arith_shifted_reg shifted_regtype, string asm,
2062                      SDPatternOperator OpNode>
2063     : I<(outs regtype:$Rd), (ins regtype:$Rn, shifted_regtype:$Rm),
2064         asm, "\t$Rd, $Rn, $Rm", "",
2065         [(set regtype:$Rd, (OpNode regtype:$Rn, shifted_regtype:$Rm))]>,
2066       Sched<[WriteISReg, ReadI, ReadISReg]> {
2067   // The operands are in order to match the 'addr' MI operands, so we
2068   // don't need an encoder method and by-name matching. Just use the default
2069   // in-order handling. Since we're using by-order, make sure the names
2070   // do not match.
2071   bits<5> dst;
2072   bits<5> src1;
2073   bits<5> src2;
2074   bits<8> shift;
2075   let Inst{30}    = isSub;
2076   let Inst{29}    = setFlags;
2077   let Inst{28-24} = 0b01011;
2078   let Inst{23-22} = shift{7-6};
2079   let Inst{21}    = 0;
2080   let Inst{20-16} = src2;
2081   let Inst{15-10} = shift{5-0};
2082   let Inst{9-5}   = src1;
2083   let Inst{4-0}   = dst;
2084
2085   let DecoderMethod = "DecodeThreeAddrSRegInstruction";
2086 }
2087
2088 class BaseAddSubEReg<bit isSub, bit setFlags, RegisterClass dstRegtype,
2089                      RegisterClass src1Regtype, Operand src2Regtype,
2090                      string asm, SDPatternOperator OpNode>
2091     : I<(outs dstRegtype:$R1),
2092         (ins src1Regtype:$R2, src2Regtype:$R3),
2093         asm, "\t$R1, $R2, $R3", "",
2094         [(set dstRegtype:$R1, (OpNode src1Regtype:$R2, src2Regtype:$R3))]>,
2095       Sched<[WriteIEReg, ReadI, ReadIEReg]> {
2096   bits<5> Rd;
2097   bits<5> Rn;
2098   bits<5> Rm;
2099   bits<6> ext;
2100   let Inst{30}    = isSub;
2101   let Inst{29}    = setFlags;
2102   let Inst{28-24} = 0b01011;
2103   let Inst{23-21} = 0b001;
2104   let Inst{20-16} = Rm;
2105   let Inst{15-13} = ext{5-3};
2106   let Inst{12-10} = ext{2-0};
2107   let Inst{9-5}   = Rn;
2108   let Inst{4-0}   = Rd;
2109
2110   let DecoderMethod = "DecodeAddSubERegInstruction";
2111 }
2112
2113 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
2114 class BaseAddSubEReg64<bit isSub, bit setFlags, RegisterClass dstRegtype,
2115                        RegisterClass src1Regtype, RegisterClass src2Regtype,
2116                        Operand ext_op, string asm>
2117     : I<(outs dstRegtype:$Rd),
2118         (ins src1Regtype:$Rn, src2Regtype:$Rm, ext_op:$ext),
2119         asm, "\t$Rd, $Rn, $Rm$ext", "", []>,
2120       Sched<[WriteIEReg, ReadI, ReadIEReg]> {
2121   bits<5> Rd;
2122   bits<5> Rn;
2123   bits<5> Rm;
2124   bits<6> ext;
2125   let Inst{30}    = isSub;
2126   let Inst{29}    = setFlags;
2127   let Inst{28-24} = 0b01011;
2128   let Inst{23-21} = 0b001;
2129   let Inst{20-16} = Rm;
2130   let Inst{15}    = ext{5};
2131   let Inst{12-10} = ext{2-0};
2132   let Inst{9-5}   = Rn;
2133   let Inst{4-0}   = Rd;
2134
2135   let DecoderMethod = "DecodeAddSubERegInstruction";
2136 }
2137
2138 // Aliases for register+register add/subtract.
2139 class AddSubRegAlias<string asm, Instruction inst, RegisterClass dstRegtype,
2140                      RegisterClass src1Regtype, RegisterClass src2Regtype,
2141                      int shiftExt>
2142     : InstAlias<asm#"\t$dst, $src1, $src2",
2143                 (inst dstRegtype:$dst, src1Regtype:$src1, src2Regtype:$src2,
2144                       shiftExt)>;
2145
2146 multiclass AddSub<bit isSub, string mnemonic, string alias,
2147                   SDPatternOperator OpNode = null_frag> {
2148   let hasSideEffects = 0, isReMaterializable = 1, isAsCheapAsAMove = 1 in {
2149   // Add/Subtract immediate
2150   // Increase the weight of the immediate variant to try to match it before
2151   // the extended register variant.
2152   // We used to match the register variant before the immediate when the
2153   // register argument could be implicitly zero-extended.
2154   let AddedComplexity = 6 in
2155   def Wri  : AddSubImmShift<isSub, 0, GPR32sp, GPR32sp, addsub_shifted_imm32,
2156                            mnemonic, OpNode> {
2157     let Inst{31} = 0;
2158   }
2159   let AddedComplexity = 6 in
2160   def Xri  : AddSubImmShift<isSub, 0, GPR64sp, GPR64sp, addsub_shifted_imm64,
2161                            mnemonic, OpNode> {
2162     let Inst{31} = 1;
2163   }
2164
2165   // Add/Subtract register - Only used for CodeGen
2166   def Wrr : BaseAddSubRegPseudo<GPR32, OpNode>;
2167   def Xrr : BaseAddSubRegPseudo<GPR64, OpNode>;
2168
2169   // Add/Subtract shifted register
2170   def Wrs : BaseAddSubSReg<isSub, 0, GPR32, arith_shifted_reg32, mnemonic,
2171                            OpNode> {
2172     let Inst{31} = 0;
2173   }
2174   def Xrs : BaseAddSubSReg<isSub, 0, GPR64, arith_shifted_reg64, mnemonic,
2175                            OpNode> {
2176     let Inst{31} = 1;
2177   }
2178   }
2179
2180   // Add/Subtract extended register
2181   let AddedComplexity = 1, hasSideEffects = 0 in {
2182   def Wrx : BaseAddSubEReg<isSub, 0, GPR32sp, GPR32sp,
2183                            arith_extended_reg32<i32>, mnemonic, OpNode> {
2184     let Inst{31} = 0;
2185   }
2186   def Xrx : BaseAddSubEReg<isSub, 0, GPR64sp, GPR64sp,
2187                            arith_extended_reg32to64<i64>, mnemonic, OpNode> {
2188     let Inst{31} = 1;
2189   }
2190   }
2191
2192   def Xrx64 : BaseAddSubEReg64<isSub, 0, GPR64sp, GPR64sp, GPR64,
2193                                arith_extendlsl64, mnemonic> {
2194     // UXTX and SXTX only.
2195     let Inst{14-13} = 0b11;
2196     let Inst{31} = 1;
2197   }
2198
2199   // add Rd, Rb, -imm -> sub Rd, Rn, imm
2200   def : InstSubst<alias#"\t$Rd, $Rn, $imm",
2201                   (!cast<Instruction>(NAME # "Wri") GPR32sp:$Rd, GPR32sp:$Rn,
2202                       addsub_shifted_imm32_neg:$imm), 0>;
2203   def : InstSubst<alias#"\t$Rd, $Rn, $imm",
2204                   (!cast<Instruction>(NAME # "Xri") GPR64sp:$Rd, GPR64sp:$Rn,
2205                        addsub_shifted_imm64_neg:$imm), 0>;
2206
2207   // Register/register aliases with no shift when SP is not used.
2208   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrs"),
2209                        GPR32, GPR32, GPR32, 0>;
2210   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Xrs"),
2211                        GPR64, GPR64, GPR64, 0>;
2212
2213   // Register/register aliases with no shift when either the destination or
2214   // first source register is SP.
2215   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrx"),
2216                        GPR32sponly, GPR32sp, GPR32, 16>; // UXTW #0
2217   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrx"),
2218                        GPR32sp, GPR32sponly, GPR32, 16>; // UXTW #0
2219   def : AddSubRegAlias<mnemonic,
2220                        !cast<Instruction>(NAME#"Xrx64"),
2221                        GPR64sponly, GPR64sp, GPR64, 24>; // UXTX #0
2222   def : AddSubRegAlias<mnemonic,
2223                        !cast<Instruction>(NAME#"Xrx64"),
2224                        GPR64sp, GPR64sponly, GPR64, 24>; // UXTX #0
2225 }
2226
2227 multiclass AddSubS<bit isSub, string mnemonic, SDNode OpNode, string cmp,
2228                    string alias, string cmpAlias> {
2229   let isCompare = 1, Defs = [NZCV] in {
2230   // Add/Subtract immediate
2231   def Wri  : AddSubImmShift<isSub, 1, GPR32, GPR32sp, addsub_shifted_imm32,
2232                            mnemonic, OpNode> {
2233     let Inst{31} = 0;
2234   }
2235   def Xri  : AddSubImmShift<isSub, 1, GPR64, GPR64sp, addsub_shifted_imm64,
2236                            mnemonic, OpNode> {
2237     let Inst{31} = 1;
2238   }
2239
2240   // Add/Subtract register
2241   def Wrr : BaseAddSubRegPseudo<GPR32, OpNode>;
2242   def Xrr : BaseAddSubRegPseudo<GPR64, OpNode>;
2243
2244   // Add/Subtract shifted register
2245   def Wrs : BaseAddSubSReg<isSub, 1, GPR32, arith_shifted_reg32, mnemonic,
2246                            OpNode> {
2247     let Inst{31} = 0;
2248   }
2249   def Xrs : BaseAddSubSReg<isSub, 1, GPR64, arith_shifted_reg64, mnemonic,
2250                            OpNode> {
2251     let Inst{31} = 1;
2252   }
2253
2254   // Add/Subtract extended register
2255   let AddedComplexity = 1 in {
2256   def Wrx : BaseAddSubEReg<isSub, 1, GPR32, GPR32sp,
2257                            arith_extended_reg32<i32>, mnemonic, OpNode> {
2258     let Inst{31} = 0;
2259   }
2260   def Xrx : BaseAddSubEReg<isSub, 1, GPR64, GPR64sp,
2261                            arith_extended_reg32<i64>, mnemonic, OpNode> {
2262     let Inst{31} = 1;
2263   }
2264   }
2265
2266   def Xrx64 : BaseAddSubEReg64<isSub, 1, GPR64, GPR64sp, GPR64,
2267                                arith_extendlsl64, mnemonic> {
2268     // UXTX and SXTX only.
2269     let Inst{14-13} = 0b11;
2270     let Inst{31} = 1;
2271   }
2272   } // Defs = [NZCV]
2273
2274   // Support negative immediates, e.g. adds Rd, Rn, -imm -> subs Rd, Rn, imm
2275   def : InstSubst<alias#"\t$Rd, $Rn, $imm",
2276                   (!cast<Instruction>(NAME # "Wri") GPR32:$Rd, GPR32sp:$Rn,
2277                       addsub_shifted_imm32_neg:$imm), 0>;
2278   def : InstSubst<alias#"\t$Rd, $Rn, $imm",
2279                   (!cast<Instruction>(NAME # "Xri") GPR64:$Rd, GPR64sp:$Rn,
2280                        addsub_shifted_imm64_neg:$imm), 0>;
2281
2282   // Compare aliases
2283   def : InstAlias<cmp#"\t$src, $imm", (!cast<Instruction>(NAME#"Wri")
2284                   WZR, GPR32sp:$src, addsub_shifted_imm32:$imm), 5>;
2285   def : InstAlias<cmp#"\t$src, $imm", (!cast<Instruction>(NAME#"Xri")
2286                   XZR, GPR64sp:$src, addsub_shifted_imm64:$imm), 5>;
2287   def : InstAlias<cmp#"\t$src1, $src2$sh", (!cast<Instruction>(NAME#"Wrx")
2288                   WZR, GPR32sp:$src1, GPR32:$src2, arith_extend:$sh), 4>;
2289   def : InstAlias<cmp#"\t$src1, $src2$sh", (!cast<Instruction>(NAME#"Xrx")
2290                   XZR, GPR64sp:$src1, GPR32:$src2, arith_extend:$sh), 4>;
2291   def : InstAlias<cmp#"\t$src1, $src2$sh", (!cast<Instruction>(NAME#"Xrx64")
2292                   XZR, GPR64sp:$src1, GPR64:$src2, arith_extendlsl64:$sh), 4>;
2293   def : InstAlias<cmp#"\t$src1, $src2$sh", (!cast<Instruction>(NAME#"Wrs")
2294                   WZR, GPR32:$src1, GPR32:$src2, arith_shift32:$sh), 4>;
2295   def : InstAlias<cmp#"\t$src1, $src2$sh", (!cast<Instruction>(NAME#"Xrs")
2296                   XZR, GPR64:$src1, GPR64:$src2, arith_shift64:$sh), 4>;
2297
2298   // Support negative immediates, e.g. cmp Rn, -imm -> cmn Rn, imm
2299   def : InstSubst<cmpAlias#"\t$src, $imm", (!cast<Instruction>(NAME#"Wri")
2300                   WZR, GPR32sp:$src, addsub_shifted_imm32_neg:$imm), 0>;
2301   def : InstSubst<cmpAlias#"\t$src, $imm", (!cast<Instruction>(NAME#"Xri")
2302                   XZR, GPR64sp:$src, addsub_shifted_imm64_neg:$imm), 0>;
2303
2304   // Compare shorthands
2305   def : InstAlias<cmp#"\t$src1, $src2", (!cast<Instruction>(NAME#"Wrs")
2306                   WZR, GPR32:$src1, GPR32:$src2, 0), 5>;
2307   def : InstAlias<cmp#"\t$src1, $src2", (!cast<Instruction>(NAME#"Xrs")
2308                   XZR, GPR64:$src1, GPR64:$src2, 0), 5>;
2309   def : InstAlias<cmp#"\t$src1, $src2", (!cast<Instruction>(NAME#"Wrx")
2310                   WZR, GPR32sponly:$src1, GPR32:$src2, 16), 5>;
2311   def : InstAlias<cmp#"\t$src1, $src2", (!cast<Instruction>(NAME#"Xrx64")
2312                   XZR, GPR64sponly:$src1, GPR64:$src2, 24), 5>;
2313
2314   // Register/register aliases with no shift when SP is not used.
2315   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrs"),
2316                        GPR32, GPR32, GPR32, 0>;
2317   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Xrs"),
2318                        GPR64, GPR64, GPR64, 0>;
2319
2320   // Register/register aliases with no shift when the first source register
2321   // is SP.
2322   def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrx"),
2323                        GPR32, GPR32sponly, GPR32, 16>; // UXTW #0
2324   def : AddSubRegAlias<mnemonic,
2325                        !cast<Instruction>(NAME#"Xrx64"),
2326                        GPR64, GPR64sponly, GPR64, 24>; // UXTX #0
2327 }
2328
2329 class AddSubG<bit isSub, string asm_inst, SDPatternOperator OpNode>
2330       : BaseAddSubImm<
2331           isSub, 0, GPR64sp, asm_inst, "\t$Rd, $Rn, $imm6, $imm4",
2332           (ins GPR64sp:$Rn, uimm6s16:$imm6, imm0_15:$imm4),
2333           (set GPR64sp:$Rd, (OpNode GPR64sp:$Rn, imm0_63:$imm6, imm0_15:$imm4))> {
2334   bits<6> imm6;
2335   bits<4> imm4;
2336   let Inst{31} = 1;
2337   let Inst{23-22} = 0b10;
2338   let Inst{21-16} = imm6;
2339   let Inst{15-14} = 0b00;
2340   let Inst{13-10} = imm4;
2341   let Unpredictable{15-14} = 0b11;
2342 }
2343
2344 class SUBP<bit setsFlags, string asm_instr, SDPatternOperator OpNode>
2345       : BaseTwoOperand<0b0000, GPR64, asm_instr, OpNode, GPR64sp, GPR64sp> {
2346   let Inst{31} = 1;
2347   let Inst{29} = setsFlags;
2348 }
2349
2350 //---
2351 // Extract
2352 //---
2353 def SDTA64EXTR : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
2354                                       SDTCisPtrTy<3>]>;
2355 def AArch64Extr : SDNode<"AArch64ISD::EXTR", SDTA64EXTR>;
2356
2357 class BaseExtractImm<RegisterClass regtype, Operand imm_type, string asm,
2358                      list<dag> patterns>
2359     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, imm_type:$imm),
2360          asm, "\t$Rd, $Rn, $Rm, $imm", "", patterns>,
2361       Sched<[WriteExtr, ReadExtrHi]> {
2362   bits<5> Rd;
2363   bits<5> Rn;
2364   bits<5> Rm;
2365   bits<6> imm;
2366
2367   let Inst{30-23} = 0b00100111;
2368   let Inst{21}    = 0;
2369   let Inst{20-16} = Rm;
2370   let Inst{15-10} = imm;
2371   let Inst{9-5}   = Rn;
2372   let Inst{4-0}   = Rd;
2373 }
2374
2375 multiclass ExtractImm<string asm> {
2376   def Wrri : BaseExtractImm<GPR32, imm0_31, asm,
2377                       [(set GPR32:$Rd,
2378                         (AArch64Extr GPR32:$Rn, GPR32:$Rm, imm0_31:$imm))]> {
2379     let Inst{31} = 0;
2380     let Inst{22} = 0;
2381     // imm<5> must be zero.
2382     let imm{5}   = 0;
2383   }
2384   def Xrri : BaseExtractImm<GPR64, imm0_63, asm,
2385                       [(set GPR64:$Rd,
2386                         (AArch64Extr GPR64:$Rn, GPR64:$Rm, imm0_63:$imm))]> {
2387
2388     let Inst{31} = 1;
2389     let Inst{22} = 1;
2390   }
2391 }
2392
2393 //---
2394 // Bitfield
2395 //---
2396
2397 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
2398 class BaseBitfieldImm<bits<2> opc,
2399                       RegisterClass regtype, Operand imm_type, string asm>
2400     : I<(outs regtype:$Rd), (ins regtype:$Rn, imm_type:$immr, imm_type:$imms),
2401          asm, "\t$Rd, $Rn, $immr, $imms", "", []>,
2402       Sched<[WriteIS, ReadI]> {
2403   bits<5> Rd;
2404   bits<5> Rn;
2405   bits<6> immr;
2406   bits<6> imms;
2407
2408   let Inst{30-29} = opc;
2409   let Inst{28-23} = 0b100110;
2410   let Inst{21-16} = immr;
2411   let Inst{15-10} = imms;
2412   let Inst{9-5}   = Rn;
2413   let Inst{4-0}   = Rd;
2414 }
2415
2416 multiclass BitfieldImm<bits<2> opc, string asm> {
2417   def Wri : BaseBitfieldImm<opc, GPR32, imm0_31, asm> {
2418     let Inst{31} = 0;
2419     let Inst{22} = 0;
2420     // imms<5> and immr<5> must be zero, else ReservedValue().
2421     let Inst{21} = 0;
2422     let Inst{15} = 0;
2423   }
2424   def Xri : BaseBitfieldImm<opc, GPR64, imm0_63, asm> {
2425     let Inst{31} = 1;
2426     let Inst{22} = 1;
2427   }
2428 }
2429
2430 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
2431 class BaseBitfieldImmWith2RegArgs<bits<2> opc,
2432                       RegisterClass regtype, Operand imm_type, string asm>
2433     : I<(outs regtype:$Rd), (ins regtype:$src, regtype:$Rn, imm_type:$immr,
2434                              imm_type:$imms),
2435          asm, "\t$Rd, $Rn, $immr, $imms", "$src = $Rd", []>,
2436       Sched<[WriteIS, ReadI]> {
2437   bits<5> Rd;
2438   bits<5> Rn;
2439   bits<6> immr;
2440   bits<6> imms;
2441
2442   let Inst{30-29} = opc;
2443   let Inst{28-23} = 0b100110;
2444   let Inst{21-16} = immr;
2445   let Inst{15-10} = imms;
2446   let Inst{9-5}   = Rn;
2447   let Inst{4-0}   = Rd;
2448 }
2449
2450 multiclass BitfieldImmWith2RegArgs<bits<2> opc, string asm> {
2451   def Wri : BaseBitfieldImmWith2RegArgs<opc, GPR32, imm0_31, asm> {
2452     let Inst{31} = 0;
2453     let Inst{22} = 0;
2454     // imms<5> and immr<5> must be zero, else ReservedValue().
2455     let Inst{21} = 0;
2456     let Inst{15} = 0;
2457   }
2458   def Xri : BaseBitfieldImmWith2RegArgs<opc, GPR64, imm0_63, asm> {
2459     let Inst{31} = 1;
2460     let Inst{22} = 1;
2461   }
2462 }
2463
2464 //---
2465 // Logical
2466 //---
2467
2468 // Logical (immediate)
2469 class BaseLogicalImm<bits<2> opc, RegisterClass dregtype,
2470                      RegisterClass sregtype, Operand imm_type, string asm,
2471                      list<dag> pattern>
2472     : I<(outs dregtype:$Rd), (ins sregtype:$Rn, imm_type:$imm),
2473          asm, "\t$Rd, $Rn, $imm", "", pattern>,
2474       Sched<[WriteI, ReadI]> {
2475   bits<5>  Rd;
2476   bits<5>  Rn;
2477   bits<13> imm;
2478   let Inst{30-29} = opc;
2479   let Inst{28-23} = 0b100100;
2480   let Inst{22}    = imm{12};
2481   let Inst{21-16} = imm{11-6};
2482   let Inst{15-10} = imm{5-0};
2483   let Inst{9-5}   = Rn;
2484   let Inst{4-0}   = Rd;
2485
2486   let DecoderMethod = "DecodeLogicalImmInstruction";
2487 }
2488
2489 // Logical (shifted register)
2490 class BaseLogicalSReg<bits<2> opc, bit N, RegisterClass regtype,
2491                       logical_shifted_reg shifted_regtype, string asm,
2492                       list<dag> pattern>
2493     : I<(outs regtype:$Rd), (ins regtype:$Rn, shifted_regtype:$Rm),
2494         asm, "\t$Rd, $Rn, $Rm", "", pattern>,
2495       Sched<[WriteISReg, ReadI, ReadISReg]> {
2496   // The operands are in order to match the 'addr' MI operands, so we
2497   // don't need an encoder method and by-name matching. Just use the default
2498   // in-order handling. Since we're using by-order, make sure the names
2499   // do not match.
2500   bits<5> dst;
2501   bits<5> src1;
2502   bits<5> src2;
2503   bits<8> shift;
2504   let Inst{30-29} = opc;
2505   let Inst{28-24} = 0b01010;
2506   let Inst{23-22} = shift{7-6};
2507   let Inst{21}    = N;
2508   let Inst{20-16} = src2;
2509   let Inst{15-10} = shift{5-0};
2510   let Inst{9-5}   = src1;
2511   let Inst{4-0}   = dst;
2512
2513   let DecoderMethod = "DecodeThreeAddrSRegInstruction";
2514 }
2515
2516 // Aliases for register+register logical instructions.
2517 class LogicalRegAlias<string asm, Instruction inst, RegisterClass regtype>
2518     : InstAlias<asm#"\t$dst, $src1, $src2",
2519                 (inst regtype:$dst, regtype:$src1, regtype:$src2, 0)>;
2520
2521 multiclass LogicalImm<bits<2> opc, string mnemonic, SDNode OpNode,
2522                       string Alias> {
2523   let AddedComplexity = 6, isReMaterializable = 1, isAsCheapAsAMove = 1 in
2524   def Wri : BaseLogicalImm<opc, GPR32sp, GPR32, logical_imm32, mnemonic,
2525                            [(set GPR32sp:$Rd, (OpNode GPR32:$Rn,
2526                                                logical_imm32:$imm))]> {
2527     let Inst{31} = 0;
2528     let Inst{22} = 0; // 64-bit version has an additional bit of immediate.
2529   }
2530   let AddedComplexity = 6, isReMaterializable = 1, isAsCheapAsAMove = 1 in
2531   def Xri : BaseLogicalImm<opc, GPR64sp, GPR64, logical_imm64, mnemonic,
2532                            [(set GPR64sp:$Rd, (OpNode GPR64:$Rn,
2533                                                logical_imm64:$imm))]> {
2534     let Inst{31} = 1;
2535   }
2536
2537   def : InstSubst<Alias # "\t$Rd, $Rn, $imm",
2538                   (!cast<Instruction>(NAME # "Wri") GPR32sp:$Rd, GPR32:$Rn,
2539                       logical_imm32_not:$imm), 0>;
2540   def : InstSubst<Alias # "\t$Rd, $Rn, $imm",
2541                   (!cast<Instruction>(NAME # "Xri") GPR64sp:$Rd, GPR64:$Rn,
2542                        logical_imm64_not:$imm), 0>;
2543 }
2544
2545 multiclass LogicalImmS<bits<2> opc, string mnemonic, SDNode OpNode,
2546                        string Alias> {
2547   let isCompare = 1, Defs = [NZCV] in {
2548   def Wri  : BaseLogicalImm<opc, GPR32, GPR32, logical_imm32, mnemonic,
2549       [(set GPR32:$Rd, (OpNode GPR32:$Rn, logical_imm32:$imm))]> {
2550     let Inst{31} = 0;
2551     let Inst{22} = 0; // 64-bit version has an additional bit of immediate.
2552   }
2553   def Xri  : BaseLogicalImm<opc, GPR64, GPR64, logical_imm64, mnemonic,
2554       [(set GPR64:$Rd, (OpNode GPR64:$Rn, logical_imm64:$imm))]> {
2555     let Inst{31} = 1;
2556   }
2557   } // end Defs = [NZCV]
2558
2559   def : InstSubst<Alias # "\t$Rd, $Rn, $imm",
2560                   (!cast<Instruction>(NAME # "Wri") GPR32:$Rd, GPR32:$Rn,
2561                       logical_imm32_not:$imm), 0>;
2562   def : InstSubst<Alias # "\t$Rd, $Rn, $imm",
2563                   (!cast<Instruction>(NAME # "Xri") GPR64:$Rd, GPR64:$Rn,
2564                        logical_imm64_not:$imm), 0>;
2565 }
2566
2567 class BaseLogicalRegPseudo<RegisterClass regtype, SDPatternOperator OpNode>
2568     : Pseudo<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
2569              [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm))]>,
2570       Sched<[WriteI, ReadI, ReadI]>;
2571
2572 // Split from LogicalImm as not all instructions have both.
2573 multiclass LogicalReg<bits<2> opc, bit N, string mnemonic,
2574                       SDPatternOperator OpNode> {
2575   let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
2576   def Wrr : BaseLogicalRegPseudo<GPR32, OpNode>;
2577   def Xrr : BaseLogicalRegPseudo<GPR64, OpNode>;
2578   }
2579
2580   def Wrs : BaseLogicalSReg<opc, N, GPR32, logical_shifted_reg32, mnemonic,
2581                             [(set GPR32:$Rd, (OpNode GPR32:$Rn,
2582                                                  logical_shifted_reg32:$Rm))]> {
2583     let Inst{31} = 0;
2584   }
2585   def Xrs : BaseLogicalSReg<opc, N, GPR64, logical_shifted_reg64, mnemonic,
2586                             [(set GPR64:$Rd, (OpNode GPR64:$Rn,
2587                                                  logical_shifted_reg64:$Rm))]> {
2588     let Inst{31} = 1;
2589   }
2590
2591   def : LogicalRegAlias<mnemonic,
2592                         !cast<Instruction>(NAME#"Wrs"), GPR32>;
2593   def : LogicalRegAlias<mnemonic,
2594                         !cast<Instruction>(NAME#"Xrs"), GPR64>;
2595 }
2596
2597 // Split from LogicalReg to allow setting NZCV Defs
2598 multiclass LogicalRegS<bits<2> opc, bit N, string mnemonic,
2599                        SDPatternOperator OpNode = null_frag> {
2600   let Defs = [NZCV], mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
2601   def Wrr : BaseLogicalRegPseudo<GPR32, OpNode>;
2602   def Xrr : BaseLogicalRegPseudo<GPR64, OpNode>;
2603
2604   def Wrs : BaseLogicalSReg<opc, N, GPR32, logical_shifted_reg32, mnemonic,
2605             [(set GPR32:$Rd, (OpNode GPR32:$Rn, logical_shifted_reg32:$Rm))]> {
2606     let Inst{31} = 0;
2607   }
2608   def Xrs : BaseLogicalSReg<opc, N, GPR64, logical_shifted_reg64, mnemonic,
2609             [(set GPR64:$Rd, (OpNode GPR64:$Rn, logical_shifted_reg64:$Rm))]> {
2610     let Inst{31} = 1;
2611   }
2612   } // Defs = [NZCV]
2613
2614   def : LogicalRegAlias<mnemonic,
2615                         !cast<Instruction>(NAME#"Wrs"), GPR32>;
2616   def : LogicalRegAlias<mnemonic,
2617                         !cast<Instruction>(NAME#"Xrs"), GPR64>;
2618 }
2619
2620 //---
2621 // Conditionally set flags
2622 //---
2623
2624 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
2625 class BaseCondComparisonImm<bit op, RegisterClass regtype, ImmLeaf immtype,
2626                             string mnemonic, SDNode OpNode>
2627     : I<(outs), (ins regtype:$Rn, immtype:$imm, imm32_0_15:$nzcv, ccode:$cond),
2628          mnemonic, "\t$Rn, $imm, $nzcv, $cond", "",
2629          [(set NZCV, (OpNode regtype:$Rn, immtype:$imm, (i32 imm:$nzcv),
2630                              (i32 imm:$cond), NZCV))]>,
2631       Sched<[WriteI, ReadI]> {
2632   let Uses = [NZCV];
2633   let Defs = [NZCV];
2634
2635   bits<5> Rn;
2636   bits<5> imm;
2637   bits<4> nzcv;
2638   bits<4> cond;
2639
2640   let Inst{30}    = op;
2641   let Inst{29-21} = 0b111010010;
2642   let Inst{20-16} = imm;
2643   let Inst{15-12} = cond;
2644   let Inst{11-10} = 0b10;
2645   let Inst{9-5}   = Rn;
2646   let Inst{4}     = 0b0;
2647   let Inst{3-0}   = nzcv;
2648 }
2649
2650 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
2651 class BaseCondComparisonReg<bit op, RegisterClass regtype, string mnemonic,
2652                             SDNode OpNode>
2653     : I<(outs), (ins regtype:$Rn, regtype:$Rm, imm32_0_15:$nzcv, ccode:$cond),
2654          mnemonic, "\t$Rn, $Rm, $nzcv, $cond", "",
2655          [(set NZCV, (OpNode regtype:$Rn, regtype:$Rm, (i32 imm:$nzcv),
2656                              (i32 imm:$cond), NZCV))]>,
2657       Sched<[WriteI, ReadI, ReadI]> {
2658   let Uses = [NZCV];
2659   let Defs = [NZCV];
2660
2661   bits<5> Rn;
2662   bits<5> Rm;
2663   bits<4> nzcv;
2664   bits<4> cond;
2665
2666   let Inst{30}    = op;
2667   let Inst{29-21} = 0b111010010;
2668   let Inst{20-16} = Rm;
2669   let Inst{15-12} = cond;
2670   let Inst{11-10} = 0b00;
2671   let Inst{9-5}   = Rn;
2672   let Inst{4}     = 0b0;
2673   let Inst{3-0}   = nzcv;
2674 }
2675
2676 multiclass CondComparison<bit op, string mnemonic, SDNode OpNode> {
2677   // immediate operand variants
2678   def Wi : BaseCondComparisonImm<op, GPR32, imm32_0_31, mnemonic, OpNode> {
2679     let Inst{31} = 0;
2680   }
2681   def Xi : BaseCondComparisonImm<op, GPR64, imm0_31, mnemonic, OpNode> {
2682     let Inst{31} = 1;
2683   }
2684   // register operand variants
2685   def Wr : BaseCondComparisonReg<op, GPR32, mnemonic, OpNode> {
2686     let Inst{31} = 0;
2687   }
2688   def Xr : BaseCondComparisonReg<op, GPR64, mnemonic, OpNode> {
2689     let Inst{31} = 1;
2690   }
2691 }
2692
2693 //---
2694 // Conditional select
2695 //---
2696
2697 class BaseCondSelect<bit op, bits<2> op2, RegisterClass regtype, string asm>
2698     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
2699          asm, "\t$Rd, $Rn, $Rm, $cond", "",
2700          [(set regtype:$Rd,
2701                (AArch64csel regtype:$Rn, regtype:$Rm, (i32 imm:$cond), NZCV))]>,
2702       Sched<[WriteI, ReadI, ReadI]> {
2703   let Uses = [NZCV];
2704
2705   bits<5> Rd;
2706   bits<5> Rn;
2707   bits<5> Rm;
2708   bits<4> cond;
2709
2710   let Inst{30}    = op;
2711   let Inst{29-21} = 0b011010100;
2712   let Inst{20-16} = Rm;
2713   let Inst{15-12} = cond;
2714   let Inst{11-10} = op2;
2715   let Inst{9-5}   = Rn;
2716   let Inst{4-0}   = Rd;
2717 }
2718
2719 multiclass CondSelect<bit op, bits<2> op2, string asm> {
2720   def Wr : BaseCondSelect<op, op2, GPR32, asm> {
2721     let Inst{31} = 0;
2722   }
2723   def Xr : BaseCondSelect<op, op2, GPR64, asm> {
2724     let Inst{31} = 1;
2725   }
2726 }
2727
2728 class BaseCondSelectOp<bit op, bits<2> op2, RegisterClass regtype, string asm,
2729                        PatFrag frag>
2730     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
2731          asm, "\t$Rd, $Rn, $Rm, $cond", "",
2732          [(set regtype:$Rd,
2733                (AArch64csel regtype:$Rn, (frag regtype:$Rm),
2734                (i32 imm:$cond), NZCV))]>,
2735       Sched<[WriteI, ReadI, ReadI]> {
2736   let Uses = [NZCV];
2737
2738   bits<5> Rd;
2739   bits<5> Rn;
2740   bits<5> Rm;
2741   bits<4> cond;
2742
2743   let Inst{30}    = op;
2744   let Inst{29-21} = 0b011010100;
2745   let Inst{20-16} = Rm;
2746   let Inst{15-12} = cond;
2747   let Inst{11-10} = op2;
2748   let Inst{9-5}   = Rn;
2749   let Inst{4-0}   = Rd;
2750 }
2751
2752 def inv_cond_XFORM : SDNodeXForm<imm, [{
2753   AArch64CC::CondCode CC = static_cast<AArch64CC::CondCode>(N->getZExtValue());
2754   return CurDAG->getTargetConstant(AArch64CC::getInvertedCondCode(CC), SDLoc(N),
2755                                    MVT::i32);
2756 }]>;
2757
2758 multiclass CondSelectOp<bit op, bits<2> op2, string asm, PatFrag frag> {
2759   def Wr : BaseCondSelectOp<op, op2, GPR32, asm, frag> {
2760     let Inst{31} = 0;
2761   }
2762   def Xr : BaseCondSelectOp<op, op2, GPR64, asm, frag> {
2763     let Inst{31} = 1;
2764   }
2765
2766   def : Pat<(AArch64csel (frag GPR32:$Rm), GPR32:$Rn, (i32 imm:$cond), NZCV),
2767             (!cast<Instruction>(NAME # Wr) GPR32:$Rn, GPR32:$Rm,
2768                                            (inv_cond_XFORM imm:$cond))>;
2769
2770   def : Pat<(AArch64csel (frag GPR64:$Rm), GPR64:$Rn, (i32 imm:$cond), NZCV),
2771             (!cast<Instruction>(NAME # Xr) GPR64:$Rn, GPR64:$Rm,
2772                                            (inv_cond_XFORM imm:$cond))>;
2773 }
2774
2775 //---
2776 // Special Mask Value
2777 //---
2778 def maski8_or_more : Operand<i32>,
2779   ImmLeaf<i32, [{ return (Imm & 0xff) == 0xff; }]> {
2780 }
2781 def maski16_or_more : Operand<i32>,
2782   ImmLeaf<i32, [{ return (Imm & 0xffff) == 0xffff; }]> {
2783 }
2784
2785
2786 //---
2787 // Load/store
2788 //---
2789
2790 // (unsigned immediate)
2791 // Indexed for 8-bit registers. offset is in range [0,4095].
2792 def am_indexed8 : ComplexPattern<i64, 2, "SelectAddrModeIndexed8", []>;
2793 def am_indexed16 : ComplexPattern<i64, 2, "SelectAddrModeIndexed16", []>;
2794 def am_indexed32 : ComplexPattern<i64, 2, "SelectAddrModeIndexed32", []>;
2795 def am_indexed64 : ComplexPattern<i64, 2, "SelectAddrModeIndexed64", []>;
2796 def am_indexed128 : ComplexPattern<i64, 2, "SelectAddrModeIndexed128", []>;
2797
2798 def gi_am_indexed8 :
2799     GIComplexOperandMatcher<s64, "selectAddrModeIndexed<8>">,
2800     GIComplexPatternEquiv<am_indexed8>;
2801 def gi_am_indexed16 :
2802     GIComplexOperandMatcher<s64, "selectAddrModeIndexed<16>">,
2803     GIComplexPatternEquiv<am_indexed16>;
2804 def gi_am_indexed32 :
2805     GIComplexOperandMatcher<s64, "selectAddrModeIndexed<32>">,
2806     GIComplexPatternEquiv<am_indexed32>;
2807 def gi_am_indexed64 :
2808     GIComplexOperandMatcher<s64, "selectAddrModeIndexed<64>">,
2809     GIComplexPatternEquiv<am_indexed64>;
2810 def gi_am_indexed128 :
2811     GIComplexOperandMatcher<s64, "selectAddrModeIndexed<128>">,
2812     GIComplexPatternEquiv<am_indexed128>;
2813
2814 class UImm12OffsetOperand<int Scale> : AsmOperandClass {
2815   let Name = "UImm12Offset" # Scale;
2816   let RenderMethod = "addUImm12OffsetOperands<" # Scale # ">";
2817   let PredicateMethod = "isUImm12Offset<" # Scale # ">";
2818   let DiagnosticType = "InvalidMemoryIndexed" # Scale;
2819 }
2820
2821 def UImm12OffsetScale1Operand : UImm12OffsetOperand<1>;
2822 def UImm12OffsetScale2Operand : UImm12OffsetOperand<2>;
2823 def UImm12OffsetScale4Operand : UImm12OffsetOperand<4>;
2824 def UImm12OffsetScale8Operand : UImm12OffsetOperand<8>;
2825 def UImm12OffsetScale16Operand : UImm12OffsetOperand<16>;
2826
2827 class uimm12_scaled<int Scale> : Operand<i64> {
2828   let ParserMatchClass
2829    = !cast<AsmOperandClass>("UImm12OffsetScale" # Scale # "Operand");
2830   let EncoderMethod
2831    = "getLdStUImm12OpValue<AArch64::fixup_aarch64_ldst_imm12_scale" # Scale # ">";
2832   let PrintMethod = "printUImm12Offset<" # Scale # ">";
2833 }
2834
2835 def uimm12s1 : uimm12_scaled<1>;
2836 def uimm12s2 : uimm12_scaled<2>;
2837 def uimm12s4 : uimm12_scaled<4>;
2838 def uimm12s8 : uimm12_scaled<8>;
2839 def uimm12s16 : uimm12_scaled<16>;
2840
2841 class BaseLoadStoreUI<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
2842                       string asm, list<dag> pattern>
2843     : I<oops, iops, asm, "\t$Rt, [$Rn, $offset]", "", pattern> {
2844   bits<5> Rt;
2845
2846   bits<5> Rn;
2847   bits<12> offset;
2848
2849   let Inst{31-30} = sz;
2850   let Inst{29-27} = 0b111;
2851   let Inst{26}    = V;
2852   let Inst{25-24} = 0b01;
2853   let Inst{23-22} = opc;
2854   let Inst{21-10} = offset;
2855   let Inst{9-5}   = Rn;
2856   let Inst{4-0}   = Rt;
2857
2858   let DecoderMethod = "DecodeUnsignedLdStInstruction";
2859 }
2860
2861 multiclass LoadUI<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
2862                   Operand indextype, string asm, list<dag> pattern> {
2863   let AddedComplexity = 10, mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
2864   def ui : BaseLoadStoreUI<sz, V, opc, (outs regtype:$Rt),
2865                            (ins GPR64sp:$Rn, indextype:$offset),
2866                            asm, pattern>,
2867            Sched<[WriteLD]>;
2868
2869   def : InstAlias<asm # "\t$Rt, [$Rn]",
2870                   (!cast<Instruction>(NAME # "ui") regtype:$Rt, GPR64sp:$Rn, 0)>;
2871 }
2872
2873 multiclass StoreUI<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
2874              Operand indextype, string asm, list<dag> pattern> {
2875   let AddedComplexity = 10, mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
2876   def ui : BaseLoadStoreUI<sz, V, opc, (outs),
2877                            (ins regtype:$Rt, GPR64sp:$Rn, indextype:$offset),
2878                            asm, pattern>,
2879            Sched<[WriteST]>;
2880
2881   def : InstAlias<asm # "\t$Rt, [$Rn]",
2882                   (!cast<Instruction>(NAME # "ui") regtype:$Rt, GPR64sp:$Rn, 0)>;
2883 }
2884
2885 // Same as StoreUI, but take a RegisterOperand. This is used by GlobalISel to
2886 // substitute zero-registers automatically.
2887 //
2888 // TODO: Roll out zero-register subtitution to GPR32/GPR64 and fold this back
2889 //       into StoreUI.
2890 multiclass StoreUIz<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
2891              Operand indextype, string asm, list<dag> pattern> {
2892   let AddedComplexity = 10, mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
2893   def ui : BaseLoadStoreUI<sz, V, opc, (outs),
2894                            (ins regtype:$Rt, GPR64sp:$Rn, indextype:$offset),
2895                            asm, pattern>,
2896            Sched<[WriteST]>;
2897
2898   def : InstAlias<asm # "\t$Rt, [$Rn]",
2899                   (!cast<Instruction>(NAME # "ui") regtype:$Rt, GPR64sp:$Rn, 0)>;
2900 }
2901
2902 def PrefetchOperand : AsmOperandClass {
2903   let Name = "Prefetch";
2904   let ParserMethod = "tryParsePrefetch";
2905 }
2906 def prfop : Operand<i32> {
2907   let PrintMethod = "printPrefetchOp";
2908   let ParserMatchClass = PrefetchOperand;
2909 }
2910
2911 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2912 class PrefetchUI<bits<2> sz, bit V, bits<2> opc, string asm, list<dag> pat>
2913     : BaseLoadStoreUI<sz, V, opc,
2914                       (outs), (ins prfop:$Rt, GPR64sp:$Rn, uimm12s8:$offset),
2915                       asm, pat>,
2916       Sched<[WriteLD]>;
2917
2918 //---
2919 // Load literal
2920 //---
2921
2922 // Load literal address: 19-bit immediate. The low two bits of the target
2923 // offset are implied zero and so are not part of the immediate.
2924 def am_ldrlit : Operand<iPTR> {
2925   let EncoderMethod = "getLoadLiteralOpValue";
2926   let DecoderMethod = "DecodePCRelLabel19";
2927   let PrintMethod = "printAlignedLabel";
2928   let ParserMatchClass = PCRelLabel19Operand;
2929   let OperandType = "OPERAND_PCREL";
2930 }
2931
2932 let mayLoad = 1, mayStore = 0, hasSideEffects = 0, AddedComplexity = 20 in
2933 class LoadLiteral<bits<2> opc, bit V, RegisterOperand regtype, string asm, list<dag> pat>
2934     : I<(outs regtype:$Rt), (ins am_ldrlit:$label),
2935         asm, "\t$Rt, $label", "", pat>,
2936       Sched<[WriteLD]> {
2937   bits<5> Rt;
2938   bits<19> label;
2939   let Inst{31-30} = opc;
2940   let Inst{29-27} = 0b011;
2941   let Inst{26}    = V;
2942   let Inst{25-24} = 0b00;
2943   let Inst{23-5}  = label;
2944   let Inst{4-0}   = Rt;
2945 }
2946
2947 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2948 class PrefetchLiteral<bits<2> opc, bit V, string asm, list<dag> pat>
2949     : I<(outs), (ins prfop:$Rt, am_ldrlit:$label),
2950         asm, "\t$Rt, $label", "", pat>,
2951       Sched<[WriteLD]> {
2952   bits<5> Rt;
2953   bits<19> label;
2954   let Inst{31-30} = opc;
2955   let Inst{29-27} = 0b011;
2956   let Inst{26}    = V;
2957   let Inst{25-24} = 0b00;
2958   let Inst{23-5}  = label;
2959   let Inst{4-0}   = Rt;
2960 }
2961
2962 //---
2963 // Load/store register offset
2964 //---
2965
2966 def ro_Xindexed8 : ComplexPattern<i64, 4, "SelectAddrModeXRO<8>", []>;
2967 def ro_Xindexed16 : ComplexPattern<i64, 4, "SelectAddrModeXRO<16>", []>;
2968 def ro_Xindexed32 : ComplexPattern<i64, 4, "SelectAddrModeXRO<32>", []>;
2969 def ro_Xindexed64 : ComplexPattern<i64, 4, "SelectAddrModeXRO<64>", []>;
2970 def ro_Xindexed128 : ComplexPattern<i64, 4, "SelectAddrModeXRO<128>", []>;
2971
2972 def ro_Windexed8 : ComplexPattern<i64, 4, "SelectAddrModeWRO<8>", []>;
2973 def ro_Windexed16 : ComplexPattern<i64, 4, "SelectAddrModeWRO<16>", []>;
2974 def ro_Windexed32 : ComplexPattern<i64, 4, "SelectAddrModeWRO<32>", []>;
2975 def ro_Windexed64 : ComplexPattern<i64, 4, "SelectAddrModeWRO<64>", []>;
2976 def ro_Windexed128 : ComplexPattern<i64, 4, "SelectAddrModeWRO<128>", []>;
2977
2978 class MemExtendOperand<string Reg, int Width> : AsmOperandClass {
2979   let Name = "Mem" # Reg # "Extend" # Width;
2980   let PredicateMethod = "isMem" # Reg # "Extend<" # Width # ">";
2981   let RenderMethod = "addMemExtendOperands";
2982   let DiagnosticType = "InvalidMemory" # Reg # "Extend" # Width;
2983 }
2984
2985 def MemWExtend8Operand : MemExtendOperand<"W", 8> {
2986   // The address "[x0, x1, lsl #0]" actually maps to the variant which performs
2987   // the trivial shift.
2988   let RenderMethod = "addMemExtend8Operands";
2989 }
2990 def MemWExtend16Operand : MemExtendOperand<"W", 16>;
2991 def MemWExtend32Operand : MemExtendOperand<"W", 32>;
2992 def MemWExtend64Operand : MemExtendOperand<"W", 64>;
2993 def MemWExtend128Operand : MemExtendOperand<"W", 128>;
2994
2995 def MemXExtend8Operand : MemExtendOperand<"X", 8> {
2996   // The address "[x0, x1, lsl #0]" actually maps to the variant which performs
2997   // the trivial shift.
2998   let RenderMethod = "addMemExtend8Operands";
2999 }
3000 def MemXExtend16Operand : MemExtendOperand<"X", 16>;
3001 def MemXExtend32Operand : MemExtendOperand<"X", 32>;
3002 def MemXExtend64Operand : MemExtendOperand<"X", 64>;
3003 def MemXExtend128Operand : MemExtendOperand<"X", 128>;
3004
3005 class ro_extend<AsmOperandClass ParserClass, string Reg, int Width>
3006         : Operand<i32> {
3007   let ParserMatchClass = ParserClass;
3008   let PrintMethod = "printMemExtend<'" # Reg # "', " # Width # ">";
3009   let DecoderMethod = "DecodeMemExtend";
3010   let EncoderMethod = "getMemExtendOpValue";
3011   let MIOperandInfo = (ops i32imm:$signed, i32imm:$doshift);
3012 }
3013
3014 def ro_Wextend8   : ro_extend<MemWExtend8Operand,   "w", 8>;
3015 def ro_Wextend16  : ro_extend<MemWExtend16Operand,  "w", 16>;
3016 def ro_Wextend32  : ro_extend<MemWExtend32Operand,  "w", 32>;
3017 def ro_Wextend64  : ro_extend<MemWExtend64Operand,  "w", 64>;
3018 def ro_Wextend128 : ro_extend<MemWExtend128Operand, "w", 128>;
3019
3020 def ro_Xextend8   : ro_extend<MemXExtend8Operand,   "x", 8>;
3021 def ro_Xextend16  : ro_extend<MemXExtend16Operand,  "x", 16>;
3022 def ro_Xextend32  : ro_extend<MemXExtend32Operand,  "x", 32>;
3023 def ro_Xextend64  : ro_extend<MemXExtend64Operand,  "x", 64>;
3024 def ro_Xextend128 : ro_extend<MemXExtend128Operand, "x", 128>;
3025
3026 class ROAddrMode<ComplexPattern windex, ComplexPattern xindex,
3027                   Operand wextend, Operand xextend>  {
3028   // CodeGen-level pattern covering the entire addressing mode.
3029   ComplexPattern Wpat = windex;
3030   ComplexPattern Xpat = xindex;
3031
3032   // Asm-level Operand covering the valid "uxtw #3" style syntax.
3033   Operand Wext = wextend;
3034   Operand Xext = xextend;
3035 }
3036
3037 def ro8 : ROAddrMode<ro_Windexed8, ro_Xindexed8, ro_Wextend8, ro_Xextend8>;
3038 def ro16 : ROAddrMode<ro_Windexed16, ro_Xindexed16, ro_Wextend16, ro_Xextend16>;
3039 def ro32 : ROAddrMode<ro_Windexed32, ro_Xindexed32, ro_Wextend32, ro_Xextend32>;
3040 def ro64 : ROAddrMode<ro_Windexed64, ro_Xindexed64, ro_Wextend64, ro_Xextend64>;
3041 def ro128 : ROAddrMode<ro_Windexed128, ro_Xindexed128, ro_Wextend128,
3042                        ro_Xextend128>;
3043
3044 class LoadStore8RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3045                       string asm, dag ins, dag outs, list<dag> pat>
3046     : I<ins, outs, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat> {
3047   bits<5> Rt;
3048   bits<5> Rn;
3049   bits<5> Rm;
3050   bits<2> extend;
3051   let Inst{31-30} = sz;
3052   let Inst{29-27} = 0b111;
3053   let Inst{26}    = V;
3054   let Inst{25-24} = 0b00;
3055   let Inst{23-22} = opc;
3056   let Inst{21}    = 1;
3057   let Inst{20-16} = Rm;
3058   let Inst{15}    = extend{1}; // sign extend Rm?
3059   let Inst{14}    = 1;
3060   let Inst{12}    = extend{0}; // do shift?
3061   let Inst{11-10} = 0b10;
3062   let Inst{9-5}   = Rn;
3063   let Inst{4-0}   = Rt;
3064 }
3065
3066 class ROInstAlias<string asm, RegisterOperand regtype, Instruction INST>
3067   : InstAlias<asm # "\t$Rt, [$Rn, $Rm]",
3068               (INST regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, 0, 0)>;
3069
3070 multiclass Load8RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3071                    string asm, ValueType Ty, SDPatternOperator loadop> {
3072   let AddedComplexity = 10 in
3073   def roW : LoadStore8RO<sz, V, opc, regtype, asm,
3074                  (outs regtype:$Rt),
3075                  (ins GPR64sp:$Rn, GPR32:$Rm, ro_Wextend8:$extend),
3076                  [(set (Ty regtype:$Rt),
3077                        (loadop (ro_Windexed8 GPR64sp:$Rn, GPR32:$Rm,
3078                                              ro_Wextend8:$extend)))]>,
3079            Sched<[WriteLDIdx, ReadAdrBase]> {
3080     let Inst{13} = 0b0;
3081   }
3082
3083   let AddedComplexity = 10 in
3084   def roX : LoadStore8RO<sz, V, opc, regtype, asm,
3085                  (outs regtype:$Rt),
3086                  (ins GPR64sp:$Rn, GPR64:$Rm, ro_Xextend8:$extend),
3087                  [(set (Ty regtype:$Rt),
3088                        (loadop (ro_Xindexed8 GPR64sp:$Rn, GPR64:$Rm,
3089                                              ro_Xextend8:$extend)))]>,
3090            Sched<[WriteLDIdx, ReadAdrBase]> {
3091     let Inst{13} = 0b1;
3092   }
3093
3094   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3095 }
3096
3097 multiclass Store8RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3098                     string asm, ValueType Ty, SDPatternOperator storeop> {
3099   let AddedComplexity = 10 in
3100   def roW : LoadStore8RO<sz, V, opc, regtype, asm, (outs),
3101                  (ins regtype:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend8:$extend),
3102                  [(storeop (Ty regtype:$Rt),
3103                            (ro_Windexed8 GPR64sp:$Rn, GPR32:$Rm,
3104                                          ro_Wextend8:$extend))]>,
3105             Sched<[WriteSTIdx, ReadAdrBase]> {
3106     let Inst{13} = 0b0;
3107   }
3108
3109   let AddedComplexity = 10 in
3110   def roX : LoadStore8RO<sz, V, opc, regtype, asm, (outs),
3111                  (ins regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend8:$extend),
3112                  [(storeop (Ty regtype:$Rt),
3113                            (ro_Xindexed8 GPR64sp:$Rn, GPR64:$Rm,
3114                                          ro_Xextend8:$extend))]>,
3115             Sched<[WriteSTIdx, ReadAdrBase]> {
3116     let Inst{13} = 0b1;
3117   }
3118
3119   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3120 }
3121
3122 class LoadStore16RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3123                       string asm, dag ins, dag outs, list<dag> pat>
3124     : I<ins, outs, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat> {
3125   bits<5> Rt;
3126   bits<5> Rn;
3127   bits<5> Rm;
3128   bits<2> extend;
3129   let Inst{31-30} = sz;
3130   let Inst{29-27} = 0b111;
3131   let Inst{26}    = V;
3132   let Inst{25-24} = 0b00;
3133   let Inst{23-22} = opc;
3134   let Inst{21}    = 1;
3135   let Inst{20-16} = Rm;
3136   let Inst{15}    = extend{1}; // sign extend Rm?
3137   let Inst{14}    = 1;
3138   let Inst{12}    = extend{0}; // do shift?
3139   let Inst{11-10} = 0b10;
3140   let Inst{9-5}   = Rn;
3141   let Inst{4-0}   = Rt;
3142 }
3143
3144 multiclass Load16RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3145                     string asm, ValueType Ty, SDPatternOperator loadop> {
3146   let AddedComplexity = 10 in
3147   def roW : LoadStore16RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3148                  (ins GPR64sp:$Rn, GPR32:$Rm, ro_Wextend16:$extend),
3149                  [(set (Ty regtype:$Rt),
3150                        (loadop (ro_Windexed16 GPR64sp:$Rn, GPR32:$Rm,
3151                                               ro_Wextend16:$extend)))]>,
3152             Sched<[WriteLDIdx, ReadAdrBase]> {
3153     let Inst{13} = 0b0;
3154   }
3155
3156   let AddedComplexity = 10 in
3157   def roX : LoadStore16RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3158                  (ins GPR64sp:$Rn, GPR64:$Rm, ro_Xextend16:$extend),
3159                  [(set (Ty regtype:$Rt),
3160                        (loadop (ro_Xindexed16 GPR64sp:$Rn, GPR64:$Rm,
3161                                              ro_Xextend16:$extend)))]>,
3162             Sched<[WriteLDIdx, ReadAdrBase]> {
3163     let Inst{13} = 0b1;
3164   }
3165
3166   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3167 }
3168
3169 multiclass Store16RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3170                      string asm, ValueType Ty, SDPatternOperator storeop> {
3171   let AddedComplexity = 10 in
3172   def roW : LoadStore16RO<sz, V, opc, regtype, asm, (outs),
3173                 (ins regtype:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend16:$extend),
3174                 [(storeop (Ty regtype:$Rt),
3175                           (ro_Windexed16 GPR64sp:$Rn, GPR32:$Rm,
3176                                          ro_Wextend16:$extend))]>,
3177            Sched<[WriteSTIdx, ReadAdrBase]> {
3178     let Inst{13} = 0b0;
3179   }
3180
3181   let AddedComplexity = 10 in
3182   def roX : LoadStore16RO<sz, V, opc, regtype, asm, (outs),
3183                 (ins regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend16:$extend),
3184                 [(storeop (Ty regtype:$Rt),
3185                           (ro_Xindexed16 GPR64sp:$Rn, GPR64:$Rm,
3186                                          ro_Xextend16:$extend))]>,
3187            Sched<[WriteSTIdx, ReadAdrBase]> {
3188     let Inst{13} = 0b1;
3189   }
3190
3191   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3192 }
3193
3194 class LoadStore32RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3195                       string asm, dag ins, dag outs, list<dag> pat>
3196     : I<ins, outs, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat> {
3197   bits<5> Rt;
3198   bits<5> Rn;
3199   bits<5> Rm;
3200   bits<2> extend;
3201   let Inst{31-30} = sz;
3202   let Inst{29-27} = 0b111;
3203   let Inst{26}    = V;
3204   let Inst{25-24} = 0b00;
3205   let Inst{23-22} = opc;
3206   let Inst{21}    = 1;
3207   let Inst{20-16} = Rm;
3208   let Inst{15}    = extend{1}; // sign extend Rm?
3209   let Inst{14}    = 1;
3210   let Inst{12}    = extend{0}; // do shift?
3211   let Inst{11-10} = 0b10;
3212   let Inst{9-5}   = Rn;
3213   let Inst{4-0}   = Rt;
3214 }
3215
3216 multiclass Load32RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3217                     string asm, ValueType Ty, SDPatternOperator loadop> {
3218   let AddedComplexity = 10 in
3219   def roW : LoadStore32RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3220                  (ins GPR64sp:$Rn, GPR32:$Rm, ro_Wextend32:$extend),
3221                  [(set (Ty regtype:$Rt),
3222                        (loadop (ro_Windexed32 GPR64sp:$Rn, GPR32:$Rm,
3223                                               ro_Wextend32:$extend)))]>,
3224            Sched<[WriteLDIdx, ReadAdrBase]> {
3225     let Inst{13} = 0b0;
3226   }
3227
3228   let AddedComplexity = 10 in
3229   def roX : LoadStore32RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3230                  (ins GPR64sp:$Rn, GPR64:$Rm, ro_Xextend32:$extend),
3231                  [(set (Ty regtype:$Rt),
3232                        (loadop (ro_Xindexed32 GPR64sp:$Rn, GPR64:$Rm,
3233                                               ro_Xextend32:$extend)))]>,
3234            Sched<[WriteLDIdx, ReadAdrBase]> {
3235     let Inst{13} = 0b1;
3236   }
3237
3238   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3239 }
3240
3241 multiclass Store32RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3242                      string asm, ValueType Ty, SDPatternOperator storeop> {
3243   let AddedComplexity = 10 in
3244   def roW : LoadStore32RO<sz, V, opc, regtype, asm, (outs),
3245                 (ins regtype:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend32:$extend),
3246                 [(storeop (Ty regtype:$Rt),
3247                           (ro_Windexed32 GPR64sp:$Rn, GPR32:$Rm,
3248                                          ro_Wextend32:$extend))]>,
3249             Sched<[WriteSTIdx, ReadAdrBase]> {
3250     let Inst{13} = 0b0;
3251   }
3252
3253   let AddedComplexity = 10 in
3254   def roX : LoadStore32RO<sz, V, opc, regtype, asm, (outs),
3255                 (ins regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend32:$extend),
3256                 [(storeop (Ty regtype:$Rt),
3257                           (ro_Xindexed32 GPR64sp:$Rn, GPR64:$Rm,
3258                                         ro_Xextend32:$extend))]>,
3259             Sched<[WriteSTIdx, ReadAdrBase]> {
3260     let Inst{13} = 0b1;
3261   }
3262
3263   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3264 }
3265
3266 class LoadStore64RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3267                       string asm, dag ins, dag outs, list<dag> pat>
3268     : I<ins, outs, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat> {
3269   bits<5> Rt;
3270   bits<5> Rn;
3271   bits<5> Rm;
3272   bits<2> extend;
3273   let Inst{31-30} = sz;
3274   let Inst{29-27} = 0b111;
3275   let Inst{26}    = V;
3276   let Inst{25-24} = 0b00;
3277   let Inst{23-22} = opc;
3278   let Inst{21}    = 1;
3279   let Inst{20-16} = Rm;
3280   let Inst{15}    = extend{1}; // sign extend Rm?
3281   let Inst{14}    = 1;
3282   let Inst{12}    = extend{0}; // do shift?
3283   let Inst{11-10} = 0b10;
3284   let Inst{9-5}   = Rn;
3285   let Inst{4-0}   = Rt;
3286 }
3287
3288 multiclass Load64RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3289                     string asm, ValueType Ty, SDPatternOperator loadop> {
3290   let AddedComplexity = 10, mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
3291   def roW : LoadStore64RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3292                 (ins GPR64sp:$Rn, GPR32:$Rm, ro_Wextend64:$extend),
3293                 [(set (Ty regtype:$Rt),
3294                       (loadop (ro_Windexed64 GPR64sp:$Rn, GPR32:$Rm,
3295                                              ro_Wextend64:$extend)))]>,
3296            Sched<[WriteLDIdx, ReadAdrBase]> {
3297     let Inst{13} = 0b0;
3298   }
3299
3300   let AddedComplexity = 10, mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
3301   def roX : LoadStore64RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3302                 (ins GPR64sp:$Rn, GPR64:$Rm, ro_Xextend64:$extend),
3303                  [(set (Ty regtype:$Rt),
3304                        (loadop (ro_Xindexed64 GPR64sp:$Rn, GPR64:$Rm,
3305                                               ro_Xextend64:$extend)))]>,
3306            Sched<[WriteLDIdx, ReadAdrBase]> {
3307     let Inst{13} = 0b1;
3308   }
3309
3310   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3311 }
3312
3313 multiclass Store64RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3314                      string asm, ValueType Ty, SDPatternOperator storeop> {
3315   let AddedComplexity = 10, mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
3316   def roW : LoadStore64RO<sz, V, opc, regtype, asm, (outs),
3317                 (ins regtype:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend64:$extend),
3318                 [(storeop (Ty regtype:$Rt),
3319                           (ro_Windexed64 GPR64sp:$Rn, GPR32:$Rm,
3320                                          ro_Wextend64:$extend))]>,
3321             Sched<[WriteSTIdx, ReadAdrBase]> {
3322     let Inst{13} = 0b0;
3323   }
3324
3325   let AddedComplexity = 10, mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
3326   def roX : LoadStore64RO<sz, V, opc, regtype, asm, (outs),
3327                 (ins regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend64:$extend),
3328                 [(storeop (Ty regtype:$Rt),
3329                           (ro_Xindexed64 GPR64sp:$Rn, GPR64:$Rm,
3330                                          ro_Xextend64:$extend))]>,
3331             Sched<[WriteSTIdx, ReadAdrBase]> {
3332     let Inst{13} = 0b1;
3333   }
3334
3335   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3336 }
3337
3338 class LoadStore128RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3339                       string asm, dag ins, dag outs, list<dag> pat>
3340     : I<ins, outs, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat> {
3341   bits<5> Rt;
3342   bits<5> Rn;
3343   bits<5> Rm;
3344   bits<2> extend;
3345   let Inst{31-30} = sz;
3346   let Inst{29-27} = 0b111;
3347   let Inst{26}    = V;
3348   let Inst{25-24} = 0b00;
3349   let Inst{23-22} = opc;
3350   let Inst{21}    = 1;
3351   let Inst{20-16} = Rm;
3352   let Inst{15}    = extend{1}; // sign extend Rm?
3353   let Inst{14}    = 1;
3354   let Inst{12}    = extend{0}; // do shift?
3355   let Inst{11-10} = 0b10;
3356   let Inst{9-5}   = Rn;
3357   let Inst{4-0}   = Rt;
3358 }
3359
3360 multiclass Load128RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3361                      string asm, ValueType Ty, SDPatternOperator loadop> {
3362   let AddedComplexity = 10, mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
3363   def roW : LoadStore128RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3364                 (ins GPR64sp:$Rn, GPR32:$Rm, ro_Wextend128:$extend),
3365                  [(set (Ty regtype:$Rt),
3366                        (loadop (ro_Windexed128 GPR64sp:$Rn, GPR32:$Rm,
3367                                                ro_Wextend128:$extend)))]>,
3368             Sched<[WriteLDIdx, ReadAdrBase]> {
3369     let Inst{13} = 0b0;
3370   }
3371
3372   let AddedComplexity = 10, mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
3373   def roX : LoadStore128RO<sz, V, opc, regtype, asm, (outs regtype:$Rt),
3374                 (ins GPR64sp:$Rn, GPR64:$Rm, ro_Xextend128:$extend),
3375                  [(set (Ty regtype:$Rt),
3376                        (loadop (ro_Xindexed128 GPR64sp:$Rn, GPR64:$Rm,
3377                                                ro_Xextend128:$extend)))]>,
3378             Sched<[WriteLDIdx, ReadAdrBase]> {
3379     let Inst{13} = 0b1;
3380   }
3381
3382   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3383 }
3384
3385 multiclass Store128RO<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3386                       string asm, ValueType Ty, SDPatternOperator storeop> {
3387   let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
3388   def roW : LoadStore128RO<sz, V, opc, regtype, asm, (outs),
3389                (ins regtype:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend128:$extend),
3390                 []>,
3391             Sched<[WriteSTIdx, ReadAdrBase]> {
3392     let Inst{13} = 0b0;
3393   }
3394
3395   let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
3396   def roX : LoadStore128RO<sz, V, opc, regtype, asm, (outs),
3397                (ins regtype:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend128:$extend),
3398                 []>,
3399             Sched<[WriteSTIdx, ReadAdrBase]> {
3400     let Inst{13} = 0b1;
3401   }
3402
3403   def : ROInstAlias<asm, regtype, !cast<Instruction>(NAME # "roX")>;
3404 }
3405
3406 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
3407 class BasePrefetchRO<bits<2> sz, bit V, bits<2> opc, dag outs, dag ins,
3408                      string asm, list<dag> pat>
3409     : I<outs, ins, asm, "\t$Rt, [$Rn, $Rm, $extend]", "", pat>,
3410       Sched<[WriteLD]> {
3411   bits<5> Rt;
3412   bits<5> Rn;
3413   bits<5> Rm;
3414   bits<2> extend;
3415   let Inst{31-30} = sz;
3416   let Inst{29-27} = 0b111;
3417   let Inst{26}    = V;
3418   let Inst{25-24} = 0b00;
3419   let Inst{23-22} = opc;
3420   let Inst{21}    = 1;
3421   let Inst{20-16} = Rm;
3422   let Inst{15}    = extend{1}; // sign extend Rm?
3423   let Inst{14}    = 1;
3424   let Inst{12}    = extend{0}; // do shift?
3425   let Inst{11-10} = 0b10;
3426   let Inst{9-5}   = Rn;
3427   let Inst{4-0}   = Rt;
3428 }
3429
3430 multiclass PrefetchRO<bits<2> sz, bit V, bits<2> opc, string asm> {
3431   def roW : BasePrefetchRO<sz, V, opc, (outs),
3432                 (ins prfop:$Rt, GPR64sp:$Rn, GPR32:$Rm, ro_Wextend64:$extend),
3433                 asm, [(AArch64Prefetch imm:$Rt,
3434                                      (ro_Windexed64 GPR64sp:$Rn, GPR32:$Rm,
3435                                                     ro_Wextend64:$extend))]> {
3436     let Inst{13} = 0b0;
3437   }
3438
3439   def roX : BasePrefetchRO<sz, V, opc, (outs),
3440                 (ins prfop:$Rt, GPR64sp:$Rn, GPR64:$Rm, ro_Xextend64:$extend),
3441                 asm,  [(AArch64Prefetch imm:$Rt,
3442                                       (ro_Xindexed64 GPR64sp:$Rn, GPR64:$Rm,
3443                                                      ro_Xextend64:$extend))]> {
3444     let Inst{13} = 0b1;
3445   }
3446
3447   def : InstAlias<"prfm $Rt, [$Rn, $Rm]",
3448                (!cast<Instruction>(NAME # "roX") prfop:$Rt,
3449                                                  GPR64sp:$Rn, GPR64:$Rm, 0, 0)>;
3450 }
3451
3452 //---
3453 // Load/store unscaled immediate
3454 //---
3455
3456 def am_unscaled8 :  ComplexPattern<i64, 2, "SelectAddrModeUnscaled8", []>;
3457 def am_unscaled16 : ComplexPattern<i64, 2, "SelectAddrModeUnscaled16", []>;
3458 def am_unscaled32 : ComplexPattern<i64, 2, "SelectAddrModeUnscaled32", []>;
3459 def am_unscaled64 : ComplexPattern<i64, 2, "SelectAddrModeUnscaled64", []>;
3460 def am_unscaled128 :ComplexPattern<i64, 2, "SelectAddrModeUnscaled128", []>;
3461
3462 def gi_am_unscaled8 :
3463     GIComplexOperandMatcher<s64, "selectAddrModeUnscaled8">,
3464     GIComplexPatternEquiv<am_unscaled8>;
3465 def gi_am_unscaled16 :
3466     GIComplexOperandMatcher<s64, "selectAddrModeUnscaled16">,
3467     GIComplexPatternEquiv<am_unscaled16>;
3468 def gi_am_unscaled32 :
3469     GIComplexOperandMatcher<s64, "selectAddrModeUnscaled32">,
3470     GIComplexPatternEquiv<am_unscaled32>;
3471 def gi_am_unscaled64 :
3472     GIComplexOperandMatcher<s64, "selectAddrModeUnscaled64">,
3473     GIComplexPatternEquiv<am_unscaled64>;
3474 def gi_am_unscaled128 :
3475     GIComplexOperandMatcher<s64, "selectAddrModeUnscaled128">,
3476     GIComplexPatternEquiv<am_unscaled128>;
3477
3478
3479 class BaseLoadStoreUnscale<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
3480                            string asm, list<dag> pattern>
3481     : I<oops, iops, asm, "\t$Rt, [$Rn, $offset]", "", pattern> {
3482   bits<5> Rt;
3483   bits<5> Rn;
3484   bits<9> offset;
3485   let Inst{31-30} = sz;
3486   let Inst{29-27} = 0b111;
3487   let Inst{26}    = V;
3488   let Inst{25-24} = 0b00;
3489   let Inst{23-22} = opc;
3490   let Inst{21}    = 0;
3491   let Inst{20-12} = offset;
3492   let Inst{11-10} = 0b00;
3493   let Inst{9-5}   = Rn;
3494   let Inst{4-0}   = Rt;
3495
3496   let DecoderMethod = "DecodeSignedLdStInstruction";
3497 }
3498
3499 // Armv8.4 LDAPR & STLR with Immediate Offset instruction
3500 multiclass BaseLoadUnscaleV84<string asm, bits<2> sz, bits<2> opc,
3501                               RegisterOperand regtype > {
3502   def i : BaseLoadStoreUnscale<sz, 0, opc, (outs regtype:$Rt),
3503                                (ins GPR64sp:$Rn, simm9:$offset), asm, []>,
3504           Sched<[WriteST]> {
3505     let Inst{29} = 0;
3506     let Inst{24} = 1;
3507   }
3508   def : InstAlias<asm # "\t$Rt, [$Rn]",
3509                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3510 }
3511
3512 multiclass BaseStoreUnscaleV84<string asm, bits<2> sz, bits<2> opc,
3513                                RegisterOperand regtype > {
3514   def i : BaseLoadStoreUnscale<sz, 0, opc, (outs),
3515                                (ins regtype:$Rt, GPR64sp:$Rn, simm9:$offset),
3516                                asm, []>,
3517           Sched<[WriteST]> {
3518     let Inst{29} = 0;
3519     let Inst{24} = 1;
3520   }
3521   def : InstAlias<asm # "\t$Rt, [$Rn]",
3522                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3523 }
3524
3525 multiclass LoadUnscaled<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3526                    string asm, list<dag> pattern> {
3527   let AddedComplexity = 1 in // try this before LoadUI
3528   def i : BaseLoadStoreUnscale<sz, V, opc, (outs regtype:$Rt),
3529                                (ins GPR64sp:$Rn, simm9:$offset), asm, pattern>,
3530           Sched<[WriteLD]>;
3531
3532   def : InstAlias<asm # "\t$Rt, [$Rn]",
3533                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3534 }
3535
3536 multiclass StoreUnscaled<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3537                          string asm, list<dag> pattern> {
3538   let AddedComplexity = 1 in // try this before StoreUI
3539   def i : BaseLoadStoreUnscale<sz, V, opc, (outs),
3540                                (ins regtype:$Rt, GPR64sp:$Rn, simm9:$offset),
3541                                asm, pattern>,
3542           Sched<[WriteST]>;
3543
3544   def : InstAlias<asm # "\t$Rt, [$Rn]",
3545                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3546 }
3547
3548 multiclass PrefetchUnscaled<bits<2> sz, bit V, bits<2> opc, string asm,
3549                             list<dag> pat> {
3550   let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
3551   def i : BaseLoadStoreUnscale<sz, V, opc, (outs),
3552                                (ins prfop:$Rt, GPR64sp:$Rn, simm9:$offset),
3553                                asm, pat>,
3554           Sched<[WriteLD]>;
3555
3556   def : InstAlias<asm # "\t$Rt, [$Rn]",
3557                   (!cast<Instruction>(NAME # "i") prfop:$Rt, GPR64sp:$Rn, 0)>;
3558 }
3559
3560 //---
3561 // Load/store unscaled immediate, unprivileged
3562 //---
3563
3564 class BaseLoadStoreUnprivileged<bits<2> sz, bit V, bits<2> opc,
3565                                 dag oops, dag iops, string asm>
3566     : I<oops, iops, asm, "\t$Rt, [$Rn, $offset]", "", []> {
3567   bits<5> Rt;
3568   bits<5> Rn;
3569   bits<9> offset;
3570   let Inst{31-30} = sz;
3571   let Inst{29-27} = 0b111;
3572   let Inst{26}    = V;
3573   let Inst{25-24} = 0b00;
3574   let Inst{23-22} = opc;
3575   let Inst{21}    = 0;
3576   let Inst{20-12} = offset;
3577   let Inst{11-10} = 0b10;
3578   let Inst{9-5}   = Rn;
3579   let Inst{4-0}   = Rt;
3580
3581   let DecoderMethod = "DecodeSignedLdStInstruction";
3582 }
3583
3584 multiclass LoadUnprivileged<bits<2> sz, bit V, bits<2> opc,
3585                             RegisterClass regtype, string asm> {
3586   let mayStore = 0, mayLoad = 1, hasSideEffects = 0 in
3587   def i : BaseLoadStoreUnprivileged<sz, V, opc, (outs regtype:$Rt),
3588                                     (ins GPR64sp:$Rn, simm9:$offset), asm>,
3589           Sched<[WriteLD]>;
3590
3591   def : InstAlias<asm # "\t$Rt, [$Rn]",
3592                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3593 }
3594
3595 multiclass StoreUnprivileged<bits<2> sz, bit V, bits<2> opc,
3596                              RegisterClass regtype, string asm> {
3597   let mayStore = 1, mayLoad = 0, hasSideEffects = 0 in
3598   def i : BaseLoadStoreUnprivileged<sz, V, opc, (outs),
3599                                  (ins regtype:$Rt, GPR64sp:$Rn, simm9:$offset),
3600                                  asm>,
3601           Sched<[WriteST]>;
3602
3603   def : InstAlias<asm # "\t$Rt, [$Rn]",
3604                   (!cast<Instruction>(NAME # "i") regtype:$Rt, GPR64sp:$Rn, 0)>;
3605 }
3606
3607 //---
3608 // Load/store pre-indexed
3609 //---
3610
3611 class BaseLoadStorePreIdx<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
3612                           string asm, string cstr, list<dag> pat>
3613     : I<oops, iops, asm, "\t$Rt, [$Rn, $offset]!", cstr, pat> {
3614   bits<5> Rt;
3615   bits<5> Rn;
3616   bits<9> offset;
3617   let Inst{31-30} = sz;
3618   let Inst{29-27} = 0b111;
3619   let Inst{26}    = V;
3620   let Inst{25-24} = 0;
3621   let Inst{23-22} = opc;
3622   let Inst{21}    = 0;
3623   let Inst{20-12} = offset;
3624   let Inst{11-10} = 0b11;
3625   let Inst{9-5}   = Rn;
3626   let Inst{4-0}   = Rt;
3627
3628   let DecoderMethod = "DecodeSignedLdStInstruction";
3629 }
3630
3631 let hasSideEffects = 0 in {
3632 let mayStore = 0, mayLoad = 1 in
3633 class LoadPreIdx<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3634              string asm>
3635     : BaseLoadStorePreIdx<sz, V, opc,
3636                      (outs GPR64sp:$wback, regtype:$Rt),
3637                      (ins GPR64sp:$Rn, simm9:$offset), asm,
3638                      "$Rn = $wback,@earlyclobber $wback", []>,
3639       Sched<[WriteLD, WriteAdr]>;
3640
3641 let mayStore = 1, mayLoad = 0 in
3642 class StorePreIdx<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3643                   string asm, SDPatternOperator storeop, ValueType Ty>
3644     : BaseLoadStorePreIdx<sz, V, opc,
3645                       (outs GPR64sp:$wback),
3646                       (ins regtype:$Rt, GPR64sp:$Rn, simm9:$offset),
3647                       asm, "$Rn = $wback,@earlyclobber $wback",
3648       [(set GPR64sp:$wback,
3649             (storeop (Ty regtype:$Rt), GPR64sp:$Rn, simm9:$offset))]>,
3650       Sched<[WriteAdr, WriteST]>;
3651 } // hasSideEffects = 0
3652
3653 //---
3654 // Load/store post-indexed
3655 //---
3656
3657 class BaseLoadStorePostIdx<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
3658                           string asm, string cstr, list<dag> pat>
3659     : I<oops, iops, asm, "\t$Rt, [$Rn], $offset", cstr, pat> {
3660   bits<5> Rt;
3661   bits<5> Rn;
3662   bits<9> offset;
3663   let Inst{31-30} = sz;
3664   let Inst{29-27} = 0b111;
3665   let Inst{26}    = V;
3666   let Inst{25-24} = 0b00;
3667   let Inst{23-22} = opc;
3668   let Inst{21}    = 0b0;
3669   let Inst{20-12} = offset;
3670   let Inst{11-10} = 0b01;
3671   let Inst{9-5}   = Rn;
3672   let Inst{4-0}   = Rt;
3673
3674   let DecoderMethod = "DecodeSignedLdStInstruction";
3675 }
3676
3677 let hasSideEffects = 0 in {
3678 let mayStore = 0, mayLoad = 1 in
3679 class LoadPostIdx<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3680              string asm>
3681     : BaseLoadStorePostIdx<sz, V, opc,
3682                       (outs GPR64sp:$wback, regtype:$Rt),
3683                       (ins GPR64sp:$Rn, simm9:$offset),
3684                       asm, "$Rn = $wback,@earlyclobber $wback", []>,
3685       Sched<[WriteLD, WriteAdr]>;
3686
3687 let mayStore = 1, mayLoad = 0 in
3688 class StorePostIdx<bits<2> sz, bit V, bits<2> opc, RegisterOperand regtype,
3689                    string asm, SDPatternOperator storeop, ValueType Ty>
3690     : BaseLoadStorePostIdx<sz, V, opc,
3691                       (outs GPR64sp:$wback),
3692                       (ins regtype:$Rt, GPR64sp:$Rn, simm9:$offset),
3693                        asm, "$Rn = $wback,@earlyclobber $wback",
3694       [(set GPR64sp:$wback,
3695             (storeop (Ty regtype:$Rt), GPR64sp:$Rn, simm9:$offset))]>,
3696     Sched<[WriteAdr, WriteST]>;
3697 } // hasSideEffects = 0
3698
3699
3700 //---
3701 // Load/store pair
3702 //---
3703
3704 // (indexed, offset)
3705
3706 class BaseLoadStorePairOffset<bits<2> opc, bit V, bit L, dag oops, dag iops,
3707                               string asm>
3708     : I<oops, iops, asm, "\t$Rt, $Rt2, [$Rn, $offset]", "", []> {
3709   bits<5> Rt;
3710   bits<5> Rt2;
3711   bits<5> Rn;
3712   bits<7> offset;
3713   let Inst{31-30} = opc;
3714   let Inst{29-27} = 0b101;
3715   let Inst{26}    = V;
3716   let Inst{25-23} = 0b010;
3717   let Inst{22}    = L;
3718   let Inst{21-15} = offset;
3719   let Inst{14-10} = Rt2;
3720   let Inst{9-5}   = Rn;
3721   let Inst{4-0}   = Rt;
3722
3723   let DecoderMethod = "DecodePairLdStInstruction";
3724 }
3725
3726 multiclass LoadPairOffset<bits<2> opc, bit V, RegisterOperand regtype,
3727                           Operand indextype, string asm> {
3728   let hasSideEffects = 0, mayStore = 0, mayLoad = 1 in
3729   def i : BaseLoadStorePairOffset<opc, V, 1,
3730                                   (outs regtype:$Rt, regtype:$Rt2),
3731                                   (ins GPR64sp:$Rn, indextype:$offset), asm>,
3732           Sched<[WriteLD, WriteLDHi]>;
3733
3734   def : InstAlias<asm # "\t$Rt, $Rt2, [$Rn]",
3735                   (!cast<Instruction>(NAME # "i") regtype:$Rt, regtype:$Rt2,
3736                                                   GPR64sp:$Rn, 0)>;
3737 }
3738
3739
3740 multiclass StorePairOffset<bits<2> opc, bit V, RegisterOperand regtype,
3741                            Operand indextype, string asm> {
3742   let hasSideEffects = 0, mayLoad = 0, mayStore = 1 in
3743   def i : BaseLoadStorePairOffset<opc, V, 0, (outs),
3744                                   (ins regtype:$Rt, regtype:$Rt2,
3745                                        GPR64sp:$Rn, indextype:$offset),
3746                                   asm>,
3747           Sched<[WriteSTP]>;
3748
3749   def : InstAlias<asm # "\t$Rt, $Rt2, [$Rn]",
3750                   (!cast<Instruction>(NAME # "i") regtype:$Rt, regtype:$Rt2,
3751                                                   GPR64sp:$Rn, 0)>;
3752 }
3753
3754 // (pre-indexed)
3755 class BaseLoadStorePairPreIdx<bits<2> opc, bit V, bit L, dag oops, dag iops,
3756                               string asm>
3757     : I<oops, iops, asm, "\t$Rt, $Rt2, [$Rn, $offset]!", "$Rn = $wback,@earlyclobber $wback", []> {
3758   bits<5> Rt;
3759   bits<5> Rt2;
3760   bits<5> Rn;
3761   bits<7> offset;
3762   let Inst{31-30} = opc;
3763   let Inst{29-27} = 0b101;
3764   let Inst{26}    = V;
3765   let Inst{25-23} = 0b011;
3766   let Inst{22}    = L;
3767   let Inst{21-15} = offset;
3768   let Inst{14-10} = Rt2;
3769   let Inst{9-5}   = Rn;
3770   let Inst{4-0}   = Rt;
3771
3772   let DecoderMethod = "DecodePairLdStInstruction";
3773 }
3774
3775 let hasSideEffects = 0 in {
3776 let mayStore = 0, mayLoad = 1 in
3777 class LoadPairPreIdx<bits<2> opc, bit V, RegisterOperand regtype,
3778                      Operand indextype, string asm>
3779     : BaseLoadStorePairPreIdx<opc, V, 1,
3780                               (outs GPR64sp:$wback, regtype:$Rt, regtype:$Rt2),
3781                               (ins GPR64sp:$Rn, indextype:$offset), asm>,
3782       Sched<[WriteLD, WriteLDHi, WriteAdr]>;
3783
3784 let mayStore = 1, mayLoad = 0 in
3785 class StorePairPreIdx<bits<2> opc, bit V, RegisterOperand regtype,
3786                       Operand indextype, string asm>
3787     : BaseLoadStorePairPreIdx<opc, V, 0, (outs GPR64sp:$wback),
3788                              (ins regtype:$Rt, regtype:$Rt2,
3789                                   GPR64sp:$Rn, indextype:$offset),
3790                              asm>,
3791       Sched<[WriteAdr, WriteSTP]>;
3792 } // hasSideEffects = 0
3793
3794 // (post-indexed)
3795
3796 class BaseLoadStorePairPostIdx<bits<2> opc, bit V, bit L, dag oops, dag iops,
3797                               string asm>
3798     : I<oops, iops, asm, "\t$Rt, $Rt2, [$Rn], $offset", "$Rn = $wback,@earlyclobber $wback", []> {
3799   bits<5> Rt;
3800   bits<5> Rt2;
3801   bits<5> Rn;
3802   bits<7> offset;
3803   let Inst{31-30} = opc;
3804   let Inst{29-27} = 0b101;
3805   let Inst{26}    = V;
3806   let Inst{25-23} = 0b001;
3807   let Inst{22}    = L;
3808   let Inst{21-15} = offset;
3809   let Inst{14-10} = Rt2;
3810   let Inst{9-5}   = Rn;
3811   let Inst{4-0}   = Rt;
3812
3813   let DecoderMethod = "DecodePairLdStInstruction";
3814 }
3815
3816 let hasSideEffects = 0 in {
3817 let mayStore = 0, mayLoad = 1 in
3818 class LoadPairPostIdx<bits<2> opc, bit V, RegisterOperand regtype,
3819                       Operand idxtype, string asm>
3820     : BaseLoadStorePairPostIdx<opc, V, 1,
3821                               (outs GPR64sp:$wback, regtype:$Rt, regtype:$Rt2),
3822                               (ins GPR64sp:$Rn, idxtype:$offset), asm>,
3823       Sched<[WriteLD, WriteLDHi, WriteAdr]>;
3824
3825 let mayStore = 1, mayLoad = 0 in
3826 class StorePairPostIdx<bits<2> opc, bit V, RegisterOperand regtype,
3827                        Operand idxtype, string asm>
3828     : BaseLoadStorePairPostIdx<opc, V, 0, (outs GPR64sp:$wback),
3829                              (ins regtype:$Rt, regtype:$Rt2,
3830                                   GPR64sp:$Rn, idxtype:$offset),
3831                              asm>,
3832       Sched<[WriteAdr, WriteSTP]>;
3833 } // hasSideEffects = 0
3834
3835 //  (no-allocate)
3836
3837 class BaseLoadStorePairNoAlloc<bits<2> opc, bit V, bit L, dag oops, dag iops,
3838                               string asm>
3839     : I<oops, iops, asm, "\t$Rt, $Rt2, [$Rn, $offset]", "", []> {
3840   bits<5> Rt;
3841   bits<5> Rt2;
3842   bits<5> Rn;
3843   bits<7> offset;
3844   let Inst{31-30} = opc;
3845   let Inst{29-27} = 0b101;
3846   let Inst{26}    = V;
3847   let Inst{25-23} = 0b000;
3848   let Inst{22}    = L;
3849   let Inst{21-15} = offset;
3850   let Inst{14-10} = Rt2;
3851   let Inst{9-5}   = Rn;
3852   let Inst{4-0}   = Rt;
3853
3854   let DecoderMethod = "DecodePairLdStInstruction";
3855 }
3856
3857 multiclass LoadPairNoAlloc<bits<2> opc, bit V, RegisterClass regtype,
3858                            Operand indextype, string asm> {
3859   let hasSideEffects = 0, mayStore = 0, mayLoad = 1 in
3860   def i : BaseLoadStorePairNoAlloc<opc, V, 1,
3861                                    (outs regtype:$Rt, regtype:$Rt2),
3862                                    (ins GPR64sp:$Rn, indextype:$offset), asm>,
3863           Sched<[WriteLD, WriteLDHi]>;
3864
3865
3866   def : InstAlias<asm # "\t$Rt, $Rt2, [$Rn]",
3867                   (!cast<Instruction>(NAME # "i") regtype:$Rt, regtype:$Rt2,
3868                                                   GPR64sp:$Rn, 0)>;
3869 }
3870
3871 multiclass StorePairNoAlloc<bits<2> opc, bit V, RegisterClass regtype,
3872                       Operand indextype, string asm> {
3873   let hasSideEffects = 0, mayStore = 1, mayLoad = 0 in
3874   def i : BaseLoadStorePairNoAlloc<opc, V, 0, (outs),
3875                                    (ins regtype:$Rt, regtype:$Rt2,
3876                                         GPR64sp:$Rn, indextype:$offset),
3877                                    asm>,
3878           Sched<[WriteSTP]>;
3879
3880   def : InstAlias<asm # "\t$Rt, $Rt2, [$Rn]",
3881                   (!cast<Instruction>(NAME # "i") regtype:$Rt, regtype:$Rt2,
3882                                                   GPR64sp:$Rn, 0)>;
3883 }
3884
3885 //---
3886 // Load/store exclusive
3887 //---
3888
3889 // True exclusive operations write to and/or read from the system's exclusive
3890 // monitors, which as far as a compiler is concerned can be modelled as a
3891 // random shared memory address. Hence LoadExclusive mayStore.
3892 //
3893 // Since these instructions have the undefined register bits set to 1 in
3894 // their canonical form, we need a post encoder method to set those bits
3895 // to 1 when encoding these instructions. We do this using the
3896 // fixLoadStoreExclusive function. This function has template parameters:
3897 //
3898 // fixLoadStoreExclusive<int hasRs, int hasRt2>
3899 //
3900 // hasRs indicates that the instruction uses the Rs field, so we won't set
3901 // it to 1 (and the same for Rt2). We don't need template parameters for
3902 // the other register fields since Rt and Rn are always used.
3903 //
3904 let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in
3905 class BaseLoadStoreExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3906                              dag oops, dag iops, string asm, string operands>
3907     : I<oops, iops, asm, operands, "", []> {
3908   let Inst{31-30} = sz;
3909   let Inst{29-24} = 0b001000;
3910   let Inst{23}    = o2;
3911   let Inst{22}    = L;
3912   let Inst{21}    = o1;
3913   let Inst{15}    = o0;
3914
3915   let DecoderMethod = "DecodeExclusiveLdStInstruction";
3916 }
3917
3918 // Neither Rs nor Rt2 operands.
3919 class LoadStoreExclusiveSimple<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3920                                dag oops, dag iops, string asm, string operands>
3921     : BaseLoadStoreExclusive<sz, o2, L, o1, o0, oops, iops, asm, operands> {
3922   bits<5> Rt;
3923   bits<5> Rn;
3924   let Inst{20-16} = 0b11111;
3925   let Unpredictable{20-16} = 0b11111;
3926   let Inst{14-10} = 0b11111;
3927   let Unpredictable{14-10} = 0b11111;
3928   let Inst{9-5} = Rn;
3929   let Inst{4-0} = Rt;
3930
3931   let PostEncoderMethod = "fixLoadStoreExclusive<0,0>";
3932 }
3933
3934 // Simple load acquires don't set the exclusive monitor
3935 let mayLoad = 1, mayStore = 0 in
3936 class LoadAcquire<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3937                   RegisterClass regtype, string asm>
3938     : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs regtype:$Rt),
3939                                (ins GPR64sp0:$Rn), asm, "\t$Rt, [$Rn]">,
3940       Sched<[WriteLD]>;
3941
3942 class LoadExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3943                     RegisterClass regtype, string asm>
3944     : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs regtype:$Rt),
3945                                (ins GPR64sp0:$Rn), asm, "\t$Rt, [$Rn]">,
3946       Sched<[WriteLD]>;
3947
3948 class LoadExclusivePair<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3949                        RegisterClass regtype, string asm>
3950     : BaseLoadStoreExclusive<sz, o2, L, o1, o0,
3951                              (outs regtype:$Rt, regtype:$Rt2),
3952                              (ins GPR64sp0:$Rn), asm,
3953                              "\t$Rt, $Rt2, [$Rn]">,
3954       Sched<[WriteLD, WriteLDHi]> {
3955   bits<5> Rt;
3956   bits<5> Rt2;
3957   bits<5> Rn;
3958   let Inst{14-10} = Rt2;
3959   let Inst{9-5} = Rn;
3960   let Inst{4-0} = Rt;
3961
3962   let PostEncoderMethod = "fixLoadStoreExclusive<0,1>";
3963 }
3964
3965 // Simple store release operations do not check the exclusive monitor.
3966 let mayLoad = 0, mayStore = 1 in
3967 class StoreRelease<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3968                    RegisterClass regtype, string asm>
3969     : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs),
3970                                (ins regtype:$Rt, GPR64sp0:$Rn),
3971                                asm, "\t$Rt, [$Rn]">,
3972       Sched<[WriteST]>;
3973
3974 let mayLoad = 1, mayStore = 1 in
3975 class StoreExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3976                      RegisterClass regtype, string asm>
3977     : BaseLoadStoreExclusive<sz, o2, L, o1, o0, (outs GPR32:$Ws),
3978                              (ins regtype:$Rt, GPR64sp0:$Rn),
3979                              asm, "\t$Ws, $Rt, [$Rn]">,
3980       Sched<[WriteSTX]> {
3981   bits<5> Ws;
3982   bits<5> Rt;
3983   bits<5> Rn;
3984   let Inst{20-16} = Ws;
3985   let Inst{9-5} = Rn;
3986   let Inst{4-0} = Rt;
3987
3988   let Constraints = "@earlyclobber $Ws";
3989   let PostEncoderMethod = "fixLoadStoreExclusive<1,0>";
3990 }
3991
3992 class StoreExclusivePair<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3993                          RegisterClass regtype, string asm>
3994     : BaseLoadStoreExclusive<sz, o2, L, o1, o0,
3995                              (outs GPR32:$Ws),
3996                              (ins regtype:$Rt, regtype:$Rt2, GPR64sp0:$Rn),
3997                               asm, "\t$Ws, $Rt, $Rt2, [$Rn]">,
3998       Sched<[WriteSTX]> {
3999   bits<5> Ws;
4000   bits<5> Rt;
4001   bits<5> Rt2;
4002   bits<5> Rn;
4003   let Inst{20-16} = Ws;
4004   let Inst{14-10} = Rt2;
4005   let Inst{9-5} = Rn;
4006   let Inst{4-0} = Rt;
4007
4008   let Constraints = "@earlyclobber $Ws";
4009 }
4010
4011 // Armv8.5-A Memory Tagging Extension
4012 class BaseMemTag<bits<2> opc1, bits<2> opc2, string asm_insn,
4013                  string asm_opnds, string cstr, dag oops, dag iops>
4014     : I<oops, iops, asm_insn, asm_opnds, cstr, []>,
4015       Sched<[]> {
4016   bits<5> Rn;
4017
4018   let Inst{31-24} = 0b11011001;
4019   let Inst{23-22} = opc1;
4020   let Inst{21}    = 1;
4021   // Inst{20-12} defined by subclass
4022   let Inst{11-10} = opc2;
4023   let Inst{9-5}   = Rn;
4024   // Inst{4-0} defined by subclass
4025 }
4026
4027 class MemTagVector<bit Load, string asm_insn, string asm_opnds,
4028                    dag oops, dag iops>
4029     : BaseMemTag<{0b1, Load}, 0b00, asm_insn, asm_opnds,
4030                   "", oops, iops> {
4031   bits<5> Rt;
4032
4033   let Inst{20-12} = 0b000000000;
4034   let Inst{4-0}   = Rt;
4035
4036   let mayLoad = Load;
4037 }
4038
4039 class MemTagLoad<string asm_insn, string asm_opnds>
4040     : BaseMemTag<0b01, 0b00, asm_insn, asm_opnds, "$Rt = $wback",
4041                  (outs GPR64:$wback),
4042                  (ins GPR64:$Rt, GPR64sp:$Rn, simm9s16:$offset)> {
4043   bits<5> Rt;
4044   bits<9> offset;
4045
4046   let Inst{20-12} = offset;
4047   let Inst{4-0}   = Rt;
4048
4049   let mayLoad = 1;
4050 }
4051
4052 class BaseMemTagStore<bits<2> opc1, bits<2> opc2, string asm_insn,
4053                      string asm_opnds, string cstr, dag oops, dag iops>
4054     : BaseMemTag<opc1, opc2, asm_insn, asm_opnds, cstr, oops, iops> {
4055   bits<5> Rt;
4056   bits<9> offset;
4057
4058   let Inst{20-12} = offset;
4059   let Inst{4-0}   = Rt;
4060
4061   let mayStore = 1;
4062 }
4063
4064 multiclass MemTagStore<bits<2> opc1, string insn> {
4065   def Offset :
4066     BaseMemTagStore<opc1, 0b10, insn, "\t$Rt, [$Rn, $offset]", "",
4067                     (outs), (ins GPR64sp:$Rt, GPR64sp:$Rn, simm9s16:$offset)>;
4068   def PreIndex :
4069     BaseMemTagStore<opc1, 0b11, insn, "\t$Rt, [$Rn, $offset]!",
4070                     "$Rn = $wback",
4071                     (outs GPR64sp:$wback),
4072                     (ins GPR64sp:$Rt, GPR64sp:$Rn, simm9s16:$offset)>;
4073   def PostIndex :
4074     BaseMemTagStore<opc1, 0b01, insn, "\t$Rt, [$Rn], $offset",
4075                     "$Rn = $wback",
4076                     (outs GPR64sp:$wback),
4077                     (ins GPR64sp:$Rt, GPR64sp:$Rn, simm9s16:$offset)>;
4078
4079   def : InstAlias<insn # "\t$Rt, [$Rn]",
4080                   (!cast<Instruction>(NAME # "Offset") GPR64sp:$Rt, GPR64sp:$Rn, 0)>;
4081 }
4082
4083 //---
4084 // Exception generation
4085 //---
4086
4087 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
4088 class ExceptionGeneration<bits<3> op1, bits<2> ll, string asm>
4089     : I<(outs), (ins imm0_65535:$imm), asm, "\t$imm", "", []>,
4090       Sched<[WriteSys]> {
4091   bits<16> imm;
4092   let Inst{31-24} = 0b11010100;
4093   let Inst{23-21} = op1;
4094   let Inst{20-5}  = imm;
4095   let Inst{4-2}   = 0b000;
4096   let Inst{1-0}   = ll;
4097 }
4098
4099 //---
4100 // UDF : Permanently UNDEFINED instructions.  Format: Opc = 0x0000, 16 bit imm.
4101 //--
4102 let hasSideEffects = 1, isTrap = 1, mayLoad = 0, mayStore = 0 in {
4103 class UDFType<bits<16> opc, string asm>
4104   : I<(outs), (ins uimm16:$imm),
4105        asm, "\t$imm", "", []>,
4106     Sched<[]> {
4107   bits<16> imm;
4108   let Inst{31-16} = opc;
4109   let Inst{15-0} = imm;
4110 }
4111 }
4112 let Predicates = [HasFPARMv8] in {
4113
4114 //---
4115 // Floating point to integer conversion
4116 //---
4117
4118 class BaseFPToIntegerUnscaled<bits<2> type, bits<2> rmode, bits<3> opcode,
4119                       RegisterClass srcType, RegisterClass dstType,
4120                       string asm, list<dag> pattern>
4121     : I<(outs dstType:$Rd), (ins srcType:$Rn),
4122          asm, "\t$Rd, $Rn", "", pattern>,
4123       Sched<[WriteFCvt]> {
4124   bits<5> Rd;
4125   bits<5> Rn;
4126   let Inst{30-29} = 0b00;
4127   let Inst{28-24} = 0b11110;
4128   let Inst{23-22} = type;
4129   let Inst{21}    = 1;
4130   let Inst{20-19} = rmode;
4131   let Inst{18-16} = opcode;
4132   let Inst{15-10} = 0;
4133   let Inst{9-5}   = Rn;
4134   let Inst{4-0}   = Rd;
4135 }
4136
4137 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4138 class BaseFPToInteger<bits<2> type, bits<2> rmode, bits<3> opcode,
4139                       RegisterClass srcType, RegisterClass dstType,
4140                       Operand immType, string asm, list<dag> pattern>
4141     : I<(outs dstType:$Rd), (ins srcType:$Rn, immType:$scale),
4142          asm, "\t$Rd, $Rn, $scale", "", pattern>,
4143       Sched<[WriteFCvt]> {
4144   bits<5> Rd;
4145   bits<5> Rn;
4146   bits<6> scale;
4147   let Inst{30-29} = 0b00;
4148   let Inst{28-24} = 0b11110;
4149   let Inst{23-22} = type;
4150   let Inst{21}    = 0;
4151   let Inst{20-19} = rmode;
4152   let Inst{18-16} = opcode;
4153   let Inst{15-10} = scale;
4154   let Inst{9-5}   = Rn;
4155   let Inst{4-0}   = Rd;
4156 }
4157
4158 multiclass FPToIntegerUnscaled<bits<2> rmode, bits<3> opcode, string asm,
4159            SDPatternOperator OpN> {
4160   // Unscaled half-precision to 32-bit
4161   def UWHr : BaseFPToIntegerUnscaled<0b11, rmode, opcode, FPR16, GPR32, asm,
4162                                      [(set GPR32:$Rd, (OpN FPR16:$Rn))]> {
4163     let Inst{31} = 0; // 32-bit GPR flag
4164     let Predicates = [HasFullFP16];
4165   }
4166
4167   // Unscaled half-precision to 64-bit
4168   def UXHr : BaseFPToIntegerUnscaled<0b11, rmode, opcode, FPR16, GPR64, asm,
4169                                      [(set GPR64:$Rd, (OpN FPR16:$Rn))]> {
4170     let Inst{31} = 1; // 64-bit GPR flag
4171     let Predicates = [HasFullFP16];
4172   }
4173
4174   // Unscaled single-precision to 32-bit
4175   def UWSr : BaseFPToIntegerUnscaled<0b00, rmode, opcode, FPR32, GPR32, asm,
4176                                      [(set GPR32:$Rd, (OpN FPR32:$Rn))]> {
4177     let Inst{31} = 0; // 32-bit GPR flag
4178   }
4179
4180   // Unscaled single-precision to 64-bit
4181   def UXSr : BaseFPToIntegerUnscaled<0b00, rmode, opcode, FPR32, GPR64, asm,
4182                                      [(set GPR64:$Rd, (OpN FPR32:$Rn))]> {
4183     let Inst{31} = 1; // 64-bit GPR flag
4184   }
4185
4186   // Unscaled double-precision to 32-bit
4187   def UWDr : BaseFPToIntegerUnscaled<0b01, rmode, opcode, FPR64, GPR32, asm,
4188                                      [(set GPR32:$Rd, (OpN (f64 FPR64:$Rn)))]> {
4189     let Inst{31} = 0; // 32-bit GPR flag
4190   }
4191
4192   // Unscaled double-precision to 64-bit
4193   def UXDr : BaseFPToIntegerUnscaled<0b01, rmode, opcode, FPR64, GPR64, asm,
4194                                      [(set GPR64:$Rd, (OpN (f64 FPR64:$Rn)))]> {
4195     let Inst{31} = 1; // 64-bit GPR flag
4196   }
4197 }
4198
4199 multiclass FPToIntegerScaled<bits<2> rmode, bits<3> opcode, string asm,
4200                              SDPatternOperator OpN> {
4201   // Scaled half-precision to 32-bit
4202   def SWHri : BaseFPToInteger<0b11, rmode, opcode, FPR16, GPR32,
4203                               fixedpoint_f16_i32, asm,
4204               [(set GPR32:$Rd, (OpN (fmul FPR16:$Rn,
4205                                           fixedpoint_f16_i32:$scale)))]> {
4206     let Inst{31} = 0; // 32-bit GPR flag
4207     let scale{5} = 1;
4208     let Predicates = [HasFullFP16];
4209   }
4210
4211   // Scaled half-precision to 64-bit
4212   def SXHri : BaseFPToInteger<0b11, rmode, opcode, FPR16, GPR64,
4213                               fixedpoint_f16_i64, asm,
4214               [(set GPR64:$Rd, (OpN (fmul FPR16:$Rn,
4215                                           fixedpoint_f16_i64:$scale)))]> {
4216     let Inst{31} = 1; // 64-bit GPR flag
4217     let Predicates = [HasFullFP16];
4218   }
4219
4220   // Scaled single-precision to 32-bit
4221   def SWSri : BaseFPToInteger<0b00, rmode, opcode, FPR32, GPR32,
4222                               fixedpoint_f32_i32, asm,
4223               [(set GPR32:$Rd, (OpN (fmul FPR32:$Rn,
4224                                           fixedpoint_f32_i32:$scale)))]> {
4225     let Inst{31} = 0; // 32-bit GPR flag
4226     let scale{5} = 1;
4227   }
4228
4229   // Scaled single-precision to 64-bit
4230   def SXSri : BaseFPToInteger<0b00, rmode, opcode, FPR32, GPR64,
4231                               fixedpoint_f32_i64, asm,
4232               [(set GPR64:$Rd, (OpN (fmul FPR32:$Rn,
4233                                           fixedpoint_f32_i64:$scale)))]> {
4234     let Inst{31} = 1; // 64-bit GPR flag
4235   }
4236
4237   // Scaled double-precision to 32-bit
4238   def SWDri : BaseFPToInteger<0b01, rmode, opcode, FPR64, GPR32,
4239                               fixedpoint_f64_i32, asm,
4240               [(set GPR32:$Rd, (OpN (fmul FPR64:$Rn,
4241                                           fixedpoint_f64_i32:$scale)))]> {
4242     let Inst{31} = 0; // 32-bit GPR flag
4243     let scale{5} = 1;
4244   }
4245
4246   // Scaled double-precision to 64-bit
4247   def SXDri : BaseFPToInteger<0b01, rmode, opcode, FPR64, GPR64,
4248                               fixedpoint_f64_i64, asm,
4249               [(set GPR64:$Rd, (OpN (fmul FPR64:$Rn,
4250                                           fixedpoint_f64_i64:$scale)))]> {
4251     let Inst{31} = 1; // 64-bit GPR flag
4252   }
4253 }
4254
4255 //---
4256 // Integer to floating point conversion
4257 //---
4258
4259 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
4260 class BaseIntegerToFP<bit isUnsigned,
4261                       RegisterClass srcType, RegisterClass dstType,
4262                       Operand immType, string asm, list<dag> pattern>
4263     : I<(outs dstType:$Rd), (ins srcType:$Rn, immType:$scale),
4264          asm, "\t$Rd, $Rn, $scale", "", pattern>,
4265       Sched<[WriteFCvt]> {
4266   bits<5> Rd;
4267   bits<5> Rn;
4268   bits<6> scale;
4269   let Inst{30-24} = 0b0011110;
4270   let Inst{21-17} = 0b00001;
4271   let Inst{16}    = isUnsigned;
4272   let Inst{15-10} = scale;
4273   let Inst{9-5}   = Rn;
4274   let Inst{4-0}   = Rd;
4275 }
4276
4277 class BaseIntegerToFPUnscaled<bit isUnsigned,
4278                       RegisterClass srcType, RegisterClass dstType,
4279                       ValueType dvt, string asm, SDNode node>
4280     : I<(outs dstType:$Rd), (ins srcType:$Rn),
4281          asm, "\t$Rd, $Rn", "", [(set (dvt dstType:$Rd), (node srcType:$Rn))]>,
4282       Sched<[WriteFCvt]> {
4283   bits<5> Rd;
4284   bits<5> Rn;
4285   bits<6> scale;
4286   let Inst{30-24} = 0b0011110;
4287   let Inst{21-17} = 0b10001;
4288   let Inst{16}    = isUnsigned;
4289   let Inst{15-10} = 0b000000;
4290   let Inst{9-5}   = Rn;
4291   let Inst{4-0}   = Rd;
4292 }
4293
4294 multiclass IntegerToFP<bit isUnsigned, string asm, SDNode node> {
4295   // Unscaled
4296   def UWHri: BaseIntegerToFPUnscaled<isUnsigned, GPR32, FPR16, f16, asm, node> {
4297     let Inst{31} = 0; // 32-bit GPR flag
4298     let Inst{23-22} = 0b11; // 16-bit FPR flag
4299     let Predicates = [HasFullFP16];
4300   }
4301
4302   def UWSri: BaseIntegerToFPUnscaled<isUnsigned, GPR32, FPR32, f32, asm, node> {
4303     let Inst{31} = 0; // 32-bit GPR flag
4304     let Inst{23-22} = 0b00; // 32-bit FPR flag
4305   }
4306
4307   def UWDri: BaseIntegerToFPUnscaled<isUnsigned, GPR32, FPR64, f64, asm, node> {
4308     let Inst{31} = 0; // 32-bit GPR flag
4309     let Inst{23-22} = 0b01; // 64-bit FPR flag
4310   }
4311
4312   def UXHri: BaseIntegerToFPUnscaled<isUnsigned, GPR64, FPR16, f16, asm, node> {
4313     let Inst{31} = 1; // 64-bit GPR flag
4314     let Inst{23-22} = 0b11; // 16-bit FPR flag
4315     let Predicates = [HasFullFP16];
4316   }
4317
4318   def UXSri: BaseIntegerToFPUnscaled<isUnsigned, GPR64, FPR32, f32, asm, node> {
4319     let Inst{31} = 1; // 64-bit GPR flag
4320     let Inst{23-22} = 0b00; // 32-bit FPR flag
4321   }
4322
4323   def UXDri: BaseIntegerToFPUnscaled<isUnsigned, GPR64, FPR64, f64, asm, node> {
4324     let Inst{31} = 1; // 64-bit GPR flag
4325     let Inst{23-22} = 0b01; // 64-bit FPR flag
4326   }
4327
4328   // Scaled
4329   def SWHri: BaseIntegerToFP<isUnsigned, GPR32, FPR16, fixedpoint_f16_i32, asm,
4330                              [(set FPR16:$Rd,
4331                                    (fdiv (node GPR32:$Rn),
4332                                          fixedpoint_f16_i32:$scale))]> {
4333     let Inst{31} = 0; // 32-bit GPR flag
4334     let Inst{23-22} = 0b11; // 16-bit FPR flag
4335     let scale{5} = 1;
4336     let Predicates = [HasFullFP16];
4337   }
4338
4339   def SWSri: BaseIntegerToFP<isUnsigned, GPR32, FPR32, fixedpoint_f32_i32, asm,
4340                              [(set FPR32:$Rd,
4341                                    (fdiv (node GPR32:$Rn),
4342                                          fixedpoint_f32_i32:$scale))]> {
4343     let Inst{31} = 0; // 32-bit GPR flag
4344     let Inst{23-22} = 0b00; // 32-bit FPR flag
4345     let scale{5} = 1;
4346   }
4347
4348   def SWDri: BaseIntegerToFP<isUnsigned, GPR32, FPR64, fixedpoint_f64_i32, asm,
4349                              [(set FPR64:$Rd,
4350                                    (fdiv (node GPR32:$Rn),
4351                                          fixedpoint_f64_i32:$scale))]> {
4352     let Inst{31} = 0; // 32-bit GPR flag
4353     let Inst{23-22} = 0b01; // 64-bit FPR flag
4354     let scale{5} = 1;
4355   }
4356
4357   def SXHri: BaseIntegerToFP<isUnsigned, GPR64, FPR16, fixedpoint_f16_i64, asm,
4358                              [(set FPR16:$Rd,
4359                                    (fdiv (node GPR64:$Rn),
4360                                          fixedpoint_f16_i64:$scale))]> {
4361     let Inst{31} = 1; // 64-bit GPR flag
4362     let Inst{23-22} = 0b11; // 16-bit FPR flag
4363     let Predicates = [HasFullFP16];
4364   }
4365
4366   def SXSri: BaseIntegerToFP<isUnsigned, GPR64, FPR32, fixedpoint_f32_i64, asm,
4367                              [(set FPR32:$Rd,
4368                                    (fdiv (node GPR64:$Rn),
4369                                          fixedpoint_f32_i64:$scale))]> {
4370     let Inst{31} = 1; // 64-bit GPR flag
4371     let Inst{23-22} = 0b00; // 32-bit FPR flag
4372   }
4373
4374   def SXDri: BaseIntegerToFP<isUnsigned, GPR64, FPR64, fixedpoint_f64_i64, asm,
4375                              [(set FPR64:$Rd,
4376                                    (fdiv (node GPR64:$Rn),
4377                                          fixedpoint_f64_i64:$scale))]> {
4378     let Inst{31} = 1; // 64-bit GPR flag
4379     let Inst{23-22} = 0b01; // 64-bit FPR flag
4380   }
4381 }
4382
4383 //---
4384 // Unscaled integer <-> floating point conversion (i.e. FMOV)
4385 //---
4386
4387 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4388 class BaseUnscaledConversion<bits<2> rmode, bits<3> opcode,
4389                       RegisterClass srcType, RegisterClass dstType,
4390                       string asm>
4391     : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd, $Rn", "",
4392         // We use COPY_TO_REGCLASS for these bitconvert operations.
4393         // copyPhysReg() expands the resultant COPY instructions after
4394         // regalloc is done. This gives greater freedom for the allocator
4395         // and related passes (coalescing, copy propagation, et. al.) to
4396         // be more effective.
4397         [/*(set (dvt dstType:$Rd), (bitconvert (svt srcType:$Rn)))*/]>,
4398       Sched<[WriteFCopy]> {
4399   bits<5> Rd;
4400   bits<5> Rn;
4401   let Inst{30-24} = 0b0011110;
4402   let Inst{21}    = 1;
4403   let Inst{20-19} = rmode;
4404   let Inst{18-16} = opcode;
4405   let Inst{15-10} = 0b000000;
4406   let Inst{9-5}   = Rn;
4407   let Inst{4-0}   = Rd;
4408 }
4409
4410 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4411 class BaseUnscaledConversionToHigh<bits<2> rmode, bits<3> opcode,
4412                      RegisterClass srcType, RegisterOperand dstType, string asm,
4413                      string kind>
4414     : I<(outs dstType:$Rd), (ins srcType:$Rn, VectorIndex1:$idx), asm,
4415         "{\t$Rd"#kind#"$idx, $Rn|"#kind#"\t$Rd$idx, $Rn}", "", []>,
4416       Sched<[WriteFCopy]> {
4417   bits<5> Rd;
4418   bits<5> Rn;
4419   let Inst{30-23} = 0b00111101;
4420   let Inst{21}    = 1;
4421   let Inst{20-19} = rmode;
4422   let Inst{18-16} = opcode;
4423   let Inst{15-10} = 0b000000;
4424   let Inst{9-5}   = Rn;
4425   let Inst{4-0}   = Rd;
4426
4427   let DecoderMethod =  "DecodeFMOVLaneInstruction";
4428 }
4429
4430 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4431 class BaseUnscaledConversionFromHigh<bits<2> rmode, bits<3> opcode,
4432                      RegisterOperand srcType, RegisterClass dstType, string asm,
4433                      string kind>
4434     : I<(outs dstType:$Rd), (ins srcType:$Rn, VectorIndex1:$idx), asm,
4435         "{\t$Rd, $Rn"#kind#"$idx|"#kind#"\t$Rd, $Rn$idx}", "", []>,
4436       Sched<[WriteFCopy]> {
4437   bits<5> Rd;
4438   bits<5> Rn;
4439   let Inst{30-23} = 0b00111101;
4440   let Inst{21}    = 1;
4441   let Inst{20-19} = rmode;
4442   let Inst{18-16} = opcode;
4443   let Inst{15-10} = 0b000000;
4444   let Inst{9-5}   = Rn;
4445   let Inst{4-0}   = Rd;
4446
4447   let DecoderMethod =  "DecodeFMOVLaneInstruction";
4448 }
4449
4450
4451 multiclass UnscaledConversion<string asm> {
4452   def WHr : BaseUnscaledConversion<0b00, 0b111, GPR32, FPR16, asm> {
4453     let Inst{31} = 0; // 32-bit GPR flag
4454     let Inst{23-22} = 0b11; // 16-bit FPR flag
4455     let Predicates = [HasFullFP16];
4456   }
4457
4458   def XHr : BaseUnscaledConversion<0b00, 0b111, GPR64, FPR16, asm> {
4459     let Inst{31} = 1; // 64-bit GPR flag
4460     let Inst{23-22} = 0b11; // 16-bit FPR flag
4461     let Predicates = [HasFullFP16];
4462   }
4463
4464   def WSr : BaseUnscaledConversion<0b00, 0b111, GPR32, FPR32, asm> {
4465     let Inst{31} = 0; // 32-bit GPR flag
4466     let Inst{23-22} = 0b00; // 32-bit FPR flag
4467   }
4468
4469   def XDr : BaseUnscaledConversion<0b00, 0b111, GPR64, FPR64, asm> {
4470     let Inst{31} = 1; // 64-bit GPR flag
4471     let Inst{23-22} = 0b01; // 64-bit FPR flag
4472   }
4473
4474   def HWr : BaseUnscaledConversion<0b00, 0b110, FPR16, GPR32, asm> {
4475     let Inst{31} = 0; // 32-bit GPR flag
4476     let Inst{23-22} = 0b11; // 16-bit FPR flag
4477     let Predicates = [HasFullFP16];
4478   }
4479
4480   def HXr : BaseUnscaledConversion<0b00, 0b110, FPR16, GPR64, asm> {
4481     let Inst{31} = 1; // 64-bit GPR flag
4482     let Inst{23-22} = 0b11; // 16-bit FPR flag
4483     let Predicates = [HasFullFP16];
4484   }
4485
4486   def SWr : BaseUnscaledConversion<0b00, 0b110, FPR32, GPR32, asm> {
4487     let Inst{31} = 0; // 32-bit GPR flag
4488     let Inst{23-22} = 0b00; // 32-bit FPR flag
4489   }
4490
4491   def DXr : BaseUnscaledConversion<0b00, 0b110, FPR64, GPR64, asm> {
4492     let Inst{31} = 1; // 64-bit GPR flag
4493     let Inst{23-22} = 0b01; // 64-bit FPR flag
4494   }
4495
4496   def XDHighr : BaseUnscaledConversionToHigh<0b01, 0b111, GPR64, V128,
4497                                              asm, ".d"> {
4498     let Inst{31} = 1;
4499     let Inst{22} = 0;
4500   }
4501
4502   def DXHighr : BaseUnscaledConversionFromHigh<0b01, 0b110, V128, GPR64,
4503                                                asm, ".d"> {
4504     let Inst{31} = 1;
4505     let Inst{22} = 0;
4506   }
4507 }
4508
4509 //---
4510 // Floating point conversion
4511 //---
4512
4513 class BaseFPConversion<bits<2> type, bits<2> opcode, RegisterClass dstType,
4514                        RegisterClass srcType, string asm, list<dag> pattern>
4515     : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd, $Rn", "", pattern>,
4516       Sched<[WriteFCvt]> {
4517   bits<5> Rd;
4518   bits<5> Rn;
4519   let Inst{31-24} = 0b00011110;
4520   let Inst{23-22} = type;
4521   let Inst{21-17} = 0b10001;
4522   let Inst{16-15} = opcode;
4523   let Inst{14-10} = 0b10000;
4524   let Inst{9-5}   = Rn;
4525   let Inst{4-0}   = Rd;
4526 }
4527
4528 multiclass FPConversion<string asm> {
4529   // Double-precision to Half-precision
4530   def HDr : BaseFPConversion<0b01, 0b11, FPR16, FPR64, asm,
4531                              [(set FPR16:$Rd, (fpround FPR64:$Rn))]>;
4532
4533   // Double-precision to Single-precision
4534   def SDr : BaseFPConversion<0b01, 0b00, FPR32, FPR64, asm,
4535                              [(set FPR32:$Rd, (fpround FPR64:$Rn))]>;
4536
4537   // Half-precision to Double-precision
4538   def DHr : BaseFPConversion<0b11, 0b01, FPR64, FPR16, asm,
4539                              [(set FPR64:$Rd, (fpextend FPR16:$Rn))]>;
4540
4541   // Half-precision to Single-precision
4542   def SHr : BaseFPConversion<0b11, 0b00, FPR32, FPR16, asm,
4543                              [(set FPR32:$Rd, (fpextend FPR16:$Rn))]>;
4544
4545   // Single-precision to Double-precision
4546   def DSr : BaseFPConversion<0b00, 0b01, FPR64, FPR32, asm,
4547                              [(set FPR64:$Rd, (fpextend FPR32:$Rn))]>;
4548
4549   // Single-precision to Half-precision
4550   def HSr : BaseFPConversion<0b00, 0b11, FPR16, FPR32, asm,
4551                              [(set FPR16:$Rd, (fpround FPR32:$Rn))]>;
4552 }
4553
4554 //---
4555 // Single operand floating point data processing
4556 //---
4557
4558 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4559 class BaseSingleOperandFPData<bits<6> opcode, RegisterClass regtype,
4560                               ValueType vt, string asm, SDPatternOperator node>
4561     : I<(outs regtype:$Rd), (ins regtype:$Rn), asm, "\t$Rd, $Rn", "",
4562          [(set (vt regtype:$Rd), (node (vt regtype:$Rn)))]>,
4563       Sched<[WriteF]> {
4564   bits<5> Rd;
4565   bits<5> Rn;
4566   let Inst{31-24} = 0b00011110;
4567   let Inst{21}    = 0b1;
4568   let Inst{20-15} = opcode;
4569   let Inst{14-10} = 0b10000;
4570   let Inst{9-5}   = Rn;
4571   let Inst{4-0}   = Rd;
4572 }
4573
4574 multiclass SingleOperandFPData<bits<4> opcode, string asm,
4575                                SDPatternOperator node = null_frag> {
4576
4577   def Hr : BaseSingleOperandFPData<{0b00,opcode}, FPR16, f16, asm, node> {
4578     let Inst{23-22} = 0b11; // 16-bit size flag
4579     let Predicates = [HasFullFP16];
4580   }
4581
4582   def Sr : BaseSingleOperandFPData<{0b00,opcode}, FPR32, f32, asm, node> {
4583     let Inst{23-22} = 0b00; // 32-bit size flag
4584   }
4585
4586   def Dr : BaseSingleOperandFPData<{0b00,opcode}, FPR64, f64, asm, node> {
4587     let Inst{23-22} = 0b01; // 64-bit size flag
4588   }
4589 }
4590
4591 multiclass SingleOperandFPNo16<bits<6> opcode, string asm,
4592                   SDPatternOperator node = null_frag>{
4593
4594   def Sr : BaseSingleOperandFPData<opcode, FPR32, f32, asm, node> {
4595     let Inst{23-22} = 0b00; // 32-bit registers
4596   }
4597
4598   def Dr : BaseSingleOperandFPData<opcode, FPR64, f64, asm, node> {
4599     let Inst{23-22} = 0b01; // 64-bit registers
4600   }
4601 }
4602
4603 // FRInt[32|64][Z|N] instructions
4604 multiclass FRIntNNT<bits<2> opcode, string asm, SDPatternOperator node = null_frag> :
4605       SingleOperandFPNo16<{0b0100,opcode}, asm, node>;
4606
4607 //---
4608 // Two operand floating point data processing
4609 //---
4610
4611 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4612 class BaseTwoOperandFPData<bits<4> opcode, RegisterClass regtype,
4613                            string asm, list<dag> pat>
4614     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
4615          asm, "\t$Rd, $Rn, $Rm", "", pat>,
4616       Sched<[WriteF]> {
4617   bits<5> Rd;
4618   bits<5> Rn;
4619   bits<5> Rm;
4620   let Inst{31-24} = 0b00011110;
4621   let Inst{21}    = 1;
4622   let Inst{20-16} = Rm;
4623   let Inst{15-12} = opcode;
4624   let Inst{11-10} = 0b10;
4625   let Inst{9-5}   = Rn;
4626   let Inst{4-0}   = Rd;
4627 }
4628
4629 multiclass TwoOperandFPData<bits<4> opcode, string asm,
4630                             SDPatternOperator node = null_frag> {
4631   def Hrr : BaseTwoOperandFPData<opcode, FPR16, asm,
4632                          [(set (f16 FPR16:$Rd),
4633                                (node (f16 FPR16:$Rn), (f16 FPR16:$Rm)))]> {
4634     let Inst{23-22} = 0b11; // 16-bit size flag
4635     let Predicates = [HasFullFP16];
4636   }
4637
4638   def Srr : BaseTwoOperandFPData<opcode, FPR32, asm,
4639                          [(set (f32 FPR32:$Rd),
4640                                (node (f32 FPR32:$Rn), (f32 FPR32:$Rm)))]> {
4641     let Inst{23-22} = 0b00; // 32-bit size flag
4642   }
4643
4644   def Drr : BaseTwoOperandFPData<opcode, FPR64, asm,
4645                          [(set (f64 FPR64:$Rd),
4646                                (node (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]> {
4647     let Inst{23-22} = 0b01; // 64-bit size flag
4648   }
4649 }
4650
4651 multiclass TwoOperandFPDataNeg<bits<4> opcode, string asm, SDNode node> {
4652   def Hrr : BaseTwoOperandFPData<opcode, FPR16, asm,
4653                   [(set FPR16:$Rd, (fneg (node FPR16:$Rn, (f16 FPR16:$Rm))))]> {
4654     let Inst{23-22} = 0b11; // 16-bit size flag
4655     let Predicates = [HasFullFP16];
4656   }
4657
4658   def Srr : BaseTwoOperandFPData<opcode, FPR32, asm,
4659                   [(set FPR32:$Rd, (fneg (node FPR32:$Rn, (f32 FPR32:$Rm))))]> {
4660     let Inst{23-22} = 0b00; // 32-bit size flag
4661   }
4662
4663   def Drr : BaseTwoOperandFPData<opcode, FPR64, asm,
4664                   [(set FPR64:$Rd, (fneg (node FPR64:$Rn, (f64 FPR64:$Rm))))]> {
4665     let Inst{23-22} = 0b01; // 64-bit size flag
4666   }
4667 }
4668
4669
4670 //---
4671 // Three operand floating point data processing
4672 //---
4673
4674 class BaseThreeOperandFPData<bit isNegated, bit isSub,
4675                              RegisterClass regtype, string asm, list<dag> pat>
4676     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, regtype: $Ra),
4677          asm, "\t$Rd, $Rn, $Rm, $Ra", "", pat>,
4678       Sched<[WriteFMul]> {
4679   bits<5> Rd;
4680   bits<5> Rn;
4681   bits<5> Rm;
4682   bits<5> Ra;
4683   let Inst{31-24} = 0b00011111;
4684   let Inst{21}    = isNegated;
4685   let Inst{20-16} = Rm;
4686   let Inst{15}    = isSub;
4687   let Inst{14-10} = Ra;
4688   let Inst{9-5}   = Rn;
4689   let Inst{4-0}   = Rd;
4690 }
4691
4692 multiclass ThreeOperandFPData<bit isNegated, bit isSub,string asm,
4693                               SDPatternOperator node> {
4694   def Hrrr : BaseThreeOperandFPData<isNegated, isSub, FPR16, asm,
4695             [(set FPR16:$Rd,
4696                   (node (f16 FPR16:$Rn), (f16 FPR16:$Rm), (f16 FPR16:$Ra)))]> {
4697     let Inst{23-22} = 0b11; // 16-bit size flag
4698     let Predicates = [HasFullFP16];
4699   }
4700
4701   def Srrr : BaseThreeOperandFPData<isNegated, isSub, FPR32, asm,
4702             [(set FPR32:$Rd,
4703                   (node (f32 FPR32:$Rn), (f32 FPR32:$Rm), (f32 FPR32:$Ra)))]> {
4704     let Inst{23-22} = 0b00; // 32-bit size flag
4705   }
4706
4707   def Drrr : BaseThreeOperandFPData<isNegated, isSub, FPR64, asm,
4708             [(set FPR64:$Rd,
4709                   (node (f64 FPR64:$Rn), (f64 FPR64:$Rm), (f64 FPR64:$Ra)))]> {
4710     let Inst{23-22} = 0b01; // 64-bit size flag
4711   }
4712 }
4713
4714 //---
4715 // Floating point data comparisons
4716 //---
4717
4718 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4719 class BaseOneOperandFPComparison<bit signalAllNans,
4720                                  RegisterClass regtype, string asm,
4721                                  list<dag> pat>
4722     : I<(outs), (ins regtype:$Rn), asm, "\t$Rn, #0.0", "", pat>,
4723       Sched<[WriteFCmp]> {
4724   bits<5> Rn;
4725   let Inst{31-24} = 0b00011110;
4726   let Inst{21}    = 1;
4727
4728   let Inst{15-10} = 0b001000;
4729   let Inst{9-5}   = Rn;
4730   let Inst{4}     = signalAllNans;
4731   let Inst{3-0}   = 0b1000;
4732
4733   // Rm should be 0b00000 canonically, but we need to accept any value.
4734   let PostEncoderMethod = "fixOneOperandFPComparison";
4735 }
4736
4737 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4738 class BaseTwoOperandFPComparison<bit signalAllNans, RegisterClass regtype,
4739                                 string asm, list<dag> pat>
4740     : I<(outs), (ins regtype:$Rn, regtype:$Rm), asm, "\t$Rn, $Rm", "", pat>,
4741       Sched<[WriteFCmp]> {
4742   bits<5> Rm;
4743   bits<5> Rn;
4744   let Inst{31-24} = 0b00011110;
4745   let Inst{21}    = 1;
4746   let Inst{20-16} = Rm;
4747   let Inst{15-10} = 0b001000;
4748   let Inst{9-5}   = Rn;
4749   let Inst{4}     = signalAllNans;
4750   let Inst{3-0}   = 0b0000;
4751 }
4752
4753 multiclass FPComparison<bit signalAllNans, string asm,
4754                         SDPatternOperator OpNode = null_frag> {
4755   let Defs = [NZCV] in {
4756   def Hrr : BaseTwoOperandFPComparison<signalAllNans, FPR16, asm,
4757       [(OpNode FPR16:$Rn, (f16 FPR16:$Rm)), (implicit NZCV)]> {
4758     let Inst{23-22} = 0b11;
4759     let Predicates = [HasFullFP16];
4760   }
4761
4762   def Hri : BaseOneOperandFPComparison<signalAllNans, FPR16, asm,
4763       [(OpNode (f16 FPR16:$Rn), fpimm0), (implicit NZCV)]> {
4764     let Inst{23-22} = 0b11;
4765     let Predicates = [HasFullFP16];
4766   }
4767
4768   def Srr : BaseTwoOperandFPComparison<signalAllNans, FPR32, asm,
4769       [(OpNode FPR32:$Rn, (f32 FPR32:$Rm)), (implicit NZCV)]> {
4770     let Inst{23-22} = 0b00;
4771   }
4772
4773   def Sri : BaseOneOperandFPComparison<signalAllNans, FPR32, asm,
4774       [(OpNode (f32 FPR32:$Rn), fpimm0), (implicit NZCV)]> {
4775     let Inst{23-22} = 0b00;
4776   }
4777
4778   def Drr : BaseTwoOperandFPComparison<signalAllNans, FPR64, asm,
4779       [(OpNode FPR64:$Rn, (f64 FPR64:$Rm)), (implicit NZCV)]> {
4780     let Inst{23-22} = 0b01;
4781   }
4782
4783   def Dri : BaseOneOperandFPComparison<signalAllNans, FPR64, asm,
4784       [(OpNode (f64 FPR64:$Rn), fpimm0), (implicit NZCV)]> {
4785     let Inst{23-22} = 0b01;
4786   }
4787   } // Defs = [NZCV]
4788 }
4789
4790 //---
4791 // Floating point conditional comparisons
4792 //---
4793
4794 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4795 class BaseFPCondComparison<bit signalAllNans, RegisterClass regtype,
4796                            string mnemonic, list<dag> pat>
4797     : I<(outs), (ins regtype:$Rn, regtype:$Rm, imm32_0_15:$nzcv, ccode:$cond),
4798          mnemonic, "\t$Rn, $Rm, $nzcv, $cond", "", pat>,
4799       Sched<[WriteFCmp]> {
4800   let Uses = [NZCV];
4801   let Defs = [NZCV];
4802
4803   bits<5> Rn;
4804   bits<5> Rm;
4805   bits<4> nzcv;
4806   bits<4> cond;
4807
4808   let Inst{31-24} = 0b00011110;
4809   let Inst{21}    = 1;
4810   let Inst{20-16} = Rm;
4811   let Inst{15-12} = cond;
4812   let Inst{11-10} = 0b01;
4813   let Inst{9-5}   = Rn;
4814   let Inst{4}     = signalAllNans;
4815   let Inst{3-0}   = nzcv;
4816 }
4817
4818 multiclass FPCondComparison<bit signalAllNans, string mnemonic,
4819                             SDPatternOperator OpNode = null_frag> {
4820   def Hrr : BaseFPCondComparison<signalAllNans, FPR16, mnemonic,
4821       [(set NZCV, (OpNode (f16 FPR16:$Rn), (f16 FPR16:$Rm), (i32 imm:$nzcv),
4822                           (i32 imm:$cond), NZCV))]> {
4823     let Inst{23-22} = 0b11;
4824     let Predicates = [HasFullFP16];
4825   }
4826
4827   def Srr : BaseFPCondComparison<signalAllNans, FPR32, mnemonic,
4828       [(set NZCV, (OpNode (f32 FPR32:$Rn), (f32 FPR32:$Rm), (i32 imm:$nzcv),
4829                           (i32 imm:$cond), NZCV))]> {
4830     let Inst{23-22} = 0b00;
4831   }
4832
4833   def Drr : BaseFPCondComparison<signalAllNans, FPR64, mnemonic,
4834       [(set NZCV, (OpNode (f64 FPR64:$Rn), (f64 FPR64:$Rm), (i32 imm:$nzcv),
4835                           (i32 imm:$cond), NZCV))]> {
4836     let Inst{23-22} = 0b01;
4837   }
4838 }
4839
4840 //---
4841 // Floating point conditional select
4842 //---
4843
4844 class BaseFPCondSelect<RegisterClass regtype, ValueType vt, string asm>
4845     : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
4846          asm, "\t$Rd, $Rn, $Rm, $cond", "",
4847          [(set regtype:$Rd,
4848                (AArch64csel (vt regtype:$Rn), regtype:$Rm,
4849                           (i32 imm:$cond), NZCV))]>,
4850       Sched<[WriteF]> {
4851   bits<5> Rd;
4852   bits<5> Rn;
4853   bits<5> Rm;
4854   bits<4> cond;
4855
4856   let Inst{31-24} = 0b00011110;
4857   let Inst{21}    = 1;
4858   let Inst{20-16} = Rm;
4859   let Inst{15-12} = cond;
4860   let Inst{11-10} = 0b11;
4861   let Inst{9-5}   = Rn;
4862   let Inst{4-0}   = Rd;
4863 }
4864
4865 multiclass FPCondSelect<string asm> {
4866   let Uses = [NZCV] in {
4867   def Hrrr : BaseFPCondSelect<FPR16, f16, asm> {
4868     let Inst{23-22} = 0b11;
4869     let Predicates = [HasFullFP16];
4870   }
4871
4872   def Srrr : BaseFPCondSelect<FPR32, f32, asm> {
4873     let Inst{23-22} = 0b00;
4874   }
4875
4876   def Drrr : BaseFPCondSelect<FPR64, f64, asm> {
4877     let Inst{23-22} = 0b01;
4878   }
4879   } // Uses = [NZCV]
4880 }
4881
4882 //---
4883 // Floating move immediate
4884 //---
4885
4886 class BaseFPMoveImmediate<RegisterClass regtype, Operand fpimmtype, string asm>
4887   : I<(outs regtype:$Rd), (ins fpimmtype:$imm), asm, "\t$Rd, $imm", "",
4888       [(set regtype:$Rd, fpimmtype:$imm)]>,
4889     Sched<[WriteFImm]> {
4890   bits<5> Rd;
4891   bits<8> imm;
4892   let Inst{31-24} = 0b00011110;
4893   let Inst{21}    = 1;
4894   let Inst{20-13} = imm;
4895   let Inst{12-5}  = 0b10000000;
4896   let Inst{4-0}   = Rd;
4897 }
4898
4899 multiclass FPMoveImmediate<string asm> {
4900   def Hi : BaseFPMoveImmediate<FPR16, fpimm16, asm> {
4901     let Inst{23-22} = 0b11;
4902     let Predicates = [HasFullFP16];
4903   }
4904
4905   def Si : BaseFPMoveImmediate<FPR32, fpimm32, asm> {
4906     let Inst{23-22} = 0b00;
4907   }
4908
4909   def Di : BaseFPMoveImmediate<FPR64, fpimm64, asm> {
4910     let Inst{23-22} = 0b01;
4911   }
4912 }
4913 } // end of 'let Predicates = [HasFPARMv8]'
4914
4915 //----------------------------------------------------------------------------
4916 // AdvSIMD
4917 //----------------------------------------------------------------------------
4918
4919 let Predicates = [HasNEON] in {
4920
4921 //----------------------------------------------------------------------------
4922 // AdvSIMD three register vector instructions
4923 //----------------------------------------------------------------------------
4924
4925 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4926 class BaseSIMDThreeSameVector<bit Q, bit U, bits<3> size, bits<5> opcode,
4927                         RegisterOperand regtype, string asm, string kind,
4928                         list<dag> pattern>
4929   : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
4930       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
4931       "|" # kind # "\t$Rd, $Rn, $Rm|}", "", pattern>,
4932     Sched<[WriteV]> {
4933   bits<5> Rd;
4934   bits<5> Rn;
4935   bits<5> Rm;
4936   let Inst{31}    = 0;
4937   let Inst{30}    = Q;
4938   let Inst{29}    = U;
4939   let Inst{28-24} = 0b01110;
4940   let Inst{23-21} = size;
4941   let Inst{20-16} = Rm;
4942   let Inst{15-11} = opcode;
4943   let Inst{10}    = 1;
4944   let Inst{9-5}   = Rn;
4945   let Inst{4-0}   = Rd;
4946 }
4947
4948 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4949 class BaseSIMDThreeSameVectorTied<bit Q, bit U, bits<3> size, bits<5> opcode,
4950                         RegisterOperand regtype, string asm, string kind,
4951                         list<dag> pattern>
4952   : I<(outs regtype:$dst), (ins regtype:$Rd, regtype:$Rn, regtype:$Rm), asm,
4953       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
4954       "|" # kind # "\t$Rd, $Rn, $Rm}", "$Rd = $dst", pattern>,
4955     Sched<[WriteV]> {
4956   bits<5> Rd;
4957   bits<5> Rn;
4958   bits<5> Rm;
4959   let Inst{31}    = 0;
4960   let Inst{30}    = Q;
4961   let Inst{29}    = U;
4962   let Inst{28-24} = 0b01110;
4963   let Inst{23-21} = size;
4964   let Inst{20-16} = Rm;
4965   let Inst{15-11} = opcode;
4966   let Inst{10}    = 1;
4967   let Inst{9-5}   = Rn;
4968   let Inst{4-0}   = Rd;
4969 }
4970
4971 // All operand sizes distinguished in the encoding.
4972 multiclass SIMDThreeSameVector<bit U, bits<5> opc, string asm,
4973                                SDPatternOperator OpNode> {
4974   def v8i8  : BaseSIMDThreeSameVector<0, U, 0b001, opc, V64,
4975                                       asm, ".8b",
4976          [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
4977   def v16i8 : BaseSIMDThreeSameVector<1, U, 0b001, opc, V128,
4978                                       asm, ".16b",
4979          [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
4980   def v4i16 : BaseSIMDThreeSameVector<0, U, 0b011, opc, V64,
4981                                       asm, ".4h",
4982          [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
4983   def v8i16 : BaseSIMDThreeSameVector<1, U, 0b011, opc, V128,
4984                                       asm, ".8h",
4985          [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
4986   def v2i32 : BaseSIMDThreeSameVector<0, U, 0b101, opc, V64,
4987                                       asm, ".2s",
4988          [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
4989   def v4i32 : BaseSIMDThreeSameVector<1, U, 0b101, opc, V128,
4990                                       asm, ".4s",
4991          [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
4992   def v2i64 : BaseSIMDThreeSameVector<1, U, 0b111, opc, V128,
4993                                       asm, ".2d",
4994          [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (v2i64 V128:$Rm)))]>;
4995 }
4996
4997 // As above, but D sized elements unsupported.
4998 multiclass SIMDThreeSameVectorBHS<bit U, bits<5> opc, string asm,
4999                                   SDPatternOperator OpNode> {
5000   def v8i8  : BaseSIMDThreeSameVector<0, U, 0b001, opc, V64,
5001                                       asm, ".8b",
5002         [(set V64:$Rd, (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm))))]>;
5003   def v16i8 : BaseSIMDThreeSameVector<1, U, 0b001, opc, V128,
5004                                       asm, ".16b",
5005         [(set V128:$Rd, (v16i8 (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm))))]>;
5006   def v4i16 : BaseSIMDThreeSameVector<0, U, 0b011, opc, V64,
5007                                       asm, ".4h",
5008         [(set V64:$Rd, (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm))))]>;
5009   def v8i16 : BaseSIMDThreeSameVector<1, U, 0b011, opc, V128,
5010                                       asm, ".8h",
5011         [(set V128:$Rd, (v8i16 (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm))))]>;
5012   def v2i32 : BaseSIMDThreeSameVector<0, U, 0b101, opc, V64,
5013                                       asm, ".2s",
5014         [(set V64:$Rd, (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm))))]>;
5015   def v4i32 : BaseSIMDThreeSameVector<1, U, 0b101, opc, V128,
5016                                       asm, ".4s",
5017         [(set V128:$Rd, (v4i32 (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm))))]>;
5018 }
5019
5020 multiclass SIMDThreeSameVectorBHSTied<bit U, bits<5> opc, string asm,
5021                                   SDPatternOperator OpNode> {
5022   def v8i8  : BaseSIMDThreeSameVectorTied<0, U, 0b001, opc, V64,
5023                                       asm, ".8b",
5024       [(set (v8i8 V64:$dst),
5025             (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
5026   def v16i8 : BaseSIMDThreeSameVectorTied<1, U, 0b001, opc, V128,
5027                                       asm, ".16b",
5028       [(set (v16i8 V128:$dst),
5029             (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
5030   def v4i16 : BaseSIMDThreeSameVectorTied<0, U, 0b011, opc, V64,
5031                                       asm, ".4h",
5032       [(set (v4i16 V64:$dst),
5033             (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
5034   def v8i16 : BaseSIMDThreeSameVectorTied<1, U, 0b011, opc, V128,
5035                                       asm, ".8h",
5036       [(set (v8i16 V128:$dst),
5037             (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
5038   def v2i32 : BaseSIMDThreeSameVectorTied<0, U, 0b101, opc, V64,
5039                                       asm, ".2s",
5040       [(set (v2i32 V64:$dst),
5041             (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
5042   def v4i32 : BaseSIMDThreeSameVectorTied<1, U, 0b101, opc, V128,
5043                                       asm, ".4s",
5044       [(set (v4i32 V128:$dst),
5045             (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
5046 }
5047
5048 // As above, but only B sized elements supported.
5049 multiclass SIMDThreeSameVectorB<bit U, bits<5> opc, string asm,
5050                                 SDPatternOperator OpNode> {
5051   def v8i8  : BaseSIMDThreeSameVector<0, U, 0b001, opc, V64,
5052                                       asm, ".8b",
5053     [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
5054   def v16i8 : BaseSIMDThreeSameVector<1, U, 0b001, opc, V128,
5055                                       asm, ".16b",
5056     [(set (v16i8 V128:$Rd),
5057           (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
5058 }
5059
5060 // As above, but only floating point elements supported.
5061 multiclass SIMDThreeSameVectorFP<bit U, bit S, bits<3> opc,
5062                                  string asm, SDPatternOperator OpNode> {
5063   let Predicates = [HasNEON, HasFullFP16] in {
5064   def v4f16 : BaseSIMDThreeSameVector<0, U, {S,0b10}, {0b00,opc}, V64,
5065                                       asm, ".4h",
5066         [(set (v4f16 V64:$Rd), (OpNode (v4f16 V64:$Rn), (v4f16 V64:$Rm)))]>;
5067   def v8f16 : BaseSIMDThreeSameVector<1, U, {S,0b10}, {0b00,opc}, V128,
5068                                       asm, ".8h",
5069         [(set (v8f16 V128:$Rd), (OpNode (v8f16 V128:$Rn), (v8f16 V128:$Rm)))]>;
5070   } // Predicates = [HasNEON, HasFullFP16]
5071   def v2f32 : BaseSIMDThreeSameVector<0, U, {S,0b01}, {0b11,opc}, V64,
5072                                       asm, ".2s",
5073         [(set (v2f32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
5074   def v4f32 : BaseSIMDThreeSameVector<1, U, {S,0b01}, {0b11,opc}, V128,
5075                                       asm, ".4s",
5076         [(set (v4f32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
5077   def v2f64 : BaseSIMDThreeSameVector<1, U, {S,0b11}, {0b11,opc}, V128,
5078                                       asm, ".2d",
5079         [(set (v2f64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
5080 }
5081
5082 multiclass SIMDThreeSameVectorFPCmp<bit U, bit S, bits<3> opc,
5083                                     string asm,
5084                                     SDPatternOperator OpNode> {
5085   let Predicates = [HasNEON, HasFullFP16] in {
5086   def v4f16 : BaseSIMDThreeSameVector<0, U, {S,0b10}, {0b00,opc}, V64,
5087                                       asm, ".4h",
5088         [(set (v4i16 V64:$Rd), (OpNode (v4f16 V64:$Rn), (v4f16 V64:$Rm)))]>;
5089   def v8f16 : BaseSIMDThreeSameVector<1, U, {S,0b10}, {0b00,opc}, V128,
5090                                       asm, ".8h",
5091         [(set (v8i16 V128:$Rd), (OpNode (v8f16 V128:$Rn), (v8f16 V128:$Rm)))]>;
5092   } // Predicates = [HasNEON, HasFullFP16]
5093   def v2f32 : BaseSIMDThreeSameVector<0, U, {S,0b01}, {0b11,opc}, V64,
5094                                       asm, ".2s",
5095         [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
5096   def v4f32 : BaseSIMDThreeSameVector<1, U, {S,0b01}, {0b11,opc}, V128,
5097                                       asm, ".4s",
5098         [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
5099   def v2f64 : BaseSIMDThreeSameVector<1, U, {S,0b11}, {0b11,opc}, V128,
5100                                       asm, ".2d",
5101         [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
5102 }
5103
5104 multiclass SIMDThreeSameVectorFPTied<bit U, bit S, bits<3> opc,
5105                                  string asm, SDPatternOperator OpNode> {
5106   let Predicates = [HasNEON, HasFullFP16] in {
5107   def v4f16 : BaseSIMDThreeSameVectorTied<0, U, {S,0b10}, {0b00,opc}, V64,
5108                                       asm, ".4h",
5109      [(set (v4f16 V64:$dst),
5110            (OpNode (v4f16 V64:$Rd), (v4f16 V64:$Rn), (v4f16 V64:$Rm)))]>;
5111   def v8f16 : BaseSIMDThreeSameVectorTied<1, U, {S,0b10}, {0b00,opc}, V128,
5112                                       asm, ".8h",
5113      [(set (v8f16 V128:$dst),
5114            (OpNode (v8f16 V128:$Rd), (v8f16 V128:$Rn), (v8f16 V128:$Rm)))]>;
5115   } // Predicates = [HasNEON, HasFullFP16]
5116   def v2f32 : BaseSIMDThreeSameVectorTied<0, U, {S,0b01}, {0b11,opc}, V64,
5117                                       asm, ".2s",
5118      [(set (v2f32 V64:$dst),
5119            (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
5120   def v4f32 : BaseSIMDThreeSameVectorTied<1, U, {S,0b01}, {0b11,opc}, V128,
5121                                       asm, ".4s",
5122      [(set (v4f32 V128:$dst),
5123            (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
5124   def v2f64 : BaseSIMDThreeSameVectorTied<1, U, {S,0b11}, {0b11,opc}, V128,
5125                                       asm, ".2d",
5126      [(set (v2f64 V128:$dst),
5127            (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
5128 }
5129
5130 // As above, but D and B sized elements unsupported.
5131 multiclass SIMDThreeSameVectorHS<bit U, bits<5> opc, string asm,
5132                                 SDPatternOperator OpNode> {
5133   def v4i16 : BaseSIMDThreeSameVector<0, U, 0b011, opc, V64,
5134                                       asm, ".4h",
5135         [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
5136   def v8i16 : BaseSIMDThreeSameVector<1, U, 0b011, opc, V128,
5137                                       asm, ".8h",
5138         [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
5139   def v2i32 : BaseSIMDThreeSameVector<0, U, 0b101, opc, V64,
5140                                       asm, ".2s",
5141         [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
5142   def v4i32 : BaseSIMDThreeSameVector<1, U, 0b101, opc, V128,
5143                                       asm, ".4s",
5144         [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
5145 }
5146
5147 // Logical three vector ops share opcode bits, and only use B sized elements.
5148 multiclass SIMDLogicalThreeVector<bit U, bits<2> size, string asm,
5149                                   SDPatternOperator OpNode = null_frag> {
5150   def v8i8  : BaseSIMDThreeSameVector<0, U, {size,1}, 0b00011, V64,
5151                                      asm, ".8b",
5152                          [(set (v8i8 V64:$Rd), (OpNode V64:$Rn, V64:$Rm))]>;
5153   def v16i8  : BaseSIMDThreeSameVector<1, U, {size,1}, 0b00011, V128,
5154                                      asm, ".16b",
5155                          [(set (v16i8 V128:$Rd), (OpNode V128:$Rn, V128:$Rm))]>;
5156
5157   def : Pat<(v4i16 (OpNode V64:$LHS, V64:$RHS)),
5158           (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
5159   def : Pat<(v2i32 (OpNode V64:$LHS, V64:$RHS)),
5160           (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
5161   def : Pat<(v1i64 (OpNode V64:$LHS, V64:$RHS)),
5162           (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
5163
5164   def : Pat<(v8i16 (OpNode V128:$LHS, V128:$RHS)),
5165       (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
5166   def : Pat<(v4i32 (OpNode V128:$LHS, V128:$RHS)),
5167       (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
5168   def : Pat<(v2i64 (OpNode V128:$LHS, V128:$RHS)),
5169       (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
5170 }
5171
5172 multiclass SIMDLogicalThreeVectorTied<bit U, bits<2> size,
5173                                   string asm, SDPatternOperator OpNode> {
5174   def v8i8  : BaseSIMDThreeSameVectorTied<0, U, {size,1}, 0b00011, V64,
5175                                      asm, ".8b",
5176              [(set (v8i8 V64:$dst),
5177                    (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
5178   def v16i8  : BaseSIMDThreeSameVectorTied<1, U, {size,1}, 0b00011, V128,
5179                                      asm, ".16b",
5180              [(set (v16i8 V128:$dst),
5181                    (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
5182                            (v16i8 V128:$Rm)))]>;
5183
5184   def : Pat<(v4i16 (OpNode (v4i16 V64:$LHS), (v4i16 V64:$MHS),
5185                            (v4i16 V64:$RHS))),
5186           (!cast<Instruction>(NAME#"v8i8")
5187             V64:$LHS, V64:$MHS, V64:$RHS)>;
5188   def : Pat<(v2i32 (OpNode (v2i32 V64:$LHS), (v2i32 V64:$MHS),
5189                            (v2i32 V64:$RHS))),
5190           (!cast<Instruction>(NAME#"v8i8")
5191             V64:$LHS, V64:$MHS, V64:$RHS)>;
5192   def : Pat<(v1i64 (OpNode (v1i64 V64:$LHS), (v1i64 V64:$MHS),
5193                            (v1i64 V64:$RHS))),
5194           (!cast<Instruction>(NAME#"v8i8")
5195             V64:$LHS, V64:$MHS, V64:$RHS)>;
5196
5197   def : Pat<(v8i16 (OpNode (v8i16 V128:$LHS), (v8i16 V128:$MHS),
5198                            (v8i16 V128:$RHS))),
5199       (!cast<Instruction>(NAME#"v16i8")
5200         V128:$LHS, V128:$MHS, V128:$RHS)>;
5201   def : Pat<(v4i32 (OpNode (v4i32 V128:$LHS), (v4i32 V128:$MHS),
5202                            (v4i32 V128:$RHS))),
5203       (!cast<Instruction>(NAME#"v16i8")
5204         V128:$LHS, V128:$MHS, V128:$RHS)>;
5205   def : Pat<(v2i64 (OpNode (v2i64 V128:$LHS), (v2i64 V128:$MHS),
5206                            (v2i64 V128:$RHS))),
5207       (!cast<Instruction>(NAME#"v16i8")
5208         V128:$LHS, V128:$MHS, V128:$RHS)>;
5209 }
5210
5211 // ARMv8.2-A Dot Product Instructions (Vector): These instructions extract
5212 // bytes from S-sized elements.
5213 class BaseSIMDThreeSameVectorDot<bit Q, bit U, string asm, string kind1,
5214                                  string kind2, RegisterOperand RegType,
5215                                  ValueType AccumType, ValueType InputType,
5216                                  SDPatternOperator OpNode> :
5217         BaseSIMDThreeSameVectorTied<Q, U, 0b100, 0b10010, RegType, asm, kind1,
5218         [(set (AccumType RegType:$dst),
5219               (OpNode (AccumType RegType:$Rd),
5220                       (InputType RegType:$Rn),
5221                       (InputType RegType:$Rm)))]> {
5222   let AsmString = !strconcat(asm, "{\t$Rd" # kind1 # ", $Rn" # kind2 # ", $Rm" # kind2 # "}");
5223 }
5224
5225 multiclass SIMDThreeSameVectorDot<bit U, string asm, SDPatternOperator OpNode> {
5226   def v8i8  : BaseSIMDThreeSameVectorDot<0, U, asm, ".2s", ".8b", V64,
5227                                          v2i32, v8i8, OpNode>;
5228   def v16i8 : BaseSIMDThreeSameVectorDot<1, U, asm, ".4s", ".16b", V128,
5229                                          v4i32, v16i8, OpNode>;
5230 }
5231
5232 // ARMv8.2-A Fused Multiply Add-Long Instructions (Vector): These instructions
5233 // select inputs from 4H vectors and accumulate outputs to a 2S vector (or from
5234 // 8H to 4S, when Q=1).
5235 class BaseSIMDThreeSameVectorFML<bit Q, bit U, bit b13, bits<3> size, string asm, string kind1,
5236                                  string kind2, RegisterOperand RegType,
5237                                  ValueType AccumType, ValueType InputType,
5238                                  SDPatternOperator OpNode> :
5239         BaseSIMDThreeSameVectorTied<Q, U, size, 0b11101, RegType, asm, kind1,
5240                 [(set (AccumType RegType:$dst),
5241               (OpNode (AccumType RegType:$Rd),
5242                       (InputType RegType:$Rn),
5243                       (InputType RegType:$Rm)))]> {
5244   let AsmString = !strconcat(asm, "{\t$Rd" # kind1 # ", $Rn" # kind2 # ", $Rm" # kind2 # "}");
5245   let Inst{13} = b13;
5246 }
5247
5248 multiclass SIMDThreeSameVectorFML<bit U, bit b13, bits<3> size, string asm,
5249                                   SDPatternOperator OpNode> {
5250   def v4f16 : BaseSIMDThreeSameVectorFML<0, U, b13, size, asm, ".2s", ".2h", V64,
5251                                          v2f32, v4f16, OpNode>;
5252   def v8f16 : BaseSIMDThreeSameVectorFML<1, U, b13, size, asm, ".4s", ".4h", V128,
5253                                          v4f32, v8f16, OpNode>;
5254 }
5255
5256
5257 //----------------------------------------------------------------------------
5258 // AdvSIMD two register vector instructions.
5259 //----------------------------------------------------------------------------
5260
5261 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5262 class BaseSIMDTwoSameVector<bit Q, bit U, bits<2> size, bits<5> opcode,
5263                             bits<2> size2, RegisterOperand regtype, string asm,
5264                             string dstkind, string srckind, list<dag> pattern>
5265   : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
5266       "{\t$Rd" # dstkind # ", $Rn" # srckind #
5267       "|" # dstkind # "\t$Rd, $Rn}", "", pattern>,
5268     Sched<[WriteV]> {
5269   bits<5> Rd;
5270   bits<5> Rn;
5271   let Inst{31}    = 0;
5272   let Inst{30}    = Q;
5273   let Inst{29}    = U;
5274   let Inst{28-24} = 0b01110;
5275   let Inst{23-22} = size;
5276   let Inst{21} = 0b1;
5277   let Inst{20-19} = size2;
5278   let Inst{18-17} = 0b00;
5279   let Inst{16-12} = opcode;
5280   let Inst{11-10} = 0b10;
5281   let Inst{9-5}   = Rn;
5282   let Inst{4-0}   = Rd;
5283 }
5284
5285 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5286 class BaseSIMDTwoSameVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
5287                                 bits<2> size2, RegisterOperand regtype,
5288                                 string asm, string dstkind, string srckind,
5289                                 list<dag> pattern>
5290   : I<(outs regtype:$dst), (ins regtype:$Rd, regtype:$Rn), asm,
5291       "{\t$Rd" # dstkind # ", $Rn" # srckind #
5292       "|" # dstkind # "\t$Rd, $Rn}", "$Rd = $dst", pattern>,
5293     Sched<[WriteV]> {
5294   bits<5> Rd;
5295   bits<5> Rn;
5296   let Inst{31}    = 0;
5297   let Inst{30}    = Q;
5298   let Inst{29}    = U;
5299   let Inst{28-24} = 0b01110;
5300   let Inst{23-22} = size;
5301   let Inst{21} = 0b1;
5302   let Inst{20-19} = size2;
5303   let Inst{18-17} = 0b00;
5304   let Inst{16-12} = opcode;
5305   let Inst{11-10} = 0b10;
5306   let Inst{9-5}   = Rn;
5307   let Inst{4-0}   = Rd;
5308 }
5309
5310 // Supports B, H, and S element sizes.
5311 multiclass SIMDTwoVectorBHS<bit U, bits<5> opc, string asm,
5312                             SDPatternOperator OpNode> {
5313   def v8i8  : BaseSIMDTwoSameVector<0, U, 0b00, opc, 0b00, V64,
5314                                       asm, ".8b", ".8b",
5315                           [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
5316   def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, 0b00, V128,
5317                                       asm, ".16b", ".16b",
5318                           [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
5319   def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, 0b00, V64,
5320                                       asm, ".4h", ".4h",
5321                           [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
5322   def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, 0b00, V128,
5323                                       asm, ".8h", ".8h",
5324                           [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
5325   def v2i32 : BaseSIMDTwoSameVector<0, U, 0b10, opc, 0b00, V64,
5326                                       asm, ".2s", ".2s",
5327                           [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
5328   def v4i32 : BaseSIMDTwoSameVector<1, U, 0b10, opc, 0b00, V128,
5329                                       asm, ".4s", ".4s",
5330                           [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5331 }
5332
5333 class BaseSIMDVectorLShiftLongBySize<bit Q, bits<2> size,
5334                             RegisterOperand regtype, string asm, string dstkind,
5335                             string srckind, string amount>
5336   : I<(outs V128:$Rd), (ins regtype:$Rn), asm,
5337       "{\t$Rd" # dstkind # ", $Rn" # srckind # ", #" # amount #
5338       "|" # dstkind # "\t$Rd, $Rn, #" #  amount # "}", "", []>,
5339     Sched<[WriteV]> {
5340   bits<5> Rd;
5341   bits<5> Rn;
5342   let Inst{31}    = 0;
5343   let Inst{30}    = Q;
5344   let Inst{29-24} = 0b101110;
5345   let Inst{23-22} = size;
5346   let Inst{21-10} = 0b100001001110;
5347   let Inst{9-5}   = Rn;
5348   let Inst{4-0}   = Rd;
5349 }
5350
5351 multiclass SIMDVectorLShiftLongBySizeBHS {
5352   let hasSideEffects = 0 in {
5353   def v8i8  : BaseSIMDVectorLShiftLongBySize<0, 0b00, V64,
5354                                              "shll", ".8h",  ".8b", "8">;
5355   def v16i8 : BaseSIMDVectorLShiftLongBySize<1, 0b00, V128,
5356                                              "shll2", ".8h", ".16b", "8">;
5357   def v4i16 : BaseSIMDVectorLShiftLongBySize<0, 0b01, V64,
5358                                              "shll", ".4s",  ".4h", "16">;
5359   def v8i16 : BaseSIMDVectorLShiftLongBySize<1, 0b01, V128,
5360                                              "shll2", ".4s", ".8h", "16">;
5361   def v2i32 : BaseSIMDVectorLShiftLongBySize<0, 0b10, V64,
5362                                              "shll", ".2d",  ".2s", "32">;
5363   def v4i32 : BaseSIMDVectorLShiftLongBySize<1, 0b10, V128,
5364                                              "shll2", ".2d", ".4s", "32">;
5365   }
5366 }
5367
5368 // Supports all element sizes.
5369 multiclass SIMDLongTwoVector<bit U, bits<5> opc, string asm,
5370                              SDPatternOperator OpNode> {
5371   def v8i8_v4i16  : BaseSIMDTwoSameVector<0, U, 0b00, opc, 0b00, V64,
5372                                       asm, ".4h", ".8b",
5373                [(set (v4i16 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
5374   def v16i8_v8i16 : BaseSIMDTwoSameVector<1, U, 0b00, opc, 0b00, V128,
5375                                       asm, ".8h", ".16b",
5376                [(set (v8i16 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
5377   def v4i16_v2i32 : BaseSIMDTwoSameVector<0, U, 0b01, opc, 0b00, V64,
5378                                       asm, ".2s", ".4h",
5379                [(set (v2i32 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
5380   def v8i16_v4i32 : BaseSIMDTwoSameVector<1, U, 0b01, opc, 0b00, V128,
5381                                       asm, ".4s", ".8h",
5382                [(set (v4i32 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
5383   def v2i32_v1i64 : BaseSIMDTwoSameVector<0, U, 0b10, opc, 0b00, V64,
5384                                       asm, ".1d", ".2s",
5385                [(set (v1i64 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
5386   def v4i32_v2i64 : BaseSIMDTwoSameVector<1, U, 0b10, opc, 0b00, V128,
5387                                       asm, ".2d", ".4s",
5388                [(set (v2i64 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5389 }
5390
5391 multiclass SIMDLongTwoVectorTied<bit U, bits<5> opc, string asm,
5392                                  SDPatternOperator OpNode> {
5393   def v8i8_v4i16  : BaseSIMDTwoSameVectorTied<0, U, 0b00, opc, 0b00, V64,
5394                                           asm, ".4h", ".8b",
5395       [(set (v4i16 V64:$dst), (OpNode (v4i16 V64:$Rd),
5396                                       (v8i8 V64:$Rn)))]>;
5397   def v16i8_v8i16 : BaseSIMDTwoSameVectorTied<1, U, 0b00, opc, 0b00, V128,
5398                                           asm, ".8h", ".16b",
5399       [(set (v8i16 V128:$dst), (OpNode (v8i16 V128:$Rd),
5400                                       (v16i8 V128:$Rn)))]>;
5401   def v4i16_v2i32 : BaseSIMDTwoSameVectorTied<0, U, 0b01, opc, 0b00, V64,
5402                                           asm, ".2s", ".4h",
5403       [(set (v2i32 V64:$dst), (OpNode (v2i32 V64:$Rd),
5404                                       (v4i16 V64:$Rn)))]>;
5405   def v8i16_v4i32 : BaseSIMDTwoSameVectorTied<1, U, 0b01, opc, 0b00, V128,
5406                                           asm, ".4s", ".8h",
5407       [(set (v4i32 V128:$dst), (OpNode (v4i32 V128:$Rd),
5408                                       (v8i16 V128:$Rn)))]>;
5409   def v2i32_v1i64 : BaseSIMDTwoSameVectorTied<0, U, 0b10, opc, 0b00, V64,
5410                                           asm, ".1d", ".2s",
5411       [(set (v1i64 V64:$dst), (OpNode (v1i64 V64:$Rd),
5412                                       (v2i32 V64:$Rn)))]>;
5413   def v4i32_v2i64 : BaseSIMDTwoSameVectorTied<1, U, 0b10, opc, 0b00, V128,
5414                                           asm, ".2d", ".4s",
5415       [(set (v2i64 V128:$dst), (OpNode (v2i64 V128:$Rd),
5416                                       (v4i32 V128:$Rn)))]>;
5417 }
5418
5419 // Supports all element sizes, except 1xD.
5420 multiclass SIMDTwoVectorBHSDTied<bit U, bits<5> opc, string asm,
5421                                   SDPatternOperator OpNode> {
5422   def v8i8  : BaseSIMDTwoSameVectorTied<0, U, 0b00, opc, 0b00, V64,
5423                                     asm, ".8b", ".8b",
5424     [(set (v8i8 V64:$dst), (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn)))]>;
5425   def v16i8 : BaseSIMDTwoSameVectorTied<1, U, 0b00, opc, 0b00, V128,
5426                                     asm, ".16b", ".16b",
5427     [(set (v16i8 V128:$dst), (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn)))]>;
5428   def v4i16 : BaseSIMDTwoSameVectorTied<0, U, 0b01, opc, 0b00, V64,
5429                                     asm, ".4h", ".4h",
5430     [(set (v4i16 V64:$dst), (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn)))]>;
5431   def v8i16 : BaseSIMDTwoSameVectorTied<1, U, 0b01, opc, 0b00, V128,
5432                                     asm, ".8h", ".8h",
5433     [(set (v8i16 V128:$dst), (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn)))]>;
5434   def v2i32 : BaseSIMDTwoSameVectorTied<0, U, 0b10, opc, 0b00, V64,
5435                                     asm, ".2s", ".2s",
5436     [(set (v2i32 V64:$dst), (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn)))]>;
5437   def v4i32 : BaseSIMDTwoSameVectorTied<1, U, 0b10, opc, 0b00, V128,
5438                                     asm, ".4s", ".4s",
5439     [(set (v4i32 V128:$dst), (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn)))]>;
5440   def v2i64 : BaseSIMDTwoSameVectorTied<1, U, 0b11, opc, 0b00, V128,
5441                                     asm, ".2d", ".2d",
5442     [(set (v2i64 V128:$dst), (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn)))]>;
5443 }
5444
5445 multiclass SIMDTwoVectorBHSD<bit U, bits<5> opc, string asm,
5446                              SDPatternOperator OpNode = null_frag> {
5447   def v8i8  : BaseSIMDTwoSameVector<0, U, 0b00, opc, 0b00, V64,
5448                                 asm, ".8b", ".8b",
5449     [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
5450   def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, 0b00, V128,
5451                                 asm, ".16b", ".16b",
5452     [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
5453   def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, 0b00, V64,
5454                                 asm, ".4h", ".4h",
5455     [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
5456   def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, 0b00, V128,
5457                                 asm, ".8h", ".8h",
5458     [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
5459   def v2i32 : BaseSIMDTwoSameVector<0, U, 0b10, opc, 0b00, V64,
5460                                 asm, ".2s", ".2s",
5461     [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
5462   def v4i32 : BaseSIMDTwoSameVector<1, U, 0b10, opc, 0b00, V128,
5463                                 asm, ".4s", ".4s",
5464     [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5465   def v2i64 : BaseSIMDTwoSameVector<1, U, 0b11, opc, 0b00, V128,
5466                                 asm, ".2d", ".2d",
5467     [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
5468 }
5469
5470
5471 // Supports only B element sizes.
5472 multiclass SIMDTwoVectorB<bit U, bits<2> size, bits<5> opc, string asm,
5473                           SDPatternOperator OpNode> {
5474   def v8i8  : BaseSIMDTwoSameVector<0, U, size, opc, 0b00, V64,
5475                                 asm, ".8b", ".8b",
5476                     [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
5477   def v16i8 : BaseSIMDTwoSameVector<1, U, size, opc, 0b00, V128,
5478                                 asm, ".16b", ".16b",
5479                     [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
5480
5481 }
5482
5483 // Supports only B and H element sizes.
5484 multiclass SIMDTwoVectorBH<bit U, bits<5> opc, string asm,
5485                                 SDPatternOperator OpNode> {
5486   def v8i8  : BaseSIMDTwoSameVector<0, U, 0b00, opc, 0b00, V64,
5487                                 asm, ".8b", ".8b",
5488                     [(set (v8i8 V64:$Rd), (OpNode V64:$Rn))]>;
5489   def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, 0b00, V128,
5490                                 asm, ".16b", ".16b",
5491                     [(set (v16i8 V128:$Rd), (OpNode V128:$Rn))]>;
5492   def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, 0b00, V64,
5493                                 asm, ".4h", ".4h",
5494                     [(set (v4i16 V64:$Rd), (OpNode V64:$Rn))]>;
5495   def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, 0b00, V128,
5496                                 asm, ".8h", ".8h",
5497                     [(set (v8i16 V128:$Rd), (OpNode V128:$Rn))]>;
5498 }
5499
5500 // Supports H, S and D element sizes, uses high bit of the size field
5501 // as an extra opcode bit.
5502 multiclass SIMDTwoVectorFP<bit U, bit S, bits<5> opc, string asm,
5503                            SDPatternOperator OpNode> {
5504   let Predicates = [HasNEON, HasFullFP16] in {
5505   def v4f16 : BaseSIMDTwoSameVector<0, U, {S,1}, opc, 0b11, V64,
5506                                 asm, ".4h", ".4h",
5507                           [(set (v4f16 V64:$Rd), (OpNode (v4f16 V64:$Rn)))]>;
5508   def v8f16 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b11, V128,
5509                                 asm, ".8h", ".8h",
5510                           [(set (v8f16 V128:$Rd), (OpNode (v8f16 V128:$Rn)))]>;
5511   } // Predicates = [HasNEON, HasFullFP16]
5512   def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, 0b00, V64,
5513                                 asm, ".2s", ".2s",
5514                           [(set (v2f32 V64:$Rd), (OpNode (v2f32 V64:$Rn)))]>;
5515   def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, 0b00, V128,
5516                                 asm, ".4s", ".4s",
5517                           [(set (v4f32 V128:$Rd), (OpNode (v4f32 V128:$Rn)))]>;
5518   def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b00, V128,
5519                                 asm, ".2d", ".2d",
5520                           [(set (v2f64 V128:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
5521 }
5522
5523 // Supports only S and D element sizes
5524 multiclass SIMDTwoVectorSD<bit U, bits<5> opc, string asm,
5525                            SDPatternOperator OpNode = null_frag> {
5526
5527   def v2f32 : BaseSIMDTwoSameVector<0, U, 00, opc, 0b00, V64,
5528                                 asm, ".2s", ".2s",
5529                           [(set (v2f32 V64:$Rd), (OpNode (v2f32 V64:$Rn)))]>;
5530   def v4f32 : BaseSIMDTwoSameVector<1, U, 00, opc, 0b00, V128,
5531                                 asm, ".4s", ".4s",
5532                           [(set (v4f32 V128:$Rd), (OpNode (v4f32 V128:$Rn)))]>;
5533   def v2f64 : BaseSIMDTwoSameVector<1, U, 01, opc, 0b00, V128,
5534                                 asm, ".2d", ".2d",
5535                           [(set (v2f64 V128:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
5536 }
5537
5538 multiclass FRIntNNTVector<bit U, bit op, string asm,
5539                           SDPatternOperator OpNode = null_frag> :
5540            SIMDTwoVectorSD<U, {0b1111,op}, asm, OpNode>;
5541
5542 // Supports only S element size.
5543 multiclass SIMDTwoVectorS<bit U, bit S, bits<5> opc, string asm,
5544                            SDPatternOperator OpNode> {
5545   def v2i32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, 0b00, V64,
5546                                 asm, ".2s", ".2s",
5547                           [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
5548   def v4i32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, 0b00, V128,
5549                                 asm, ".4s", ".4s",
5550                           [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5551 }
5552
5553
5554 multiclass SIMDTwoVectorFPToInt<bit U, bit S, bits<5> opc, string asm,
5555                            SDPatternOperator OpNode> {
5556   let Predicates = [HasNEON, HasFullFP16] in {
5557   def v4f16 : BaseSIMDTwoSameVector<0, U, {S,1}, opc, 0b11, V64,
5558                                 asm, ".4h", ".4h",
5559                           [(set (v4i16 V64:$Rd), (OpNode (v4f16 V64:$Rn)))]>;
5560   def v8f16 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b11, V128,
5561                                 asm, ".8h", ".8h",
5562                           [(set (v8i16 V128:$Rd), (OpNode (v8f16 V128:$Rn)))]>;
5563   } // Predicates = [HasNEON, HasFullFP16]
5564   def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, 0b00, V64,
5565                                 asm, ".2s", ".2s",
5566                           [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn)))]>;
5567   def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, 0b00, V128,
5568                                 asm, ".4s", ".4s",
5569                           [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn)))]>;
5570   def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b00, V128,
5571                                 asm, ".2d", ".2d",
5572                           [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
5573 }
5574
5575 multiclass SIMDTwoVectorIntToFP<bit U, bit S, bits<5> opc, string asm,
5576                            SDPatternOperator OpNode> {
5577   let Predicates = [HasNEON, HasFullFP16] in {
5578   def v4f16 : BaseSIMDTwoSameVector<0, U, {S,1}, opc, 0b11, V64,
5579                                 asm, ".4h", ".4h",
5580                           [(set (v4f16 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
5581   def v8f16 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b11, V128,
5582                                 asm, ".8h", ".8h",
5583                           [(set (v8f16 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
5584   } // Predicates = [HasNEON, HasFullFP16]
5585   def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, 0b00, V64,
5586                                 asm, ".2s", ".2s",
5587                           [(set (v2f32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
5588   def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, 0b00, V128,
5589                                 asm, ".4s", ".4s",
5590                           [(set (v4f32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5591   def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, 0b00, V128,
5592                                 asm, ".2d", ".2d",
5593                           [(set (v2f64 V128:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
5594 }
5595
5596
5597 class BaseSIMDMixedTwoVector<bit Q, bit U, bits<2> size, bits<5> opcode,
5598                            RegisterOperand inreg, RegisterOperand outreg,
5599                            string asm, string outkind, string inkind,
5600                            list<dag> pattern>
5601   : I<(outs outreg:$Rd), (ins inreg:$Rn), asm,
5602       "{\t$Rd" # outkind # ", $Rn" # inkind #
5603       "|" # outkind # "\t$Rd, $Rn}", "", pattern>,
5604     Sched<[WriteV]> {
5605   bits<5> Rd;
5606   bits<5> Rn;
5607   let Inst{31}    = 0;
5608   let Inst{30}    = Q;
5609   let Inst{29}    = U;
5610   let Inst{28-24} = 0b01110;
5611   let Inst{23-22} = size;
5612   let Inst{21-17} = 0b10000;
5613   let Inst{16-12} = opcode;
5614   let Inst{11-10} = 0b10;
5615   let Inst{9-5}   = Rn;
5616   let Inst{4-0}   = Rd;
5617 }
5618
5619 class BaseSIMDMixedTwoVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
5620                            RegisterOperand inreg, RegisterOperand outreg,
5621                            string asm, string outkind, string inkind,
5622                            list<dag> pattern>
5623   : I<(outs outreg:$dst), (ins outreg:$Rd, inreg:$Rn), asm,
5624       "{\t$Rd" # outkind # ", $Rn" # inkind #
5625       "|" # outkind # "\t$Rd, $Rn}", "$Rd = $dst", pattern>,
5626     Sched<[WriteV]> {
5627   bits<5> Rd;
5628   bits<5> Rn;
5629   let Inst{31}    = 0;
5630   let Inst{30}    = Q;
5631   let Inst{29}    = U;
5632   let Inst{28-24} = 0b01110;
5633   let Inst{23-22} = size;
5634   let Inst{21-17} = 0b10000;
5635   let Inst{16-12} = opcode;
5636   let Inst{11-10} = 0b10;
5637   let Inst{9-5}   = Rn;
5638   let Inst{4-0}   = Rd;
5639 }
5640
5641 multiclass SIMDMixedTwoVector<bit U, bits<5> opc, string asm,
5642                               SDPatternOperator OpNode> {
5643   def v8i8  : BaseSIMDMixedTwoVector<0, U, 0b00, opc, V128, V64,
5644                                       asm, ".8b", ".8h",
5645         [(set (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
5646   def v16i8 : BaseSIMDMixedTwoVectorTied<1, U, 0b00, opc, V128, V128,
5647                                       asm#"2", ".16b", ".8h", []>;
5648   def v4i16 : BaseSIMDMixedTwoVector<0, U, 0b01, opc, V128, V64,
5649                                       asm, ".4h", ".4s",
5650         [(set (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
5651   def v8i16 : BaseSIMDMixedTwoVectorTied<1, U, 0b01, opc, V128, V128,
5652                                       asm#"2", ".8h", ".4s", []>;
5653   def v2i32 : BaseSIMDMixedTwoVector<0, U, 0b10, opc, V128, V64,
5654                                       asm, ".2s", ".2d",
5655         [(set (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
5656   def v4i32 : BaseSIMDMixedTwoVectorTied<1, U, 0b10, opc, V128, V128,
5657                                       asm#"2", ".4s", ".2d", []>;
5658
5659   def : Pat<(concat_vectors (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn))),
5660             (!cast<Instruction>(NAME # "v16i8")
5661                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
5662   def : Pat<(concat_vectors (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn))),
5663             (!cast<Instruction>(NAME # "v8i16")
5664                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
5665   def : Pat<(concat_vectors (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn))),
5666             (!cast<Instruction>(NAME # "v4i32")
5667                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
5668 }
5669
5670 class BaseSIMDCmpTwoVector<bit Q, bit U, bits<2> size, bits<2> size2,
5671                            bits<5> opcode, RegisterOperand regtype, string asm,
5672                            string kind, string zero, ValueType dty,
5673                            ValueType sty, SDNode OpNode>
5674   : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
5675       "{\t$Rd" # kind # ", $Rn" # kind # ", #" # zero #
5676       "|" # kind # "\t$Rd, $Rn, #" # zero # "}", "",
5677       [(set (dty regtype:$Rd), (OpNode (sty regtype:$Rn)))]>,
5678     Sched<[WriteV]> {
5679   bits<5> Rd;
5680   bits<5> Rn;
5681   let Inst{31}    = 0;
5682   let Inst{30}    = Q;
5683   let Inst{29}    = U;
5684   let Inst{28-24} = 0b01110;
5685   let Inst{23-22} = size;
5686   let Inst{21} = 0b1;
5687   let Inst{20-19} = size2;
5688   let Inst{18-17} = 0b00;
5689   let Inst{16-12} = opcode;
5690   let Inst{11-10} = 0b10;
5691   let Inst{9-5}   = Rn;
5692   let Inst{4-0}   = Rd;
5693 }
5694
5695 // Comparisons support all element sizes, except 1xD.
5696 multiclass SIMDCmpTwoVector<bit U, bits<5> opc, string asm,
5697                             SDNode OpNode> {
5698   def v8i8rz  : BaseSIMDCmpTwoVector<0, U, 0b00, 0b00, opc, V64,
5699                                      asm, ".8b", "0",
5700                                      v8i8, v8i8, OpNode>;
5701   def v16i8rz : BaseSIMDCmpTwoVector<1, U, 0b00, 0b00, opc, V128,
5702                                      asm, ".16b", "0",
5703                                      v16i8, v16i8, OpNode>;
5704   def v4i16rz : BaseSIMDCmpTwoVector<0, U, 0b01, 0b00, opc, V64,
5705                                      asm, ".4h", "0",
5706                                      v4i16, v4i16, OpNode>;
5707   def v8i16rz : BaseSIMDCmpTwoVector<1, U, 0b01, 0b00, opc, V128,
5708                                      asm, ".8h", "0",
5709                                      v8i16, v8i16, OpNode>;
5710   def v2i32rz : BaseSIMDCmpTwoVector<0, U, 0b10, 0b00, opc, V64,
5711                                      asm, ".2s", "0",
5712                                      v2i32, v2i32, OpNode>;
5713   def v4i32rz : BaseSIMDCmpTwoVector<1, U, 0b10, 0b00, opc, V128,
5714                                      asm, ".4s", "0",
5715                                      v4i32, v4i32, OpNode>;
5716   def v2i64rz : BaseSIMDCmpTwoVector<1, U, 0b11, 0b00, opc, V128,
5717                                      asm, ".2d", "0",
5718                                      v2i64, v2i64, OpNode>;
5719 }
5720
5721 // FP Comparisons support only S and D element sizes (and H for v8.2a).
5722 multiclass SIMDFPCmpTwoVector<bit U, bit S, bits<5> opc,
5723                               string asm, SDNode OpNode> {
5724
5725   let Predicates = [HasNEON, HasFullFP16] in {
5726   def v4i16rz : BaseSIMDCmpTwoVector<0, U, {S,1}, 0b11, opc, V64,
5727                                      asm, ".4h", "0.0",
5728                                      v4i16, v4f16, OpNode>;
5729   def v8i16rz : BaseSIMDCmpTwoVector<1, U, {S,1}, 0b11, opc, V128,
5730                                      asm, ".8h", "0.0",
5731                                      v8i16, v8f16, OpNode>;
5732   } // Predicates = [HasNEON, HasFullFP16]
5733   def v2i32rz : BaseSIMDCmpTwoVector<0, U, {S,0}, 0b00, opc, V64,
5734                                      asm, ".2s", "0.0",
5735                                      v2i32, v2f32, OpNode>;
5736   def v4i32rz : BaseSIMDCmpTwoVector<1, U, {S,0}, 0b00, opc, V128,
5737                                      asm, ".4s", "0.0",
5738                                      v4i32, v4f32, OpNode>;
5739   def v2i64rz : BaseSIMDCmpTwoVector<1, U, {S,1}, 0b00, opc, V128,
5740                                      asm, ".2d", "0.0",
5741                                      v2i64, v2f64, OpNode>;
5742
5743   let Predicates = [HasNEON, HasFullFP16] in {
5744   def : InstAlias<asm # "\t$Vd.4h, $Vn.4h, #0",
5745                   (!cast<Instruction>(NAME # v4i16rz) V64:$Vd, V64:$Vn), 0>;
5746   def : InstAlias<asm # "\t$Vd.8h, $Vn.8h, #0",
5747                   (!cast<Instruction>(NAME # v8i16rz) V128:$Vd, V128:$Vn), 0>;
5748   }
5749   def : InstAlias<asm # "\t$Vd.2s, $Vn.2s, #0",
5750                   (!cast<Instruction>(NAME # v2i32rz) V64:$Vd, V64:$Vn), 0>;
5751   def : InstAlias<asm # "\t$Vd.4s, $Vn.4s, #0",
5752                   (!cast<Instruction>(NAME # v4i32rz) V128:$Vd, V128:$Vn), 0>;
5753   def : InstAlias<asm # "\t$Vd.2d, $Vn.2d, #0",
5754                   (!cast<Instruction>(NAME # v2i64rz) V128:$Vd, V128:$Vn), 0>;
5755   let Predicates = [HasNEON, HasFullFP16] in {
5756   def : InstAlias<asm # ".4h\t$Vd, $Vn, #0",
5757                   (!cast<Instruction>(NAME # v4i16rz) V64:$Vd, V64:$Vn), 0>;
5758   def : InstAlias<asm # ".8h\t$Vd, $Vn, #0",
5759                   (!cast<Instruction>(NAME # v8i16rz) V128:$Vd, V128:$Vn), 0>;
5760   }
5761   def : InstAlias<asm # ".2s\t$Vd, $Vn, #0",
5762                   (!cast<Instruction>(NAME # v2i32rz) V64:$Vd, V64:$Vn), 0>;
5763   def : InstAlias<asm # ".4s\t$Vd, $Vn, #0",
5764                   (!cast<Instruction>(NAME # v4i32rz) V128:$Vd, V128:$Vn), 0>;
5765   def : InstAlias<asm # ".2d\t$Vd, $Vn, #0",
5766                   (!cast<Instruction>(NAME # v2i64rz) V128:$Vd, V128:$Vn), 0>;
5767 }
5768
5769 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5770 class BaseSIMDFPCvtTwoVector<bit Q, bit U, bits<2> size, bits<5> opcode,
5771                              RegisterOperand outtype, RegisterOperand intype,
5772                              string asm, string VdTy, string VnTy,
5773                              list<dag> pattern>
5774   : I<(outs outtype:$Rd), (ins intype:$Rn), asm,
5775       !strconcat("\t$Rd", VdTy, ", $Rn", VnTy), "", pattern>,
5776     Sched<[WriteV]> {
5777   bits<5> Rd;
5778   bits<5> Rn;
5779   let Inst{31}    = 0;
5780   let Inst{30}    = Q;
5781   let Inst{29}    = U;
5782   let Inst{28-24} = 0b01110;
5783   let Inst{23-22} = size;
5784   let Inst{21-17} = 0b10000;
5785   let Inst{16-12} = opcode;
5786   let Inst{11-10} = 0b10;
5787   let Inst{9-5}   = Rn;
5788   let Inst{4-0}   = Rd;
5789 }
5790
5791 class BaseSIMDFPCvtTwoVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
5792                              RegisterOperand outtype, RegisterOperand intype,
5793                              string asm, string VdTy, string VnTy,
5794                              list<dag> pattern>
5795   : I<(outs outtype:$dst), (ins outtype:$Rd, intype:$Rn), asm,
5796       !strconcat("\t$Rd", VdTy, ", $Rn", VnTy), "$Rd = $dst", pattern>,
5797     Sched<[WriteV]> {
5798   bits<5> Rd;
5799   bits<5> Rn;
5800   let Inst{31}    = 0;
5801   let Inst{30}    = Q;
5802   let Inst{29}    = U;
5803   let Inst{28-24} = 0b01110;
5804   let Inst{23-22} = size;
5805   let Inst{21-17} = 0b10000;
5806   let Inst{16-12} = opcode;
5807   let Inst{11-10} = 0b10;
5808   let Inst{9-5}   = Rn;
5809   let Inst{4-0}   = Rd;
5810 }
5811
5812 multiclass SIMDFPWidenTwoVector<bit U, bit S, bits<5> opc, string asm> {
5813   def v4i16 : BaseSIMDFPCvtTwoVector<0, U, {S,0}, opc, V128, V64,
5814                                     asm, ".4s", ".4h", []>;
5815   def v8i16 : BaseSIMDFPCvtTwoVector<1, U, {S,0}, opc, V128, V128,
5816                                     asm#"2", ".4s", ".8h", []>;
5817   def v2i32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V128, V64,
5818                                     asm, ".2d", ".2s", []>;
5819   def v4i32 : BaseSIMDFPCvtTwoVector<1, U, {S,1}, opc, V128, V128,
5820                                     asm#"2", ".2d", ".4s", []>;
5821 }
5822
5823 multiclass SIMDFPNarrowTwoVector<bit U, bit S, bits<5> opc, string asm> {
5824   def v4i16 : BaseSIMDFPCvtTwoVector<0, U, {S,0}, opc, V64, V128,
5825                                     asm, ".4h", ".4s", []>;
5826   def v8i16 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,0}, opc, V128, V128,
5827                                     asm#"2", ".8h", ".4s", []>;
5828   def v2i32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V64, V128,
5829                                     asm, ".2s", ".2d", []>;
5830   def v4i32 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,1}, opc, V128, V128,
5831                                     asm#"2", ".4s", ".2d", []>;
5832 }
5833
5834 multiclass SIMDFPInexactCvtTwoVector<bit U, bit S, bits<5> opc, string asm,
5835                                      Intrinsic OpNode> {
5836   def v2f32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V64, V128,
5837                                      asm, ".2s", ".2d",
5838                           [(set (v2f32 V64:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
5839   def v4f32 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,1}, opc, V128, V128,
5840                                     asm#"2", ".4s", ".2d", []>;
5841
5842   def : Pat<(concat_vectors (v2f32 V64:$Rd), (OpNode (v2f64 V128:$Rn))),
5843             (!cast<Instruction>(NAME # "v4f32")
5844                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
5845 }
5846
5847 //----------------------------------------------------------------------------
5848 // AdvSIMD three register different-size vector instructions.
5849 //----------------------------------------------------------------------------
5850
5851 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5852 class BaseSIMDDifferentThreeVector<bit U, bits<3> size, bits<4> opcode,
5853                       RegisterOperand outtype, RegisterOperand intype1,
5854                       RegisterOperand intype2, string asm,
5855                       string outkind, string inkind1, string inkind2,
5856                       list<dag> pattern>
5857   : I<(outs outtype:$Rd), (ins intype1:$Rn, intype2:$Rm), asm,
5858       "{\t$Rd" # outkind # ", $Rn" # inkind1 # ", $Rm" # inkind2 #
5859       "|" # outkind # "\t$Rd, $Rn, $Rm}", "", pattern>,
5860     Sched<[WriteV]> {
5861   bits<5> Rd;
5862   bits<5> Rn;
5863   bits<5> Rm;
5864   let Inst{31}    = 0;
5865   let Inst{30}    = size{0};
5866   let Inst{29}    = U;
5867   let Inst{28-24} = 0b01110;
5868   let Inst{23-22} = size{2-1};
5869   let Inst{21}    = 1;
5870   let Inst{20-16} = Rm;
5871   let Inst{15-12} = opcode;
5872   let Inst{11-10} = 0b00;
5873   let Inst{9-5}   = Rn;
5874   let Inst{4-0}   = Rd;
5875 }
5876
5877 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5878 class BaseSIMDDifferentThreeVectorTied<bit U, bits<3> size, bits<4> opcode,
5879                       RegisterOperand outtype, RegisterOperand intype1,
5880                       RegisterOperand intype2, string asm,
5881                       string outkind, string inkind1, string inkind2,
5882                       list<dag> pattern>
5883   : I<(outs outtype:$dst), (ins outtype:$Rd, intype1:$Rn, intype2:$Rm), asm,
5884       "{\t$Rd" # outkind # ", $Rn" # inkind1 # ", $Rm" # inkind2 #
5885       "|" # outkind # "\t$Rd, $Rn, $Rm}", "$Rd = $dst", pattern>,
5886     Sched<[WriteV]> {
5887   bits<5> Rd;
5888   bits<5> Rn;
5889   bits<5> Rm;
5890   let Inst{31}    = 0;
5891   let Inst{30}    = size{0};
5892   let Inst{29}    = U;
5893   let Inst{28-24} = 0b01110;
5894   let Inst{23-22} = size{2-1};
5895   let Inst{21}    = 1;
5896   let Inst{20-16} = Rm;
5897   let Inst{15-12} = opcode;
5898   let Inst{11-10} = 0b00;
5899   let Inst{9-5}   = Rn;
5900   let Inst{4-0}   = Rd;
5901 }
5902
5903 // FIXME: TableGen doesn't know how to deal with expanded types that also
5904 //        change the element count (in this case, placing the results in
5905 //        the high elements of the result register rather than the low
5906 //        elements). Until that's fixed, we can't code-gen those.
5907 multiclass SIMDNarrowThreeVectorBHS<bit U, bits<4> opc, string asm,
5908                                     Intrinsic IntOp> {
5909   def v8i16_v8i8   : BaseSIMDDifferentThreeVector<U, 0b000, opc,
5910                                                   V64, V128, V128,
5911                                                   asm, ".8b", ".8h", ".8h",
5912      [(set (v8i8 V64:$Rd), (IntOp (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
5913   def v8i16_v16i8  : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
5914                                                   V128, V128, V128,
5915                                                   asm#"2", ".16b", ".8h", ".8h",
5916      []>;
5917   def v4i32_v4i16  : BaseSIMDDifferentThreeVector<U, 0b010, opc,
5918                                                   V64, V128, V128,
5919                                                   asm, ".4h", ".4s", ".4s",
5920      [(set (v4i16 V64:$Rd), (IntOp (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
5921   def v4i32_v8i16  : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
5922                                                   V128, V128, V128,
5923                                                   asm#"2", ".8h", ".4s", ".4s",
5924      []>;
5925   def v2i64_v2i32  : BaseSIMDDifferentThreeVector<U, 0b100, opc,
5926                                                   V64, V128, V128,
5927                                                   asm, ".2s", ".2d", ".2d",
5928      [(set (v2i32 V64:$Rd), (IntOp (v2i64 V128:$Rn), (v2i64 V128:$Rm)))]>;
5929   def v2i64_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
5930                                                   V128, V128, V128,
5931                                                   asm#"2", ".4s", ".2d", ".2d",
5932      []>;
5933
5934
5935   // Patterns for the '2' variants involve INSERT_SUBREG, which you can't put in
5936   // a version attached to an instruction.
5937   def : Pat<(concat_vectors (v8i8 V64:$Rd), (IntOp (v8i16 V128:$Rn),
5938                                                    (v8i16 V128:$Rm))),
5939             (!cast<Instruction>(NAME # "v8i16_v16i8")
5940                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
5941                 V128:$Rn, V128:$Rm)>;
5942   def : Pat<(concat_vectors (v4i16 V64:$Rd), (IntOp (v4i32 V128:$Rn),
5943                                                     (v4i32 V128:$Rm))),
5944             (!cast<Instruction>(NAME # "v4i32_v8i16")
5945                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
5946                 V128:$Rn, V128:$Rm)>;
5947   def : Pat<(concat_vectors (v2i32 V64:$Rd), (IntOp (v2i64 V128:$Rn),
5948                                                     (v2i64 V128:$Rm))),
5949             (!cast<Instruction>(NAME # "v2i64_v4i32")
5950                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
5951                 V128:$Rn, V128:$Rm)>;
5952 }
5953
5954 multiclass SIMDDifferentThreeVectorBD<bit U, bits<4> opc, string asm,
5955                                       Intrinsic IntOp> {
5956   def v8i8   : BaseSIMDDifferentThreeVector<U, 0b000, opc,
5957                                             V128, V64, V64,
5958                                             asm, ".8h", ".8b", ".8b",
5959       [(set (v8i16 V128:$Rd), (IntOp (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
5960   def v16i8  : BaseSIMDDifferentThreeVector<U, 0b001, opc,
5961                                             V128, V128, V128,
5962                                             asm#"2", ".8h", ".16b", ".16b", []>;
5963   let Predicates = [HasAES] in {
5964     def v1i64  : BaseSIMDDifferentThreeVector<U, 0b110, opc,
5965                                               V128, V64, V64,
5966                                               asm, ".1q", ".1d", ".1d", []>;
5967     def v2i64  : BaseSIMDDifferentThreeVector<U, 0b111, opc,
5968                                               V128, V128, V128,
5969                                               asm#"2", ".1q", ".2d", ".2d", []>;
5970   }
5971
5972   def : Pat<(v8i16 (IntOp (v8i8 (extract_high_v16i8 V128:$Rn)),
5973                           (v8i8 (extract_high_v16i8 V128:$Rm)))),
5974       (!cast<Instruction>(NAME#"v16i8") V128:$Rn, V128:$Rm)>;
5975 }
5976
5977 multiclass SIMDLongThreeVectorHS<bit U, bits<4> opc, string asm,
5978                                  SDPatternOperator OpNode> {
5979   def v4i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b010, opc,
5980                                                   V128, V64, V64,
5981                                                   asm, ".4s", ".4h", ".4h",
5982       [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
5983   def v8i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b011, opc,
5984                                                   V128, V128, V128,
5985                                                   asm#"2", ".4s", ".8h", ".8h",
5986       [(set (v4i32 V128:$Rd), (OpNode (extract_high_v8i16 V128:$Rn),
5987                                       (extract_high_v8i16 V128:$Rm)))]>;
5988   def v2i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b100, opc,
5989                                                   V128, V64, V64,
5990                                                   asm, ".2d", ".2s", ".2s",
5991       [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
5992   def v4i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b101, opc,
5993                                                   V128, V128, V128,
5994                                                   asm#"2", ".2d", ".4s", ".4s",
5995       [(set (v2i64 V128:$Rd), (OpNode (extract_high_v4i32 V128:$Rn),
5996                                       (extract_high_v4i32 V128:$Rm)))]>;
5997 }
5998
5999 multiclass SIMDLongThreeVectorBHSabdl<bit U, bits<4> opc, string asm,
6000                                   SDPatternOperator OpNode = null_frag> {
6001   def v8i8_v8i16   : BaseSIMDDifferentThreeVector<U, 0b000, opc,
6002                                                   V128, V64, V64,
6003                                                   asm, ".8h", ".8b", ".8b",
6004       [(set (v8i16 V128:$Rd),
6005             (zext (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))))]>;
6006   def v16i8_v8i16  : BaseSIMDDifferentThreeVector<U, 0b001, opc,
6007                                                  V128, V128, V128,
6008                                                  asm#"2", ".8h", ".16b", ".16b",
6009       [(set (v8i16 V128:$Rd),
6010             (zext (v8i8 (OpNode (extract_high_v16i8 V128:$Rn),
6011                                 (extract_high_v16i8 V128:$Rm)))))]>;
6012   def v4i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b010, opc,
6013                                                   V128, V64, V64,
6014                                                   asm, ".4s", ".4h", ".4h",
6015       [(set (v4i32 V128:$Rd),
6016             (zext (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))))]>;
6017   def v8i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b011, opc,
6018                                                   V128, V128, V128,
6019                                                   asm#"2", ".4s", ".8h", ".8h",
6020       [(set (v4i32 V128:$Rd),
6021             (zext (v4i16 (OpNode (extract_high_v8i16 V128:$Rn),
6022                                   (extract_high_v8i16 V128:$Rm)))))]>;
6023   def v2i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b100, opc,
6024                                                   V128, V64, V64,
6025                                                   asm, ".2d", ".2s", ".2s",
6026       [(set (v2i64 V128:$Rd),
6027             (zext (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))))]>;
6028   def v4i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b101, opc,
6029                                                   V128, V128, V128,
6030                                                   asm#"2", ".2d", ".4s", ".4s",
6031       [(set (v2i64 V128:$Rd),
6032             (zext (v2i32 (OpNode (extract_high_v4i32 V128:$Rn),
6033                                  (extract_high_v4i32 V128:$Rm)))))]>;
6034 }
6035
6036 multiclass SIMDLongThreeVectorTiedBHSabal<bit U, bits<4> opc,
6037                                           string asm,
6038                                           SDPatternOperator OpNode> {
6039   def v8i8_v8i16   : BaseSIMDDifferentThreeVectorTied<U, 0b000, opc,
6040                                                   V128, V64, V64,
6041                                                   asm, ".8h", ".8b", ".8b",
6042     [(set (v8i16 V128:$dst),
6043           (add (v8i16 V128:$Rd),
6044                (zext (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm))))))]>;
6045   def v16i8_v8i16  : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
6046                                                  V128, V128, V128,
6047                                                  asm#"2", ".8h", ".16b", ".16b",
6048     [(set (v8i16 V128:$dst),
6049           (add (v8i16 V128:$Rd),
6050                (zext (v8i8 (OpNode (extract_high_v16i8 V128:$Rn),
6051                                    (extract_high_v16i8 V128:$Rm))))))]>;
6052   def v4i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
6053                                                   V128, V64, V64,
6054                                                   asm, ".4s", ".4h", ".4h",
6055     [(set (v4i32 V128:$dst),
6056           (add (v4i32 V128:$Rd),
6057                (zext (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm))))))]>;
6058   def v8i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
6059                                                   V128, V128, V128,
6060                                                   asm#"2", ".4s", ".8h", ".8h",
6061     [(set (v4i32 V128:$dst),
6062           (add (v4i32 V128:$Rd),
6063                (zext (v4i16 (OpNode (extract_high_v8i16 V128:$Rn),
6064                                     (extract_high_v8i16 V128:$Rm))))))]>;
6065   def v2i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
6066                                                   V128, V64, V64,
6067                                                   asm, ".2d", ".2s", ".2s",
6068     [(set (v2i64 V128:$dst),
6069           (add (v2i64 V128:$Rd),
6070                (zext (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm))))))]>;
6071   def v4i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
6072                                                   V128, V128, V128,
6073                                                   asm#"2", ".2d", ".4s", ".4s",
6074     [(set (v2i64 V128:$dst),
6075           (add (v2i64 V128:$Rd),
6076                (zext (v2i32 (OpNode (extract_high_v4i32 V128:$Rn),
6077                                     (extract_high_v4i32 V128:$Rm))))))]>;
6078 }
6079
6080 multiclass SIMDLongThreeVectorBHS<bit U, bits<4> opc, string asm,
6081                                   SDPatternOperator OpNode = null_frag> {
6082   def v8i8_v8i16   : BaseSIMDDifferentThreeVector<U, 0b000, opc,
6083                                                   V128, V64, V64,
6084                                                   asm, ".8h", ".8b", ".8b",
6085       [(set (v8i16 V128:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
6086   def v16i8_v8i16  : BaseSIMDDifferentThreeVector<U, 0b001, opc,
6087                                                  V128, V128, V128,
6088                                                  asm#"2", ".8h", ".16b", ".16b",
6089       [(set (v8i16 V128:$Rd), (OpNode (extract_high_v16i8 V128:$Rn),
6090                                       (extract_high_v16i8 V128:$Rm)))]>;
6091   def v4i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b010, opc,
6092                                                   V128, V64, V64,
6093                                                   asm, ".4s", ".4h", ".4h",
6094       [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
6095   def v8i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b011, opc,
6096                                                   V128, V128, V128,
6097                                                   asm#"2", ".4s", ".8h", ".8h",
6098       [(set (v4i32 V128:$Rd), (OpNode (extract_high_v8i16 V128:$Rn),
6099                                       (extract_high_v8i16 V128:$Rm)))]>;
6100   def v2i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b100, opc,
6101                                                   V128, V64, V64,
6102                                                   asm, ".2d", ".2s", ".2s",
6103       [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
6104   def v4i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b101, opc,
6105                                                   V128, V128, V128,
6106                                                   asm#"2", ".2d", ".4s", ".4s",
6107       [(set (v2i64 V128:$Rd), (OpNode (extract_high_v4i32 V128:$Rn),
6108                                       (extract_high_v4i32 V128:$Rm)))]>;
6109 }
6110
6111 multiclass SIMDLongThreeVectorTiedBHS<bit U, bits<4> opc,
6112                                       string asm,
6113                                       SDPatternOperator OpNode> {
6114   def v8i8_v8i16   : BaseSIMDDifferentThreeVectorTied<U, 0b000, opc,
6115                                                   V128, V64, V64,
6116                                                   asm, ".8h", ".8b", ".8b",
6117     [(set (v8i16 V128:$dst),
6118           (OpNode (v8i16 V128:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
6119   def v16i8_v8i16  : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
6120                                                  V128, V128, V128,
6121                                                  asm#"2", ".8h", ".16b", ".16b",
6122     [(set (v8i16 V128:$dst),
6123           (OpNode (v8i16 V128:$Rd),
6124                   (extract_high_v16i8 V128:$Rn),
6125                   (extract_high_v16i8 V128:$Rm)))]>;
6126   def v4i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
6127                                                   V128, V64, V64,
6128                                                   asm, ".4s", ".4h", ".4h",
6129     [(set (v4i32 V128:$dst),
6130           (OpNode (v4i32 V128:$Rd), (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
6131   def v8i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
6132                                                   V128, V128, V128,
6133                                                   asm#"2", ".4s", ".8h", ".8h",
6134     [(set (v4i32 V128:$dst),
6135           (OpNode (v4i32 V128:$Rd),
6136                   (extract_high_v8i16 V128:$Rn),
6137                   (extract_high_v8i16 V128:$Rm)))]>;
6138   def v2i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
6139                                                   V128, V64, V64,
6140                                                   asm, ".2d", ".2s", ".2s",
6141     [(set (v2i64 V128:$dst),
6142           (OpNode (v2i64 V128:$Rd), (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
6143   def v4i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
6144                                                   V128, V128, V128,
6145                                                   asm#"2", ".2d", ".4s", ".4s",
6146     [(set (v2i64 V128:$dst),
6147           (OpNode (v2i64 V128:$Rd),
6148                   (extract_high_v4i32 V128:$Rn),
6149                   (extract_high_v4i32 V128:$Rm)))]>;
6150 }
6151
6152 multiclass SIMDLongThreeVectorSQDMLXTiedHS<bit U, bits<4> opc, string asm,
6153                                            SDPatternOperator Accum> {
6154   def v4i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
6155                                                   V128, V64, V64,
6156                                                   asm, ".4s", ".4h", ".4h",
6157     [(set (v4i32 V128:$dst),
6158           (Accum (v4i32 V128:$Rd),
6159                  (v4i32 (int_aarch64_neon_sqdmull (v4i16 V64:$Rn),
6160                                                 (v4i16 V64:$Rm)))))]>;
6161   def v8i16_v4i32  : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
6162                                                   V128, V128, V128,
6163                                                   asm#"2", ".4s", ".8h", ".8h",
6164     [(set (v4i32 V128:$dst),
6165           (Accum (v4i32 V128:$Rd),
6166                  (v4i32 (int_aarch64_neon_sqdmull (extract_high_v8i16 V128:$Rn),
6167                                             (extract_high_v8i16 V128:$Rm)))))]>;
6168   def v2i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
6169                                                   V128, V64, V64,
6170                                                   asm, ".2d", ".2s", ".2s",
6171     [(set (v2i64 V128:$dst),
6172           (Accum (v2i64 V128:$Rd),
6173                  (v2i64 (int_aarch64_neon_sqdmull (v2i32 V64:$Rn),
6174                                                 (v2i32 V64:$Rm)))))]>;
6175   def v4i32_v2i64  : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
6176                                                   V128, V128, V128,
6177                                                   asm#"2", ".2d", ".4s", ".4s",
6178     [(set (v2i64 V128:$dst),
6179           (Accum (v2i64 V128:$Rd),
6180                  (v2i64 (int_aarch64_neon_sqdmull (extract_high_v4i32 V128:$Rn),
6181                                             (extract_high_v4i32 V128:$Rm)))))]>;
6182 }
6183
6184 multiclass SIMDWideThreeVectorBHS<bit U, bits<4> opc, string asm,
6185                                   SDPatternOperator OpNode> {
6186   def v8i8_v8i16   : BaseSIMDDifferentThreeVector<U, 0b000, opc,
6187                                                   V128, V128, V64,
6188                                                   asm, ".8h", ".8h", ".8b",
6189        [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i8 V64:$Rm)))]>;
6190   def v16i8_v8i16  : BaseSIMDDifferentThreeVector<U, 0b001, opc,
6191                                                   V128, V128, V128,
6192                                                   asm#"2", ".8h", ".8h", ".16b",
6193        [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
6194                                        (extract_high_v16i8 V128:$Rm)))]>;
6195   def v4i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b010, opc,
6196                                                   V128, V128, V64,
6197                                                   asm, ".4s", ".4s", ".4h",
6198        [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i16 V64:$Rm)))]>;
6199   def v8i16_v4i32  : BaseSIMDDifferentThreeVector<U, 0b011, opc,
6200                                                   V128, V128, V128,
6201                                                   asm#"2", ".4s", ".4s", ".8h",
6202        [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
6203                                        (extract_high_v8i16 V128:$Rm)))]>;
6204   def v2i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b100, opc,
6205                                                   V128, V128, V64,
6206                                                   asm, ".2d", ".2d", ".2s",
6207        [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (v2i32 V64:$Rm)))]>;
6208   def v4i32_v2i64  : BaseSIMDDifferentThreeVector<U, 0b101, opc,
6209                                                   V128, V128, V128,
6210                                                   asm#"2", ".2d", ".2d", ".4s",
6211        [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
6212                                        (extract_high_v4i32 V128:$Rm)))]>;
6213 }
6214
6215 //----------------------------------------------------------------------------
6216 // AdvSIMD bitwise extract from vector
6217 //----------------------------------------------------------------------------
6218
6219 class BaseSIMDBitwiseExtract<bit size, RegisterOperand regtype, ValueType vty,
6220                              string asm, string kind>
6221   : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, i32imm:$imm), asm,
6222       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind # ", $imm" #
6223       "|" # kind # "\t$Rd, $Rn, $Rm, $imm}", "",
6224       [(set (vty regtype:$Rd),
6225             (AArch64ext regtype:$Rn, regtype:$Rm, (i32 imm:$imm)))]>,
6226     Sched<[WriteV]> {
6227   bits<5> Rd;
6228   bits<5> Rn;
6229   bits<5> Rm;
6230   bits<4> imm;
6231   let Inst{31}    = 0;
6232   let Inst{30}    = size;
6233   let Inst{29-21} = 0b101110000;
6234   let Inst{20-16} = Rm;
6235   let Inst{15}    = 0;
6236   let Inst{14-11} = imm;
6237   let Inst{10}    = 0;
6238   let Inst{9-5}   = Rn;
6239   let Inst{4-0}   = Rd;
6240 }
6241
6242
6243 multiclass SIMDBitwiseExtract<string asm> {
6244   def v8i8  : BaseSIMDBitwiseExtract<0, V64, v8i8, asm, ".8b"> {
6245     let imm{3} = 0;
6246   }
6247   def v16i8 : BaseSIMDBitwiseExtract<1, V128, v16i8, asm, ".16b">;
6248 }
6249
6250 //----------------------------------------------------------------------------
6251 // AdvSIMD zip vector
6252 //----------------------------------------------------------------------------
6253
6254 class BaseSIMDZipVector<bits<3> size, bits<3> opc, RegisterOperand regtype,
6255                         string asm, string kind, SDNode OpNode, ValueType valty>
6256   : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
6257       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
6258       "|" # kind # "\t$Rd, $Rn, $Rm}", "",
6259       [(set (valty regtype:$Rd), (OpNode regtype:$Rn, regtype:$Rm))]>,
6260     Sched<[WriteV]> {
6261   bits<5> Rd;
6262   bits<5> Rn;
6263   bits<5> Rm;
6264   let Inst{31}    = 0;
6265   let Inst{30}    = size{0};
6266   let Inst{29-24} = 0b001110;
6267   let Inst{23-22} = size{2-1};
6268   let Inst{21}    = 0;
6269   let Inst{20-16} = Rm;
6270   let Inst{15}    = 0;
6271   let Inst{14-12} = opc;
6272   let Inst{11-10} = 0b10;
6273   let Inst{9-5}   = Rn;
6274   let Inst{4-0}   = Rd;
6275 }
6276
6277 multiclass SIMDZipVector<bits<3>opc, string asm,
6278                          SDNode OpNode> {
6279   def v8i8   : BaseSIMDZipVector<0b000, opc, V64,
6280       asm, ".8b", OpNode, v8i8>;
6281   def v16i8  : BaseSIMDZipVector<0b001, opc, V128,
6282       asm, ".16b", OpNode, v16i8>;
6283   def v4i16  : BaseSIMDZipVector<0b010, opc, V64,
6284       asm, ".4h", OpNode, v4i16>;
6285   def v8i16  : BaseSIMDZipVector<0b011, opc, V128,
6286       asm, ".8h", OpNode, v8i16>;
6287   def v2i32  : BaseSIMDZipVector<0b100, opc, V64,
6288       asm, ".2s", OpNode, v2i32>;
6289   def v4i32  : BaseSIMDZipVector<0b101, opc, V128,
6290       asm, ".4s", OpNode, v4i32>;
6291   def v2i64  : BaseSIMDZipVector<0b111, opc, V128,
6292       asm, ".2d", OpNode, v2i64>;
6293
6294   def : Pat<(v4f16 (OpNode V64:$Rn, V64:$Rm)),
6295         (!cast<Instruction>(NAME#"v4i16") V64:$Rn, V64:$Rm)>;
6296   def : Pat<(v8f16 (OpNode V128:$Rn, V128:$Rm)),
6297         (!cast<Instruction>(NAME#"v8i16") V128:$Rn, V128:$Rm)>;
6298   def : Pat<(v2f32 (OpNode V64:$Rn, V64:$Rm)),
6299         (!cast<Instruction>(NAME#"v2i32") V64:$Rn, V64:$Rm)>;
6300   def : Pat<(v4f32 (OpNode V128:$Rn, V128:$Rm)),
6301         (!cast<Instruction>(NAME#"v4i32") V128:$Rn, V128:$Rm)>;
6302   def : Pat<(v2f64 (OpNode V128:$Rn, V128:$Rm)),
6303         (!cast<Instruction>(NAME#"v2i64") V128:$Rn, V128:$Rm)>;
6304 }
6305
6306 //----------------------------------------------------------------------------
6307 // AdvSIMD three register scalar instructions
6308 //----------------------------------------------------------------------------
6309
6310 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6311 class BaseSIMDThreeScalar<bit U, bits<3> size, bits<5> opcode,
6312                         RegisterClass regtype, string asm,
6313                         list<dag> pattern>
6314   : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
6315       "\t$Rd, $Rn, $Rm", "", pattern>,
6316     Sched<[WriteV]> {
6317   bits<5> Rd;
6318   bits<5> Rn;
6319   bits<5> Rm;
6320   let Inst{31-30} = 0b01;
6321   let Inst{29}    = U;
6322   let Inst{28-24} = 0b11110;
6323   let Inst{23-21} = size;
6324   let Inst{20-16} = Rm;
6325   let Inst{15-11} = opcode;
6326   let Inst{10}    = 1;
6327   let Inst{9-5}   = Rn;
6328   let Inst{4-0}   = Rd;
6329 }
6330
6331 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6332 class BaseSIMDThreeScalarTied<bit U, bits<2> size, bit R, bits<5> opcode,
6333                         dag oops, dag iops, string asm,
6334             list<dag> pattern>
6335   : I<oops, iops, asm, "\t$Rd, $Rn, $Rm", "$Rd = $dst", pattern>,
6336     Sched<[WriteV]> {
6337   bits<5> Rd;
6338   bits<5> Rn;
6339   bits<5> Rm;
6340   let Inst{31-30} = 0b01;
6341   let Inst{29}    = U;
6342   let Inst{28-24} = 0b11110;
6343   let Inst{23-22} = size;
6344   let Inst{21}    = R;
6345   let Inst{20-16} = Rm;
6346   let Inst{15-11} = opcode;
6347   let Inst{10}    = 1;
6348   let Inst{9-5}   = Rn;
6349   let Inst{4-0}   = Rd;
6350 }
6351
6352 multiclass SIMDThreeScalarD<bit U, bits<5> opc, string asm,
6353                             SDPatternOperator OpNode> {
6354   def v1i64  : BaseSIMDThreeScalar<U, 0b111, opc, FPR64, asm,
6355     [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn), (v1i64 FPR64:$Rm)))]>;
6356 }
6357
6358 multiclass SIMDThreeScalarBHSD<bit U, bits<5> opc, string asm,
6359                                SDPatternOperator OpNode> {
6360   def v1i64  : BaseSIMDThreeScalar<U, 0b111, opc, FPR64, asm,
6361     [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn), (v1i64 FPR64:$Rm)))]>;
6362   def v1i32  : BaseSIMDThreeScalar<U, 0b101, opc, FPR32, asm, []>;
6363   def v1i16  : BaseSIMDThreeScalar<U, 0b011, opc, FPR16, asm, []>;
6364   def v1i8   : BaseSIMDThreeScalar<U, 0b001, opc, FPR8 , asm, []>;
6365
6366   def : Pat<(i64 (OpNode (i64 FPR64:$Rn), (i64 FPR64:$Rm))),
6367             (!cast<Instruction>(NAME#"v1i64") FPR64:$Rn, FPR64:$Rm)>;
6368   def : Pat<(i32 (OpNode (i32 FPR32:$Rn), (i32 FPR32:$Rm))),
6369             (!cast<Instruction>(NAME#"v1i32") FPR32:$Rn, FPR32:$Rm)>;
6370 }
6371
6372 multiclass SIMDThreeScalarHS<bit U, bits<5> opc, string asm,
6373                              SDPatternOperator OpNode> {
6374   def v1i32  : BaseSIMDThreeScalar<U, 0b101, opc, FPR32, asm,
6375                              [(set FPR32:$Rd, (OpNode FPR32:$Rn, FPR32:$Rm))]>;
6376   def v1i16  : BaseSIMDThreeScalar<U, 0b011, opc, FPR16, asm, []>;
6377 }
6378
6379 multiclass SIMDThreeScalarHSTied<bit U, bit R, bits<5> opc, string asm,
6380                                  SDPatternOperator OpNode = null_frag> {
6381   def v1i32: BaseSIMDThreeScalarTied<U, 0b10, R, opc, (outs FPR32:$dst),
6382                                      (ins FPR32:$Rd, FPR32:$Rn, FPR32:$Rm),
6383                                      asm, []>;
6384   def v1i16: BaseSIMDThreeScalarTied<U, 0b01, R, opc, (outs FPR16:$dst),
6385                                      (ins FPR16:$Rd, FPR16:$Rn, FPR16:$Rm),
6386                                      asm, []>;
6387 }
6388
6389 multiclass SIMDFPThreeScalar<bit U, bit S, bits<3> opc, string asm,
6390                              SDPatternOperator OpNode = null_frag> {
6391   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6392     def #NAME#64 : BaseSIMDThreeScalar<U, {S,0b11}, {0b11,opc}, FPR64, asm,
6393       [(set (f64 FPR64:$Rd), (OpNode (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]>;
6394     def #NAME#32 : BaseSIMDThreeScalar<U, {S,0b01}, {0b11,opc}, FPR32, asm,
6395       [(set FPR32:$Rd, (OpNode FPR32:$Rn, FPR32:$Rm))]>;
6396     let Predicates = [HasNEON, HasFullFP16] in {
6397     def #NAME#16 : BaseSIMDThreeScalar<U, {S,0b10}, {0b00,opc}, FPR16, asm,
6398       [(set FPR16:$Rd, (OpNode FPR16:$Rn, FPR16:$Rm))]>;
6399     } // Predicates = [HasNEON, HasFullFP16]
6400   }
6401
6402   def : Pat<(v1f64 (OpNode (v1f64 FPR64:$Rn), (v1f64 FPR64:$Rm))),
6403             (!cast<Instruction>(NAME # "64") FPR64:$Rn, FPR64:$Rm)>;
6404 }
6405
6406 multiclass SIMDThreeScalarFPCmp<bit U, bit S, bits<3> opc, string asm,
6407                                 SDPatternOperator OpNode = null_frag> {
6408   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6409     def #NAME#64 : BaseSIMDThreeScalar<U, {S,0b11}, {0b11,opc}, FPR64, asm,
6410       [(set (i64 FPR64:$Rd), (OpNode (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]>;
6411     def #NAME#32 : BaseSIMDThreeScalar<U, {S,0b01}, {0b11,opc}, FPR32, asm,
6412       [(set (i32 FPR32:$Rd), (OpNode (f32 FPR32:$Rn), (f32 FPR32:$Rm)))]>;
6413     let Predicates = [HasNEON, HasFullFP16] in {
6414     def #NAME#16 : BaseSIMDThreeScalar<U, {S,0b10}, {0b00,opc}, FPR16, asm,
6415       []>;
6416     } // Predicates = [HasNEON, HasFullFP16]
6417   }
6418
6419   def : Pat<(v1i64 (OpNode (v1f64 FPR64:$Rn), (v1f64 FPR64:$Rm))),
6420             (!cast<Instruction>(NAME # "64") FPR64:$Rn, FPR64:$Rm)>;
6421 }
6422
6423 class BaseSIMDThreeScalarMixed<bit U, bits<2> size, bits<5> opcode,
6424               dag oops, dag iops, string asm, string cstr, list<dag> pat>
6425   : I<oops, iops, asm,
6426       "\t$Rd, $Rn, $Rm", cstr, pat>,
6427     Sched<[WriteV]> {
6428   bits<5> Rd;
6429   bits<5> Rn;
6430   bits<5> Rm;
6431   let Inst{31-30} = 0b01;
6432   let Inst{29}    = U;
6433   let Inst{28-24} = 0b11110;
6434   let Inst{23-22} = size;
6435   let Inst{21}    = 1;
6436   let Inst{20-16} = Rm;
6437   let Inst{15-11} = opcode;
6438   let Inst{10}    = 0;
6439   let Inst{9-5}   = Rn;
6440   let Inst{4-0}   = Rd;
6441 }
6442
6443 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6444 multiclass SIMDThreeScalarMixedHS<bit U, bits<5> opc, string asm,
6445                                   SDPatternOperator OpNode = null_frag> {
6446   def i16  : BaseSIMDThreeScalarMixed<U, 0b01, opc,
6447                                       (outs FPR32:$Rd),
6448                                       (ins FPR16:$Rn, FPR16:$Rm), asm, "", []>;
6449   def i32  : BaseSIMDThreeScalarMixed<U, 0b10, opc,
6450                                       (outs FPR64:$Rd),
6451                                       (ins FPR32:$Rn, FPR32:$Rm), asm, "",
6452             [(set (i64 FPR64:$Rd), (OpNode (i32 FPR32:$Rn), (i32 FPR32:$Rm)))]>;
6453 }
6454
6455 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6456 multiclass SIMDThreeScalarMixedTiedHS<bit U, bits<5> opc, string asm,
6457                                   SDPatternOperator OpNode = null_frag> {
6458   def i16  : BaseSIMDThreeScalarMixed<U, 0b01, opc,
6459                                       (outs FPR32:$dst),
6460                                       (ins FPR32:$Rd, FPR16:$Rn, FPR16:$Rm),
6461                                       asm, "$Rd = $dst", []>;
6462   def i32  : BaseSIMDThreeScalarMixed<U, 0b10, opc,
6463                                       (outs FPR64:$dst),
6464                                       (ins FPR64:$Rd, FPR32:$Rn, FPR32:$Rm),
6465                                       asm, "$Rd = $dst",
6466             [(set (i64 FPR64:$dst),
6467                   (OpNode (i64 FPR64:$Rd), (i32 FPR32:$Rn), (i32 FPR32:$Rm)))]>;
6468 }
6469
6470 //----------------------------------------------------------------------------
6471 // AdvSIMD two register scalar instructions
6472 //----------------------------------------------------------------------------
6473
6474 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6475 class BaseSIMDTwoScalar<bit U, bits<2> size, bits<2> size2, bits<5> opcode,
6476                         RegisterClass regtype, RegisterClass regtype2,
6477                         string asm, list<dag> pat>
6478   : I<(outs regtype:$Rd), (ins regtype2:$Rn), asm,
6479       "\t$Rd, $Rn", "", pat>,
6480     Sched<[WriteV]> {
6481   bits<5> Rd;
6482   bits<5> Rn;
6483   let Inst{31-30} = 0b01;
6484   let Inst{29}    = U;
6485   let Inst{28-24} = 0b11110;
6486   let Inst{23-22} = size;
6487   let Inst{21} = 0b1;
6488   let Inst{20-19} = size2;
6489   let Inst{18-17} = 0b00;
6490   let Inst{16-12} = opcode;
6491   let Inst{11-10} = 0b10;
6492   let Inst{9-5}   = Rn;
6493   let Inst{4-0}   = Rd;
6494 }
6495
6496 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6497 class BaseSIMDTwoScalarTied<bit U, bits<2> size, bits<5> opcode,
6498                         RegisterClass regtype, RegisterClass regtype2,
6499                         string asm, list<dag> pat>
6500   : I<(outs regtype:$dst), (ins regtype:$Rd, regtype2:$Rn), asm,
6501       "\t$Rd, $Rn", "$Rd = $dst", pat>,
6502     Sched<[WriteV]> {
6503   bits<5> Rd;
6504   bits<5> Rn;
6505   let Inst{31-30} = 0b01;
6506   let Inst{29}    = U;
6507   let Inst{28-24} = 0b11110;
6508   let Inst{23-22} = size;
6509   let Inst{21-17} = 0b10000;
6510   let Inst{16-12} = opcode;
6511   let Inst{11-10} = 0b10;
6512   let Inst{9-5}   = Rn;
6513   let Inst{4-0}   = Rd;
6514 }
6515
6516
6517 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6518 class BaseSIMDCmpTwoScalar<bit U, bits<2> size, bits<2> size2, bits<5> opcode,
6519                         RegisterClass regtype, string asm, string zero>
6520   : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
6521       "\t$Rd, $Rn, #" # zero, "", []>,
6522     Sched<[WriteV]> {
6523   bits<5> Rd;
6524   bits<5> Rn;
6525   let Inst{31-30} = 0b01;
6526   let Inst{29}    = U;
6527   let Inst{28-24} = 0b11110;
6528   let Inst{23-22} = size;
6529   let Inst{21} = 0b1;
6530   let Inst{20-19} = size2;
6531   let Inst{18-17} = 0b00;
6532   let Inst{16-12} = opcode;
6533   let Inst{11-10} = 0b10;
6534   let Inst{9-5}   = Rn;
6535   let Inst{4-0}   = Rd;
6536 }
6537
6538 class SIMDInexactCvtTwoScalar<bits<5> opcode, string asm>
6539   : I<(outs FPR32:$Rd), (ins FPR64:$Rn), asm, "\t$Rd, $Rn", "",
6540      [(set (f32 FPR32:$Rd), (int_aarch64_sisd_fcvtxn (f64 FPR64:$Rn)))]>,
6541     Sched<[WriteV]> {
6542   bits<5> Rd;
6543   bits<5> Rn;
6544   let Inst{31-17} = 0b011111100110000;
6545   let Inst{16-12} = opcode;
6546   let Inst{11-10} = 0b10;
6547   let Inst{9-5}   = Rn;
6548   let Inst{4-0}   = Rd;
6549 }
6550
6551 multiclass SIMDCmpTwoScalarD<bit U, bits<5> opc, string asm,
6552                              SDPatternOperator OpNode> {
6553   def v1i64rz  : BaseSIMDCmpTwoScalar<U, 0b11, 0b00, opc, FPR64, asm, "0">;
6554
6555   def : Pat<(v1i64 (OpNode FPR64:$Rn)),
6556             (!cast<Instruction>(NAME # v1i64rz) FPR64:$Rn)>;
6557 }
6558
6559 multiclass SIMDFPCmpTwoScalar<bit U, bit S, bits<5> opc, string asm,
6560                               SDPatternOperator OpNode> {
6561   def v1i64rz  : BaseSIMDCmpTwoScalar<U, {S,1}, 0b00, opc, FPR64, asm, "0.0">;
6562   def v1i32rz  : BaseSIMDCmpTwoScalar<U, {S,0}, 0b00, opc, FPR32, asm, "0.0">;
6563   let Predicates = [HasNEON, HasFullFP16] in {
6564   def v1i16rz  : BaseSIMDCmpTwoScalar<U, {S,1}, 0b11, opc, FPR16, asm, "0.0">;
6565   }
6566
6567   def : InstAlias<asm # "\t$Rd, $Rn, #0",
6568                   (!cast<Instruction>(NAME # v1i64rz) FPR64:$Rd, FPR64:$Rn), 0>;
6569   def : InstAlias<asm # "\t$Rd, $Rn, #0",
6570                   (!cast<Instruction>(NAME # v1i32rz) FPR32:$Rd, FPR32:$Rn), 0>;
6571   let Predicates = [HasNEON, HasFullFP16] in {
6572   def : InstAlias<asm # "\t$Rd, $Rn, #0",
6573                   (!cast<Instruction>(NAME # v1i16rz) FPR16:$Rd, FPR16:$Rn), 0>;
6574   }
6575
6576   def : Pat<(v1i64 (OpNode (v1f64 FPR64:$Rn))),
6577             (!cast<Instruction>(NAME # v1i64rz) FPR64:$Rn)>;
6578 }
6579
6580 multiclass SIMDTwoScalarD<bit U, bits<5> opc, string asm,
6581                           SDPatternOperator OpNode = null_frag> {
6582   def v1i64       : BaseSIMDTwoScalar<U, 0b11, 0b00, opc, FPR64, FPR64, asm,
6583     [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn)))]>;
6584
6585   def : Pat<(i64 (OpNode (i64 FPR64:$Rn))),
6586             (!cast<Instruction>(NAME # "v1i64") FPR64:$Rn)>;
6587 }
6588
6589 multiclass SIMDFPTwoScalar<bit U, bit S, bits<5> opc, string asm> {
6590   def v1i64       : BaseSIMDTwoScalar<U, {S,1}, 0b00, opc, FPR64, FPR64, asm,[]>;
6591   def v1i32       : BaseSIMDTwoScalar<U, {S,0}, 0b00, opc, FPR32, FPR32, asm,[]>;
6592   let Predicates = [HasNEON, HasFullFP16] in {
6593   def v1f16       : BaseSIMDTwoScalar<U, {S,1}, 0b11, opc, FPR16, FPR16, asm,[]>;
6594   }
6595 }
6596
6597 multiclass SIMDFPTwoScalarCVT<bit U, bit S, bits<5> opc, string asm,
6598                               SDPatternOperator OpNode> {
6599   def v1i64 : BaseSIMDTwoScalar<U, {S,1}, 0b00, opc, FPR64, FPR64, asm,
6600                                 [(set FPR64:$Rd, (OpNode (f64 FPR64:$Rn)))]>;
6601   def v1i32 : BaseSIMDTwoScalar<U, {S,0}, 0b00, opc, FPR32, FPR32, asm,
6602                                 [(set FPR32:$Rd, (OpNode (f32 FPR32:$Rn)))]>;
6603   let Predicates = [HasNEON, HasFullFP16] in {
6604   def v1i16 : BaseSIMDTwoScalar<U, {S,1}, 0b11, opc, FPR16, FPR16, asm,
6605                                 [(set FPR16:$Rd, (OpNode (f16 FPR16:$Rn)))]>;
6606   }
6607 }
6608
6609 multiclass SIMDTwoScalarBHSD<bit U, bits<5> opc, string asm,
6610                              SDPatternOperator OpNode = null_frag> {
6611   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6612     def v1i64  : BaseSIMDTwoScalar<U, 0b11, 0b00, opc, FPR64, FPR64, asm,
6613            [(set (i64 FPR64:$Rd), (OpNode (i64 FPR64:$Rn)))]>;
6614     def v1i32  : BaseSIMDTwoScalar<U, 0b10, 0b00, opc, FPR32, FPR32, asm,
6615            [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn)))]>;
6616     def v1i16  : BaseSIMDTwoScalar<U, 0b01, 0b00, opc, FPR16, FPR16, asm, []>;
6617     def v1i8   : BaseSIMDTwoScalar<U, 0b00, 0b00, opc, FPR8 , FPR8 , asm, []>;
6618   }
6619
6620   def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rn))),
6621             (!cast<Instruction>(NAME # v1i64) FPR64:$Rn)>;
6622 }
6623
6624 multiclass SIMDTwoScalarBHSDTied<bit U, bits<5> opc, string asm,
6625                                  Intrinsic OpNode> {
6626   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6627     def v1i64  : BaseSIMDTwoScalarTied<U, 0b11, opc, FPR64, FPR64, asm,
6628         [(set (i64 FPR64:$dst), (OpNode (i64 FPR64:$Rd), (i64 FPR64:$Rn)))]>;
6629     def v1i32  : BaseSIMDTwoScalarTied<U, 0b10, opc, FPR32, FPR32, asm,
6630         [(set (i32 FPR32:$dst), (OpNode (i32 FPR32:$Rd), (i32 FPR32:$Rn)))]>;
6631     def v1i16  : BaseSIMDTwoScalarTied<U, 0b01, opc, FPR16, FPR16, asm, []>;
6632     def v1i8   : BaseSIMDTwoScalarTied<U, 0b00, opc, FPR8 , FPR8 , asm, []>;
6633   }
6634
6635   def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rd), (v1i64 FPR64:$Rn))),
6636             (!cast<Instruction>(NAME # v1i64) FPR64:$Rd, FPR64:$Rn)>;
6637 }
6638
6639
6640
6641 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6642 multiclass SIMDTwoScalarMixedBHS<bit U, bits<5> opc, string asm,
6643                                  SDPatternOperator OpNode = null_frag> {
6644   def v1i32  : BaseSIMDTwoScalar<U, 0b10, 0b00, opc, FPR32, FPR64, asm,
6645         [(set (i32 FPR32:$Rd), (OpNode (i64 FPR64:$Rn)))]>;
6646   def v1i16  : BaseSIMDTwoScalar<U, 0b01, 0b00, opc, FPR16, FPR32, asm, []>;
6647   def v1i8   : BaseSIMDTwoScalar<U, 0b00, 0b00, opc, FPR8 , FPR16, asm, []>;
6648 }
6649
6650 //----------------------------------------------------------------------------
6651 // AdvSIMD scalar pairwise instructions
6652 //----------------------------------------------------------------------------
6653
6654 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6655 class BaseSIMDPairwiseScalar<bit U, bits<2> size, bits<5> opcode,
6656                         RegisterOperand regtype, RegisterOperand vectype,
6657                         string asm, string kind>
6658   : I<(outs regtype:$Rd), (ins vectype:$Rn), asm,
6659       "{\t$Rd, $Rn" # kind # "|" # kind # "\t$Rd, $Rn}", "", []>,
6660     Sched<[WriteV]> {
6661   bits<5> Rd;
6662   bits<5> Rn;
6663   let Inst{31-30} = 0b01;
6664   let Inst{29}    = U;
6665   let Inst{28-24} = 0b11110;
6666   let Inst{23-22} = size;
6667   let Inst{21-17} = 0b11000;
6668   let Inst{16-12} = opcode;
6669   let Inst{11-10} = 0b10;
6670   let Inst{9-5}   = Rn;
6671   let Inst{4-0}   = Rd;
6672 }
6673
6674 multiclass SIMDPairwiseScalarD<bit U, bits<5> opc, string asm> {
6675   def v2i64p : BaseSIMDPairwiseScalar<U, 0b11, opc, FPR64Op, V128,
6676                                       asm, ".2d">;
6677 }
6678
6679 multiclass SIMDFPPairwiseScalar<bit S, bits<5> opc, string asm> {
6680   let Predicates = [HasNEON, HasFullFP16] in {
6681   def v2i16p : BaseSIMDPairwiseScalar<0, {S,0}, opc, FPR16Op, V64,
6682                                       asm, ".2h">;
6683   }
6684   def v2i32p : BaseSIMDPairwiseScalar<1, {S,0}, opc, FPR32Op, V64,
6685                                       asm, ".2s">;
6686   def v2i64p : BaseSIMDPairwiseScalar<1, {S,1}, opc, FPR64Op, V128,
6687                                       asm, ".2d">;
6688 }
6689
6690 //----------------------------------------------------------------------------
6691 // AdvSIMD across lanes instructions
6692 //----------------------------------------------------------------------------
6693
6694 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
6695 class BaseSIMDAcrossLanes<bit Q, bit U, bits<2> size, bits<5> opcode,
6696                           RegisterClass regtype, RegisterOperand vectype,
6697                           string asm, string kind, list<dag> pattern>
6698   : I<(outs regtype:$Rd), (ins vectype:$Rn), asm,
6699       "{\t$Rd, $Rn" # kind # "|" # kind # "\t$Rd, $Rn}", "", pattern>,
6700     Sched<[WriteV]> {
6701   bits<5> Rd;
6702   bits<5> Rn;
6703   let Inst{31}    = 0;
6704   let Inst{30}    = Q;
6705   let Inst{29}    = U;
6706   let Inst{28-24} = 0b01110;
6707   let Inst{23-22} = size;
6708   let Inst{21-17} = 0b11000;
6709   let Inst{16-12} = opcode;
6710   let Inst{11-10} = 0b10;
6711   let Inst{9-5}   = Rn;
6712   let Inst{4-0}   = Rd;
6713 }
6714
6715 multiclass SIMDAcrossLanesBHS<bit U, bits<5> opcode,
6716                               string asm> {
6717   def v8i8v  : BaseSIMDAcrossLanes<0, U, 0b00, opcode, FPR8,  V64,
6718                                    asm, ".8b", []>;
6719   def v16i8v : BaseSIMDAcrossLanes<1, U, 0b00, opcode, FPR8,  V128,
6720                                    asm, ".16b", []>;
6721   def v4i16v : BaseSIMDAcrossLanes<0, U, 0b01, opcode, FPR16, V64,
6722                                    asm, ".4h", []>;
6723   def v8i16v : BaseSIMDAcrossLanes<1, U, 0b01, opcode, FPR16, V128,
6724                                    asm, ".8h", []>;
6725   def v4i32v : BaseSIMDAcrossLanes<1, U, 0b10, opcode, FPR32, V128,
6726                                    asm, ".4s", []>;
6727 }
6728
6729 multiclass SIMDAcrossLanesHSD<bit U, bits<5> opcode, string asm> {
6730   def v8i8v  : BaseSIMDAcrossLanes<0, U, 0b00, opcode, FPR16, V64,
6731                                    asm, ".8b", []>;
6732   def v16i8v : BaseSIMDAcrossLanes<1, U, 0b00, opcode, FPR16, V128,
6733                                    asm, ".16b", []>;
6734   def v4i16v : BaseSIMDAcrossLanes<0, U, 0b01, opcode, FPR32, V64,
6735                                    asm, ".4h", []>;
6736   def v8i16v : BaseSIMDAcrossLanes<1, U, 0b01, opcode, FPR32, V128,
6737                                    asm, ".8h", []>;
6738   def v4i32v : BaseSIMDAcrossLanes<1, U, 0b10, opcode, FPR64, V128,
6739                                    asm, ".4s", []>;
6740 }
6741
6742 multiclass SIMDFPAcrossLanes<bits<5> opcode, bit sz1, string asm,
6743                             Intrinsic intOp> {
6744   let Predicates = [HasNEON, HasFullFP16] in {
6745   def v4i16v : BaseSIMDAcrossLanes<0, 0, {sz1, 0}, opcode, FPR16, V64,
6746                                    asm, ".4h",
6747         [(set FPR16:$Rd, (intOp (v4f16 V64:$Rn)))]>;
6748   def v8i16v : BaseSIMDAcrossLanes<1, 0, {sz1, 0}, opcode, FPR16, V128,
6749                                    asm, ".8h",
6750         [(set FPR16:$Rd, (intOp (v8f16 V128:$Rn)))]>;
6751   } // Predicates = [HasNEON, HasFullFP16]
6752   def v4i32v : BaseSIMDAcrossLanes<1, 1, {sz1, 0}, opcode, FPR32, V128,
6753                                    asm, ".4s",
6754         [(set FPR32:$Rd, (intOp (v4f32 V128:$Rn)))]>;
6755 }
6756
6757 //----------------------------------------------------------------------------
6758 // AdvSIMD INS/DUP instructions
6759 //----------------------------------------------------------------------------
6760
6761 // FIXME: There has got to be a better way to factor these. ugh.
6762
6763 class BaseSIMDInsDup<bit Q, bit op, dag outs, dag ins, string asm,
6764                      string operands, string constraints, list<dag> pattern>
6765   : I<outs, ins, asm, operands, constraints, pattern>,
6766     Sched<[WriteV]> {
6767   bits<5> Rd;
6768   bits<5> Rn;
6769   let Inst{31} = 0;
6770   let Inst{30} = Q;
6771   let Inst{29} = op;
6772   let Inst{28-21} = 0b01110000;
6773   let Inst{15} = 0;
6774   let Inst{10} = 1;
6775   let Inst{9-5} = Rn;
6776   let Inst{4-0} = Rd;
6777 }
6778
6779 class SIMDDupFromMain<bit Q, bits<5> imm5, string size, ValueType vectype,
6780                       RegisterOperand vecreg, RegisterClass regtype>
6781   : BaseSIMDInsDup<Q, 0, (outs vecreg:$Rd), (ins regtype:$Rn), "dup",
6782                    "{\t$Rd" # size # ", $Rn" #
6783                    "|" # size # "\t$Rd, $Rn}", "",
6784                    [(set (vectype vecreg:$Rd), (AArch64dup regtype:$Rn))]> {
6785   let Inst{20-16} = imm5;
6786   let Inst{14-11} = 0b0001;
6787 }
6788
6789 class SIMDDupFromElement<bit Q, string dstkind, string srckind,
6790                          ValueType vectype, ValueType insreg,
6791                          RegisterOperand vecreg, Operand idxtype,
6792                          ValueType elttype, SDNode OpNode>
6793   : BaseSIMDInsDup<Q, 0, (outs vecreg:$Rd), (ins V128:$Rn, idxtype:$idx), "dup",
6794                    "{\t$Rd" # dstkind # ", $Rn" # srckind # "$idx" #
6795                    "|" # dstkind # "\t$Rd, $Rn$idx}", "",
6796                  [(set (vectype vecreg:$Rd),
6797                        (OpNode (insreg V128:$Rn), idxtype:$idx))]> {
6798   let Inst{14-11} = 0b0000;
6799 }
6800
6801 class SIMDDup64FromElement
6802   : SIMDDupFromElement<1, ".2d", ".d", v2i64, v2i64, V128,
6803                        VectorIndexD, i64, AArch64duplane64> {
6804   bits<1> idx;
6805   let Inst{20} = idx;
6806   let Inst{19-16} = 0b1000;
6807 }
6808
6809 class SIMDDup32FromElement<bit Q, string size, ValueType vectype,
6810                            RegisterOperand vecreg>
6811   : SIMDDupFromElement<Q, size, ".s", vectype, v4i32, vecreg,
6812                        VectorIndexS, i64, AArch64duplane32> {
6813   bits<2> idx;
6814   let Inst{20-19} = idx;
6815   let Inst{18-16} = 0b100;
6816 }
6817
6818 class SIMDDup16FromElement<bit Q, string size, ValueType vectype,
6819                            RegisterOperand vecreg>
6820   : SIMDDupFromElement<Q, size, ".h", vectype, v8i16, vecreg,
6821                        VectorIndexH, i64, AArch64duplane16> {
6822   bits<3> idx;
6823   let Inst{20-18} = idx;
6824   let Inst{17-16} = 0b10;
6825 }
6826
6827 class SIMDDup8FromElement<bit Q, string size, ValueType vectype,
6828                           RegisterOperand vecreg>
6829   : SIMDDupFromElement<Q, size, ".b", vectype, v16i8, vecreg,
6830                        VectorIndexB, i64, AArch64duplane8> {
6831   bits<4> idx;
6832   let Inst{20-17} = idx;
6833   let Inst{16} = 1;
6834 }
6835
6836 class BaseSIMDMov<bit Q, string size, bits<4> imm4, RegisterClass regtype,
6837                   Operand idxtype, string asm, list<dag> pattern>
6838   : BaseSIMDInsDup<Q, 0, (outs regtype:$Rd), (ins V128:$Rn, idxtype:$idx), asm,
6839                    "{\t$Rd, $Rn" # size # "$idx" #
6840                    "|" # size # "\t$Rd, $Rn$idx}", "", pattern> {
6841   let Inst{14-11} = imm4;
6842 }
6843
6844 class SIMDSMov<bit Q, string size, RegisterClass regtype,
6845                Operand idxtype>
6846   : BaseSIMDMov<Q, size, 0b0101, regtype, idxtype, "smov", []>;
6847 class SIMDUMov<bit Q, string size, ValueType vectype, RegisterClass regtype,
6848                Operand idxtype>
6849   : BaseSIMDMov<Q, size, 0b0111, regtype, idxtype, "umov",
6850       [(set regtype:$Rd, (vector_extract (vectype V128:$Rn), idxtype:$idx))]>;
6851
6852 class SIMDMovAlias<string asm, string size, Instruction inst,
6853                    RegisterClass regtype, Operand idxtype>
6854     : InstAlias<asm#"{\t$dst, $src"#size#"$idx" #
6855                     "|" # size # "\t$dst, $src$idx}",
6856                 (inst regtype:$dst, V128:$src, idxtype:$idx)>;
6857
6858 multiclass SMov {
6859   def vi8to32 : SIMDSMov<0, ".b", GPR32, VectorIndexB> {
6860     bits<4> idx;
6861     let Inst{20-17} = idx;
6862     let Inst{16} = 1;
6863   }
6864   def vi8to64 : SIMDSMov<1, ".b", GPR64, VectorIndexB> {
6865     bits<4> idx;
6866     let Inst{20-17} = idx;
6867     let Inst{16} = 1;
6868   }
6869   def vi16to32 : SIMDSMov<0, ".h", GPR32, VectorIndexH> {
6870     bits<3> idx;
6871     let Inst{20-18} = idx;
6872     let Inst{17-16} = 0b10;
6873   }
6874   def vi16to64 : SIMDSMov<1, ".h", GPR64, VectorIndexH> {
6875     bits<3> idx;
6876     let Inst{20-18} = idx;
6877     let Inst{17-16} = 0b10;
6878   }
6879   def vi32to64 : SIMDSMov<1, ".s", GPR64, VectorIndexS> {
6880     bits<2> idx;
6881     let Inst{20-19} = idx;
6882     let Inst{18-16} = 0b100;
6883   }
6884 }
6885
6886 multiclass UMov {
6887   def vi8 : SIMDUMov<0, ".b", v16i8, GPR32, VectorIndexB> {
6888     bits<4> idx;
6889     let Inst{20-17} = idx;
6890     let Inst{16} = 1;
6891   }
6892   def vi16 : SIMDUMov<0, ".h", v8i16, GPR32, VectorIndexH> {
6893     bits<3> idx;
6894     let Inst{20-18} = idx;
6895     let Inst{17-16} = 0b10;
6896   }
6897   def vi32 : SIMDUMov<0, ".s", v4i32, GPR32, VectorIndexS> {
6898     bits<2> idx;
6899     let Inst{20-19} = idx;
6900     let Inst{18-16} = 0b100;
6901   }
6902   def vi64 : SIMDUMov<1, ".d", v2i64, GPR64, VectorIndexD> {
6903     bits<1> idx;
6904     let Inst{20} = idx;
6905     let Inst{19-16} = 0b1000;
6906   }
6907   def : SIMDMovAlias<"mov", ".s",
6908                      !cast<Instruction>(NAME#"vi32"),
6909                      GPR32, VectorIndexS>;
6910   def : SIMDMovAlias<"mov", ".d",
6911                      !cast<Instruction>(NAME#"vi64"),
6912                      GPR64, VectorIndexD>;
6913 }
6914
6915 class SIMDInsFromMain<string size, ValueType vectype,
6916                       RegisterClass regtype, Operand idxtype>
6917   : BaseSIMDInsDup<1, 0, (outs V128:$dst),
6918                    (ins V128:$Rd, idxtype:$idx, regtype:$Rn), "ins",
6919                    "{\t$Rd" # size # "$idx, $Rn" #
6920                    "|" # size # "\t$Rd$idx, $Rn}",
6921                    "$Rd = $dst",
6922             [(set V128:$dst,
6923               (vector_insert (vectype V128:$Rd), regtype:$Rn, idxtype:$idx))]> {
6924   let Inst{14-11} = 0b0011;
6925 }
6926
6927 class SIMDInsFromElement<string size, ValueType vectype,
6928                          ValueType elttype, Operand idxtype>
6929   : BaseSIMDInsDup<1, 1, (outs V128:$dst),
6930                    (ins V128:$Rd, idxtype:$idx, V128:$Rn, idxtype:$idx2), "ins",
6931                    "{\t$Rd" # size # "$idx, $Rn" # size # "$idx2" #
6932                    "|" # size # "\t$Rd$idx, $Rn$idx2}",
6933                    "$Rd = $dst",
6934          [(set V128:$dst,
6935                (vector_insert
6936                  (vectype V128:$Rd),
6937                  (elttype (vector_extract (vectype V128:$Rn), idxtype:$idx2)),
6938                  idxtype:$idx))]>;
6939
6940 class SIMDInsMainMovAlias<string size, Instruction inst,
6941                           RegisterClass regtype, Operand idxtype>
6942     : InstAlias<"mov" # "{\t$dst" # size # "$idx, $src" #
6943                         "|" # size #"\t$dst$idx, $src}",
6944                 (inst V128:$dst, idxtype:$idx, regtype:$src)>;
6945 class SIMDInsElementMovAlias<string size, Instruction inst,
6946                              Operand idxtype>
6947     : InstAlias<"mov" # "{\t$dst" # size # "$idx, $src" # size # "$idx2" #
6948                       # "|" # size #"\t$dst$idx, $src$idx2}",
6949                 (inst V128:$dst, idxtype:$idx, V128:$src, idxtype:$idx2)>;
6950
6951
6952 multiclass SIMDIns {
6953   def vi8gpr : SIMDInsFromMain<".b", v16i8, GPR32, VectorIndexB> {
6954     bits<4> idx;
6955     let Inst{20-17} = idx;
6956     let Inst{16} = 1;
6957   }
6958   def vi16gpr : SIMDInsFromMain<".h", v8i16, GPR32, VectorIndexH> {
6959     bits<3> idx;
6960     let Inst{20-18} = idx;
6961     let Inst{17-16} = 0b10;
6962   }
6963   def vi32gpr : SIMDInsFromMain<".s", v4i32, GPR32, VectorIndexS> {
6964     bits<2> idx;
6965     let Inst{20-19} = idx;
6966     let Inst{18-16} = 0b100;
6967   }
6968   def vi64gpr : SIMDInsFromMain<".d", v2i64, GPR64, VectorIndexD> {
6969     bits<1> idx;
6970     let Inst{20} = idx;
6971     let Inst{19-16} = 0b1000;
6972   }
6973
6974   def vi8lane : SIMDInsFromElement<".b", v16i8, i32, VectorIndexB> {
6975     bits<4> idx;
6976     bits<4> idx2;
6977     let Inst{20-17} = idx;
6978     let Inst{16} = 1;
6979     let Inst{14-11} = idx2;
6980   }
6981   def vi16lane : SIMDInsFromElement<".h", v8i16, i32, VectorIndexH> {
6982     bits<3> idx;
6983     bits<3> idx2;
6984     let Inst{20-18} = idx;
6985     let Inst{17-16} = 0b10;
6986     let Inst{14-12} = idx2;
6987     let Inst{11} = {?};
6988   }
6989   def vi32lane : SIMDInsFromElement<".s", v4i32, i32, VectorIndexS> {
6990     bits<2> idx;
6991     bits<2> idx2;
6992     let Inst{20-19} = idx;
6993     let Inst{18-16} = 0b100;
6994     let Inst{14-13} = idx2;
6995     let Inst{12-11} = {?,?};
6996   }
6997   def vi64lane : SIMDInsFromElement<".d", v2i64, i64, VectorIndexD> {
6998     bits<1> idx;
6999     bits<1> idx2;
7000     let Inst{20} = idx;
7001     let Inst{19-16} = 0b1000;
7002     let Inst{14} = idx2;
7003     let Inst{13-11} = {?,?,?};
7004   }
7005
7006   // For all forms of the INS instruction, the "mov" mnemonic is the
7007   // preferred alias. Why they didn't just call the instruction "mov" in
7008   // the first place is a very good question indeed...
7009   def : SIMDInsMainMovAlias<".b", !cast<Instruction>(NAME#"vi8gpr"),
7010                          GPR32, VectorIndexB>;
7011   def : SIMDInsMainMovAlias<".h", !cast<Instruction>(NAME#"vi16gpr"),
7012                          GPR32, VectorIndexH>;
7013   def : SIMDInsMainMovAlias<".s", !cast<Instruction>(NAME#"vi32gpr"),
7014                          GPR32, VectorIndexS>;
7015   def : SIMDInsMainMovAlias<".d", !cast<Instruction>(NAME#"vi64gpr"),
7016                          GPR64, VectorIndexD>;
7017
7018   def : SIMDInsElementMovAlias<".b", !cast<Instruction>(NAME#"vi8lane"),
7019                          VectorIndexB>;
7020   def : SIMDInsElementMovAlias<".h", !cast<Instruction>(NAME#"vi16lane"),
7021                          VectorIndexH>;
7022   def : SIMDInsElementMovAlias<".s", !cast<Instruction>(NAME#"vi32lane"),
7023                          VectorIndexS>;
7024   def : SIMDInsElementMovAlias<".d", !cast<Instruction>(NAME#"vi64lane"),
7025                          VectorIndexD>;
7026 }
7027
7028 //----------------------------------------------------------------------------
7029 // AdvSIMD TBL/TBX
7030 //----------------------------------------------------------------------------
7031
7032 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
7033 class BaseSIMDTableLookup<bit Q, bits<2> len, bit op, RegisterOperand vectype,
7034                           RegisterOperand listtype, string asm, string kind>
7035   : I<(outs vectype:$Vd), (ins listtype:$Vn, vectype:$Vm), asm,
7036        "\t$Vd" # kind # ", $Vn, $Vm" # kind, "", []>,
7037     Sched<[WriteV]> {
7038   bits<5> Vd;
7039   bits<5> Vn;
7040   bits<5> Vm;
7041   let Inst{31}    = 0;
7042   let Inst{30}    = Q;
7043   let Inst{29-21} = 0b001110000;
7044   let Inst{20-16} = Vm;
7045   let Inst{15}    = 0;
7046   let Inst{14-13} = len;
7047   let Inst{12}    = op;
7048   let Inst{11-10} = 0b00;
7049   let Inst{9-5}   = Vn;
7050   let Inst{4-0}   = Vd;
7051 }
7052
7053 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
7054 class BaseSIMDTableLookupTied<bit Q, bits<2> len, bit op, RegisterOperand vectype,
7055                           RegisterOperand listtype, string asm, string kind>
7056   : I<(outs vectype:$dst), (ins vectype:$Vd, listtype:$Vn, vectype:$Vm), asm,
7057        "\t$Vd" # kind # ", $Vn, $Vm" # kind, "$Vd = $dst", []>,
7058     Sched<[WriteV]> {
7059   bits<5> Vd;
7060   bits<5> Vn;
7061   bits<5> Vm;
7062   let Inst{31}    = 0;
7063   let Inst{30}    = Q;
7064   let Inst{29-21} = 0b001110000;
7065   let Inst{20-16} = Vm;
7066   let Inst{15}    = 0;
7067   let Inst{14-13} = len;
7068   let Inst{12}    = op;
7069   let Inst{11-10} = 0b00;
7070   let Inst{9-5}   = Vn;
7071   let Inst{4-0}   = Vd;
7072 }
7073
7074 class SIMDTableLookupAlias<string asm, Instruction inst,
7075                           RegisterOperand vectype, RegisterOperand listtype>
7076     : InstAlias<!strconcat(asm, "\t$dst, $lst, $index"),
7077                 (inst vectype:$dst, listtype:$lst, vectype:$index), 0>;
7078
7079 multiclass SIMDTableLookup<bit op, string asm> {
7080   def v8i8One   : BaseSIMDTableLookup<0, 0b00, op, V64, VecListOne16b,
7081                                       asm, ".8b">;
7082   def v8i8Two   : BaseSIMDTableLookup<0, 0b01, op, V64, VecListTwo16b,
7083                                       asm, ".8b">;
7084   def v8i8Three : BaseSIMDTableLookup<0, 0b10, op, V64, VecListThree16b,
7085                                       asm, ".8b">;
7086   def v8i8Four  : BaseSIMDTableLookup<0, 0b11, op, V64, VecListFour16b,
7087                                       asm, ".8b">;
7088   def v16i8One  : BaseSIMDTableLookup<1, 0b00, op, V128, VecListOne16b,
7089                                       asm, ".16b">;
7090   def v16i8Two  : BaseSIMDTableLookup<1, 0b01, op, V128, VecListTwo16b,
7091                                       asm, ".16b">;
7092   def v16i8Three: BaseSIMDTableLookup<1, 0b10, op, V128, VecListThree16b,
7093                                       asm, ".16b">;
7094   def v16i8Four : BaseSIMDTableLookup<1, 0b11, op, V128, VecListFour16b,
7095                                       asm, ".16b">;
7096
7097   def : SIMDTableLookupAlias<asm # ".8b",
7098                          !cast<Instruction>(NAME#"v8i8One"),
7099                          V64, VecListOne128>;
7100   def : SIMDTableLookupAlias<asm # ".8b",
7101                          !cast<Instruction>(NAME#"v8i8Two"),
7102                          V64, VecListTwo128>;
7103   def : SIMDTableLookupAlias<asm # ".8b",
7104                          !cast<Instruction>(NAME#"v8i8Three"),
7105                          V64, VecListThree128>;
7106   def : SIMDTableLookupAlias<asm # ".8b",
7107                          !cast<Instruction>(NAME#"v8i8Four"),
7108                          V64, VecListFour128>;
7109   def : SIMDTableLookupAlias<asm # ".16b",
7110                          !cast<Instruction>(NAME#"v16i8One"),
7111                          V128, VecListOne128>;
7112   def : SIMDTableLookupAlias<asm # ".16b",
7113                          !cast<Instruction>(NAME#"v16i8Two"),
7114                          V128, VecListTwo128>;
7115   def : SIMDTableLookupAlias<asm # ".16b",
7116                          !cast<Instruction>(NAME#"v16i8Three"),
7117                          V128, VecListThree128>;
7118   def : SIMDTableLookupAlias<asm # ".16b",
7119                          !cast<Instruction>(NAME#"v16i8Four"),
7120                          V128, VecListFour128>;
7121 }
7122
7123 multiclass SIMDTableLookupTied<bit op, string asm> {
7124   def v8i8One   : BaseSIMDTableLookupTied<0, 0b00, op, V64, VecListOne16b,
7125                                       asm, ".8b">;
7126   def v8i8Two   : BaseSIMDTableLookupTied<0, 0b01, op, V64, VecListTwo16b,
7127                                       asm, ".8b">;
7128   def v8i8Three : BaseSIMDTableLookupTied<0, 0b10, op, V64, VecListThree16b,
7129                                       asm, ".8b">;
7130   def v8i8Four  : BaseSIMDTableLookupTied<0, 0b11, op, V64, VecListFour16b,
7131                                       asm, ".8b">;
7132   def v16i8One  : BaseSIMDTableLookupTied<1, 0b00, op, V128, VecListOne16b,
7133                                       asm, ".16b">;
7134   def v16i8Two  : BaseSIMDTableLookupTied<1, 0b01, op, V128, VecListTwo16b,
7135                                       asm, ".16b">;
7136   def v16i8Three: BaseSIMDTableLookupTied<1, 0b10, op, V128, VecListThree16b,
7137                                       asm, ".16b">;
7138   def v16i8Four : BaseSIMDTableLookupTied<1, 0b11, op, V128, VecListFour16b,
7139                                       asm, ".16b">;
7140
7141   def : SIMDTableLookupAlias<asm # ".8b",
7142                          !cast<Instruction>(NAME#"v8i8One"),
7143                          V64, VecListOne128>;
7144   def : SIMDTableLookupAlias<asm # ".8b",
7145                          !cast<Instruction>(NAME#"v8i8Two"),
7146                          V64, VecListTwo128>;
7147   def : SIMDTableLookupAlias<asm # ".8b",
7148                          !cast<Instruction>(NAME#"v8i8Three"),
7149                          V64, VecListThree128>;
7150   def : SIMDTableLookupAlias<asm # ".8b",
7151                          !cast<Instruction>(NAME#"v8i8Four"),
7152                          V64, VecListFour128>;
7153   def : SIMDTableLookupAlias<asm # ".16b",
7154                          !cast<Instruction>(NAME#"v16i8One"),
7155                          V128, VecListOne128>;
7156   def : SIMDTableLookupAlias<asm # ".16b",
7157                          !cast<Instruction>(NAME#"v16i8Two"),
7158                          V128, VecListTwo128>;
7159   def : SIMDTableLookupAlias<asm # ".16b",
7160                          !cast<Instruction>(NAME#"v16i8Three"),
7161                          V128, VecListThree128>;
7162   def : SIMDTableLookupAlias<asm # ".16b",
7163                          !cast<Instruction>(NAME#"v16i8Four"),
7164                          V128, VecListFour128>;
7165 }
7166
7167
7168 //----------------------------------------------------------------------------
7169 // AdvSIMD scalar CPY
7170 //----------------------------------------------------------------------------
7171 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
7172 class BaseSIMDScalarCPY<RegisterClass regtype, RegisterOperand vectype,
7173                         string kind, Operand idxtype>
7174   : I<(outs regtype:$dst), (ins vectype:$src, idxtype:$idx), "mov",
7175        "{\t$dst, $src" # kind # "$idx" #
7176        "|\t$dst, $src$idx}", "", []>,
7177     Sched<[WriteV]> {
7178   bits<5> dst;
7179   bits<5> src;
7180   let Inst{31-21} = 0b01011110000;
7181   let Inst{15-10} = 0b000001;
7182   let Inst{9-5}   = src;
7183   let Inst{4-0}   = dst;
7184 }
7185
7186 class SIMDScalarCPYAlias<string asm, string size, Instruction inst,
7187       RegisterClass regtype, RegisterOperand vectype, Operand idxtype>
7188     : InstAlias<asm # "{\t$dst, $src" # size # "$index" #
7189                     # "|\t$dst, $src$index}",
7190                 (inst regtype:$dst, vectype:$src, idxtype:$index), 0>;
7191
7192
7193 multiclass SIMDScalarCPY<string asm> {
7194   def i8  : BaseSIMDScalarCPY<FPR8,  V128, ".b", VectorIndexB> {
7195     bits<4> idx;
7196     let Inst{20-17} = idx;
7197     let Inst{16} = 1;
7198   }
7199   def i16 : BaseSIMDScalarCPY<FPR16, V128, ".h", VectorIndexH> {
7200     bits<3> idx;
7201     let Inst{20-18} = idx;
7202     let Inst{17-16} = 0b10;
7203   }
7204   def i32 : BaseSIMDScalarCPY<FPR32, V128, ".s", VectorIndexS> {
7205     bits<2> idx;
7206     let Inst{20-19} = idx;
7207     let Inst{18-16} = 0b100;
7208   }
7209   def i64 : BaseSIMDScalarCPY<FPR64, V128, ".d", VectorIndexD> {
7210     bits<1> idx;
7211     let Inst{20} = idx;
7212     let Inst{19-16} = 0b1000;
7213   }
7214
7215   def : Pat<(v1i64 (scalar_to_vector (i64 (vector_extract (v2i64 V128:$src),
7216                                                           VectorIndexD:$idx)))),
7217             (!cast<Instruction>(NAME # i64) V128:$src, VectorIndexD:$idx)>;
7218
7219   // 'DUP' mnemonic aliases.
7220   def : SIMDScalarCPYAlias<"dup", ".b",
7221                            !cast<Instruction>(NAME#"i8"),
7222                            FPR8, V128, VectorIndexB>;
7223   def : SIMDScalarCPYAlias<"dup", ".h",
7224                            !cast<Instruction>(NAME#"i16"),
7225                            FPR16, V128, VectorIndexH>;
7226   def : SIMDScalarCPYAlias<"dup", ".s",
7227                            !cast<Instruction>(NAME#"i32"),
7228                            FPR32, V128, VectorIndexS>;
7229   def : SIMDScalarCPYAlias<"dup", ".d",
7230                            !cast<Instruction>(NAME#"i64"),
7231                            FPR64, V128, VectorIndexD>;
7232 }
7233
7234 //----------------------------------------------------------------------------
7235 // AdvSIMD modified immediate instructions
7236 //----------------------------------------------------------------------------
7237
7238 class BaseSIMDModifiedImm<bit Q, bit op, bit op2, dag oops, dag iops,
7239                           string asm, string op_string,
7240                           string cstr, list<dag> pattern>
7241   : I<oops, iops, asm, op_string, cstr, pattern>,
7242     Sched<[WriteV]> {
7243   bits<5> Rd;
7244   bits<8> imm8;
7245   let Inst{31}    = 0;
7246   let Inst{30}    = Q;
7247   let Inst{29}    = op;
7248   let Inst{28-19} = 0b0111100000;
7249   let Inst{18-16} = imm8{7-5};
7250   let Inst{11} = op2;
7251   let Inst{10} = 1;
7252   let Inst{9-5}   = imm8{4-0};
7253   let Inst{4-0}   = Rd;
7254 }
7255
7256 class BaseSIMDModifiedImmVector<bit Q, bit op, bit op2, RegisterOperand vectype,
7257                                 Operand immtype, dag opt_shift_iop,
7258                                 string opt_shift, string asm, string kind,
7259                                 list<dag> pattern>
7260   : BaseSIMDModifiedImm<Q, op, op2, (outs vectype:$Rd),
7261                         !con((ins immtype:$imm8), opt_shift_iop), asm,
7262                         "{\t$Rd" # kind # ", $imm8" # opt_shift #
7263                         "|" # kind # "\t$Rd, $imm8" # opt_shift # "}",
7264                         "", pattern> {
7265   let DecoderMethod = "DecodeModImmInstruction";
7266 }
7267
7268 class BaseSIMDModifiedImmVectorTied<bit Q, bit op, RegisterOperand vectype,
7269                                 Operand immtype, dag opt_shift_iop,
7270                                 string opt_shift, string asm, string kind,
7271                                 list<dag> pattern>
7272   : BaseSIMDModifiedImm<Q, op, 0, (outs vectype:$dst),
7273                         !con((ins vectype:$Rd, immtype:$imm8), opt_shift_iop),
7274                         asm, "{\t$Rd" # kind # ", $imm8" # opt_shift #
7275                              "|" # kind # "\t$Rd, $imm8" # opt_shift # "}",
7276                         "$Rd = $dst", pattern> {
7277   let DecoderMethod = "DecodeModImmTiedInstruction";
7278 }
7279
7280 class BaseSIMDModifiedImmVectorShift<bit Q, bit op, bits<2> b15_b12,
7281                                      RegisterOperand vectype, string asm,
7282                                      string kind, list<dag> pattern>
7283   : BaseSIMDModifiedImmVector<Q, op, 0, vectype, imm0_255,
7284                               (ins logical_vec_shift:$shift),
7285                               "$shift", asm, kind, pattern> {
7286   bits<2> shift;
7287   let Inst{15}    = b15_b12{1};
7288   let Inst{14-13} = shift;
7289   let Inst{12}    = b15_b12{0};
7290 }
7291
7292 class BaseSIMDModifiedImmVectorShiftTied<bit Q, bit op, bits<2> b15_b12,
7293                                      RegisterOperand vectype, string asm,
7294                                      string kind, list<dag> pattern>
7295   : BaseSIMDModifiedImmVectorTied<Q, op, vectype, imm0_255,
7296                               (ins logical_vec_shift:$shift),
7297                               "$shift", asm, kind, pattern> {
7298   bits<2> shift;
7299   let Inst{15}    = b15_b12{1};
7300   let Inst{14-13} = shift;
7301   let Inst{12}    = b15_b12{0};
7302 }
7303
7304
7305 class BaseSIMDModifiedImmVectorShiftHalf<bit Q, bit op, bits<2> b15_b12,
7306                                          RegisterOperand vectype, string asm,
7307                                          string kind, list<dag> pattern>
7308   : BaseSIMDModifiedImmVector<Q, op, 0, vectype, imm0_255,
7309                               (ins logical_vec_hw_shift:$shift),
7310                               "$shift", asm, kind, pattern> {
7311   bits<2> shift;
7312   let Inst{15} = b15_b12{1};
7313   let Inst{14} = 0;
7314   let Inst{13} = shift{0};
7315   let Inst{12} = b15_b12{0};
7316 }
7317
7318 class BaseSIMDModifiedImmVectorShiftHalfTied<bit Q, bit op, bits<2> b15_b12,
7319                                          RegisterOperand vectype, string asm,
7320                                          string kind, list<dag> pattern>
7321   : BaseSIMDModifiedImmVectorTied<Q, op, vectype, imm0_255,
7322                               (ins logical_vec_hw_shift:$shift),
7323                               "$shift", asm, kind, pattern> {
7324   bits<2> shift;
7325   let Inst{15} = b15_b12{1};
7326   let Inst{14} = 0;
7327   let Inst{13} = shift{0};
7328   let Inst{12} = b15_b12{0};
7329 }
7330
7331 multiclass SIMDModifiedImmVectorShift<bit op, bits<2> hw_cmode, bits<2> w_cmode,
7332                                       string asm> {
7333   def v4i16 : BaseSIMDModifiedImmVectorShiftHalf<0, op, hw_cmode, V64,
7334                                                  asm, ".4h", []>;
7335   def v8i16 : BaseSIMDModifiedImmVectorShiftHalf<1, op, hw_cmode, V128,
7336                                                  asm, ".8h", []>;
7337
7338   def v2i32 : BaseSIMDModifiedImmVectorShift<0, op, w_cmode, V64,
7339                                              asm, ".2s", []>;
7340   def v4i32 : BaseSIMDModifiedImmVectorShift<1, op, w_cmode, V128,
7341                                              asm, ".4s", []>;
7342 }
7343
7344 multiclass SIMDModifiedImmVectorShiftTied<bit op, bits<2> hw_cmode,
7345                                       bits<2> w_cmode, string asm,
7346                                       SDNode OpNode> {
7347   def v4i16 : BaseSIMDModifiedImmVectorShiftHalfTied<0, op, hw_cmode, V64,
7348                                                  asm, ".4h",
7349              [(set (v4i16 V64:$dst), (OpNode V64:$Rd,
7350                                              imm0_255:$imm8,
7351                                              (i32 imm:$shift)))]>;
7352   def v8i16 : BaseSIMDModifiedImmVectorShiftHalfTied<1, op, hw_cmode, V128,
7353                                                  asm, ".8h",
7354              [(set (v8i16 V128:$dst), (OpNode V128:$Rd,
7355                                               imm0_255:$imm8,
7356                                               (i32 imm:$shift)))]>;
7357
7358   def v2i32 : BaseSIMDModifiedImmVectorShiftTied<0, op, w_cmode, V64,
7359                                              asm, ".2s",
7360              [(set (v2i32 V64:$dst), (OpNode V64:$Rd,
7361                                              imm0_255:$imm8,
7362                                              (i32 imm:$shift)))]>;
7363   def v4i32 : BaseSIMDModifiedImmVectorShiftTied<1, op, w_cmode, V128,
7364                                              asm, ".4s",
7365              [(set (v4i32 V128:$dst), (OpNode V128:$Rd,
7366                                               imm0_255:$imm8,
7367                                               (i32 imm:$shift)))]>;
7368 }
7369
7370 class SIMDModifiedImmMoveMSL<bit Q, bit op, bits<4> cmode,
7371                              RegisterOperand vectype, string asm,
7372                              string kind, list<dag> pattern>
7373   : BaseSIMDModifiedImmVector<Q, op, 0, vectype, imm0_255,
7374                               (ins move_vec_shift:$shift),
7375                               "$shift", asm, kind, pattern> {
7376   bits<1> shift;
7377   let Inst{15-13} = cmode{3-1};
7378   let Inst{12}    = shift;
7379 }
7380
7381 class SIMDModifiedImmVectorNoShift<bit Q, bit op, bit op2, bits<4> cmode,
7382                                    RegisterOperand vectype,
7383                                    Operand imm_type, string asm,
7384                                    string kind, list<dag> pattern>
7385   : BaseSIMDModifiedImmVector<Q, op, op2, vectype, imm_type, (ins), "",
7386                               asm, kind, pattern> {
7387   let Inst{15-12} = cmode;
7388 }
7389
7390 class SIMDModifiedImmScalarNoShift<bit Q, bit op, bits<4> cmode, string asm,
7391                                    list<dag> pattern>
7392   : BaseSIMDModifiedImm<Q, op, 0, (outs FPR64:$Rd), (ins simdimmtype10:$imm8), asm,
7393                         "\t$Rd, $imm8", "", pattern> {
7394   let Inst{15-12} = cmode;
7395   let DecoderMethod = "DecodeModImmInstruction";
7396 }
7397
7398 //----------------------------------------------------------------------------
7399 // AdvSIMD indexed element
7400 //----------------------------------------------------------------------------
7401
7402 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
7403 class BaseSIMDIndexed<bit Q, bit U, bit Scalar, bits<2> size, bits<4> opc,
7404                       RegisterOperand dst_reg, RegisterOperand lhs_reg,
7405                       RegisterOperand rhs_reg, Operand vec_idx, string asm,
7406                       string apple_kind, string dst_kind, string lhs_kind,
7407                       string rhs_kind, list<dag> pattern>
7408   : I<(outs dst_reg:$Rd), (ins lhs_reg:$Rn, rhs_reg:$Rm, vec_idx:$idx),
7409       asm,
7410       "{\t$Rd" # dst_kind # ", $Rn" # lhs_kind # ", $Rm" # rhs_kind # "$idx" #
7411       "|" # apple_kind # "\t$Rd, $Rn, $Rm$idx}", "", pattern>,
7412     Sched<[WriteV]> {
7413   bits<5> Rd;
7414   bits<5> Rn;
7415   bits<5> Rm;
7416
7417   let Inst{31}    = 0;
7418   let Inst{30}    = Q;
7419   let Inst{29}    = U;
7420   let Inst{28}    = Scalar;
7421   let Inst{27-24} = 0b1111;
7422   let Inst{23-22} = size;
7423   // Bit 21 must be set by the derived class.
7424   let Inst{20-16} = Rm;
7425   let Inst{15-12} = opc;
7426   // Bit 11 must be set by the derived class.
7427   let Inst{10}    = 0;
7428   let Inst{9-5}   = Rn;
7429   let Inst{4-0}   = Rd;
7430 }
7431
7432 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
7433 class BaseSIMDIndexedTied<bit Q, bit U, bit Scalar, bits<2> size, bits<4> opc,
7434                       RegisterOperand dst_reg, RegisterOperand lhs_reg,
7435                       RegisterOperand rhs_reg, Operand vec_idx, string asm,
7436                       string apple_kind, string dst_kind, string lhs_kind,
7437                       string rhs_kind, list<dag> pattern>
7438   : I<(outs dst_reg:$dst),
7439       (ins dst_reg:$Rd, lhs_reg:$Rn, rhs_reg:$Rm, vec_idx:$idx), asm,
7440       "{\t$Rd" # dst_kind # ", $Rn" # lhs_kind # ", $Rm" # rhs_kind # "$idx" #
7441       "|" # apple_kind # "\t$Rd, $Rn, $Rm$idx}", "$Rd = $dst", pattern>,
7442     Sched<[WriteV]> {
7443   bits<5> Rd;
7444   bits<5> Rn;
7445   bits<5> Rm;
7446
7447   let Inst{31}    = 0;
7448   let Inst{30}    = Q;
7449   let Inst{29}    = U;
7450   let Inst{28}    = Scalar;
7451   let Inst{27-24} = 0b1111;
7452   let Inst{23-22} = size;
7453   // Bit 21 must be set by the derived class.
7454   let Inst{20-16} = Rm;
7455   let Inst{15-12} = opc;
7456   // Bit 11 must be set by the derived class.
7457   let Inst{10}    = 0;
7458   let Inst{9-5}   = Rn;
7459   let Inst{4-0}   = Rd;
7460 }
7461
7462 // ARMv8.2-A Dot Product Instructions (Indexed)
7463 class BaseSIMDThreeSameVectorDotIndex<bit Q, bit U, string asm, string dst_kind,
7464                                       string lhs_kind, string rhs_kind,
7465                                       RegisterOperand RegType,
7466                                       ValueType AccumType, ValueType InputType,
7467                                       SDPatternOperator OpNode> :
7468         BaseSIMDIndexedTied<Q, U, 0b0, 0b10, 0b1110, RegType, RegType, V128,
7469                             VectorIndexS, asm, "", dst_kind, lhs_kind, rhs_kind,
7470         [(set (AccumType RegType:$dst),
7471               (AccumType (OpNode (AccumType RegType:$Rd),
7472                                  (InputType RegType:$Rn),
7473                                  (InputType (bitconvert (AccumType
7474                                     (AArch64duplane32 (v4i32 V128:$Rm),
7475                                         VectorIndexS:$idx)))))))]> {
7476   bits<2> idx;
7477   let Inst{21}    = idx{0};  // L
7478   let Inst{11}    = idx{1};  // H
7479 }
7480
7481 multiclass SIMDThreeSameVectorDotIndex<bit U, string asm,
7482                                        SDPatternOperator OpNode> {
7483   def v8i8  : BaseSIMDThreeSameVectorDotIndex<0, U, asm, ".2s", ".8b", ".4b",
7484                                               V64, v2i32, v8i8, OpNode>;
7485   def v16i8 : BaseSIMDThreeSameVectorDotIndex<1, U, asm, ".4s", ".16b", ".4b",
7486                                               V128, v4i32, v16i8, OpNode>;
7487 }
7488
7489 // ARMv8.2-A Fused Multiply Add-Long Instructions (Indexed)
7490 class BaseSIMDThreeSameVectorFMLIndex<bit Q, bit U, bits<4> opc, string asm,
7491                                       string dst_kind, string lhs_kind,
7492                                       string rhs_kind, RegisterOperand RegType,
7493                                       ValueType AccumType, ValueType InputType,
7494                                       SDPatternOperator OpNode> :
7495         BaseSIMDIndexedTied<Q, U, 0, 0b10, opc, RegType, RegType, V128,
7496                             VectorIndexH, asm, "", dst_kind, lhs_kind, rhs_kind,
7497           [(set (AccumType RegType:$dst),
7498                 (AccumType (OpNode (AccumType RegType:$Rd),
7499                                    (InputType RegType:$Rn),
7500                                    (InputType (AArch64duplane16 (v8f16 V128:$Rm),
7501                                                 VectorIndexH:$idx)))))]> {
7502   // idx = H:L:M
7503   bits<3> idx;
7504   let Inst{11} = idx{2}; // H
7505   let Inst{21} = idx{1}; // L
7506   let Inst{20} = idx{0}; // M
7507 }
7508
7509 multiclass SIMDThreeSameVectorFMLIndex<bit U, bits<4> opc, string asm,
7510                                        SDPatternOperator OpNode> {
7511   def v4f16 : BaseSIMDThreeSameVectorFMLIndex<0, U, opc, asm, ".2s", ".2h", ".h",
7512                                               V64, v2f32, v4f16, OpNode>;
7513   def v8f16 : BaseSIMDThreeSameVectorFMLIndex<1, U, opc, asm, ".4s", ".4h", ".h",
7514                                               V128, v4f32, v8f16, OpNode>;
7515 }
7516
7517 multiclass SIMDFPIndexed<bit U, bits<4> opc, string asm,
7518                          SDPatternOperator OpNode> {
7519   let Predicates = [HasNEON, HasFullFP16] in {
7520   def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b00, opc,
7521                                       V64, V64,
7522                                       V128_lo, VectorIndexH,
7523                                       asm, ".4h", ".4h", ".4h", ".h",
7524     [(set (v4f16 V64:$Rd),
7525         (OpNode (v4f16 V64:$Rn),
7526          (v4f16 (AArch64duplane16 (v8f16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7527     bits<3> idx;
7528     let Inst{11} = idx{2};
7529     let Inst{21} = idx{1};
7530     let Inst{20} = idx{0};
7531   }
7532
7533   def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b00, opc,
7534                                       V128, V128,
7535                                       V128_lo, VectorIndexH,
7536                                       asm, ".8h", ".8h", ".8h", ".h",
7537     [(set (v8f16 V128:$Rd),
7538         (OpNode (v8f16 V128:$Rn),
7539          (v8f16 (AArch64duplane16 (v8f16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7540     bits<3> idx;
7541     let Inst{11} = idx{2};
7542     let Inst{21} = idx{1};
7543     let Inst{20} = idx{0};
7544   }
7545   } // Predicates = [HasNEON, HasFullFP16]
7546
7547   def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
7548                                       V64, V64,
7549                                       V128, VectorIndexS,
7550                                       asm, ".2s", ".2s", ".2s", ".s",
7551     [(set (v2f32 V64:$Rd),
7552         (OpNode (v2f32 V64:$Rn),
7553          (v2f32 (AArch64duplane32 (v4f32 V128:$Rm), VectorIndexS:$idx))))]> {
7554     bits<2> idx;
7555     let Inst{11} = idx{1};
7556     let Inst{21} = idx{0};
7557   }
7558
7559   def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
7560                                       V128, V128,
7561                                       V128, VectorIndexS,
7562                                       asm, ".4s", ".4s", ".4s", ".s",
7563     [(set (v4f32 V128:$Rd),
7564         (OpNode (v4f32 V128:$Rn),
7565          (v4f32 (AArch64duplane32 (v4f32 V128:$Rm), VectorIndexS:$idx))))]> {
7566     bits<2> idx;
7567     let Inst{11} = idx{1};
7568     let Inst{21} = idx{0};
7569   }
7570
7571   def v2i64_indexed : BaseSIMDIndexed<1, U, 0, 0b11, opc,
7572                                       V128, V128,
7573                                       V128, VectorIndexD,
7574                                       asm, ".2d", ".2d", ".2d", ".d",
7575     [(set (v2f64 V128:$Rd),
7576         (OpNode (v2f64 V128:$Rn),
7577          (v2f64 (AArch64duplane64 (v2f64 V128:$Rm), VectorIndexD:$idx))))]> {
7578     bits<1> idx;
7579     let Inst{11} = idx{0};
7580     let Inst{21} = 0;
7581   }
7582
7583   let Predicates = [HasNEON, HasFullFP16] in {
7584   def v1i16_indexed : BaseSIMDIndexed<1, U, 1, 0b00, opc,
7585                                       FPR16Op, FPR16Op, V128_lo, VectorIndexH,
7586                                       asm, ".h", "", "", ".h",
7587     [(set (f16 FPR16Op:$Rd),
7588           (OpNode (f16 FPR16Op:$Rn),
7589                   (f16 (vector_extract (v8f16 V128_lo:$Rm),
7590                                        VectorIndexH:$idx))))]> {
7591     bits<3> idx;
7592     let Inst{11} = idx{2};
7593     let Inst{21} = idx{1};
7594     let Inst{20} = idx{0};
7595   }
7596   } // Predicates = [HasNEON, HasFullFP16]
7597
7598   def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
7599                                       FPR32Op, FPR32Op, V128, VectorIndexS,
7600                                       asm, ".s", "", "", ".s",
7601     [(set (f32 FPR32Op:$Rd),
7602           (OpNode (f32 FPR32Op:$Rn),
7603                   (f32 (vector_extract (v4f32 V128:$Rm),
7604                                        VectorIndexS:$idx))))]> {
7605     bits<2> idx;
7606     let Inst{11} = idx{1};
7607     let Inst{21} = idx{0};
7608   }
7609
7610   def v1i64_indexed : BaseSIMDIndexed<1, U, 1, 0b11, opc,
7611                                       FPR64Op, FPR64Op, V128, VectorIndexD,
7612                                       asm, ".d", "", "", ".d",
7613     [(set (f64 FPR64Op:$Rd),
7614           (OpNode (f64 FPR64Op:$Rn),
7615                   (f64 (vector_extract (v2f64 V128:$Rm),
7616                                        VectorIndexD:$idx))))]> {
7617     bits<1> idx;
7618     let Inst{11} = idx{0};
7619     let Inst{21} = 0;
7620   }
7621 }
7622
7623 multiclass SIMDFPIndexedTiedPatterns<string INST, SDPatternOperator OpNode> {
7624   // 2 variants for the .2s version: DUPLANE from 128-bit and DUP scalar.
7625   def : Pat<(v2f32 (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn),
7626                            (AArch64duplane32 (v4f32 V128:$Rm),
7627                                            VectorIndexS:$idx))),
7628             (!cast<Instruction>(INST # v2i32_indexed)
7629                 V64:$Rd, V64:$Rn, V128:$Rm, VectorIndexS:$idx)>;
7630   def : Pat<(v2f32 (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn),
7631                            (AArch64dup (f32 FPR32Op:$Rm)))),
7632             (!cast<Instruction>(INST # "v2i32_indexed") V64:$Rd, V64:$Rn,
7633                 (SUBREG_TO_REG (i32 0), FPR32Op:$Rm, ssub), (i64 0))>;
7634
7635
7636   // 2 variants for the .4s version: DUPLANE from 128-bit and DUP scalar.
7637   def : Pat<(v4f32 (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn),
7638                            (AArch64duplane32 (v4f32 V128:$Rm),
7639                                            VectorIndexS:$idx))),
7640             (!cast<Instruction>(INST # "v4i32_indexed")
7641                 V128:$Rd, V128:$Rn, V128:$Rm, VectorIndexS:$idx)>;
7642   def : Pat<(v4f32 (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn),
7643                            (AArch64dup (f32 FPR32Op:$Rm)))),
7644             (!cast<Instruction>(INST # "v4i32_indexed") V128:$Rd, V128:$Rn,
7645                 (SUBREG_TO_REG (i32 0), FPR32Op:$Rm, ssub), (i64 0))>;
7646
7647   // 2 variants for the .2d version: DUPLANE from 128-bit and DUP scalar.
7648   def : Pat<(v2f64 (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn),
7649                            (AArch64duplane64 (v2f64 V128:$Rm),
7650                                            VectorIndexD:$idx))),
7651             (!cast<Instruction>(INST # "v2i64_indexed")
7652                 V128:$Rd, V128:$Rn, V128:$Rm, VectorIndexS:$idx)>;
7653   def : Pat<(v2f64 (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn),
7654                            (AArch64dup (f64 FPR64Op:$Rm)))),
7655             (!cast<Instruction>(INST # "v2i64_indexed") V128:$Rd, V128:$Rn,
7656                 (SUBREG_TO_REG (i32 0), FPR64Op:$Rm, dsub), (i64 0))>;
7657
7658   // 2 variants for 32-bit scalar version: extract from .2s or from .4s
7659   def : Pat<(f32 (OpNode (f32 FPR32:$Rd), (f32 FPR32:$Rn),
7660                          (vector_extract (v4f32 V128:$Rm), VectorIndexS:$idx))),
7661             (!cast<Instruction>(INST # "v1i32_indexed") FPR32:$Rd, FPR32:$Rn,
7662                 V128:$Rm, VectorIndexS:$idx)>;
7663   def : Pat<(f32 (OpNode (f32 FPR32:$Rd), (f32 FPR32:$Rn),
7664                          (vector_extract (v2f32 V64:$Rm), VectorIndexS:$idx))),
7665             (!cast<Instruction>(INST # "v1i32_indexed") FPR32:$Rd, FPR32:$Rn,
7666                 (SUBREG_TO_REG (i32 0), V64:$Rm, dsub), VectorIndexS:$idx)>;
7667
7668   // 1 variant for 64-bit scalar version: extract from .1d or from .2d
7669   def : Pat<(f64 (OpNode (f64 FPR64:$Rd), (f64 FPR64:$Rn),
7670                          (vector_extract (v2f64 V128:$Rm), VectorIndexD:$idx))),
7671             (!cast<Instruction>(INST # "v1i64_indexed") FPR64:$Rd, FPR64:$Rn,
7672                 V128:$Rm, VectorIndexD:$idx)>;
7673 }
7674
7675 multiclass SIMDFPIndexedTied<bit U, bits<4> opc, string asm> {
7676   let Predicates = [HasNEON, HasFullFP16] in {
7677   def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b00, opc, V64, V64,
7678                                           V128_lo, VectorIndexH,
7679                                           asm, ".4h", ".4h", ".4h", ".h", []> {
7680     bits<3> idx;
7681     let Inst{11} = idx{2};
7682     let Inst{21} = idx{1};
7683     let Inst{20} = idx{0};
7684   }
7685
7686   def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b00, opc,
7687                                           V128, V128,
7688                                           V128_lo, VectorIndexH,
7689                                           asm, ".8h", ".8h", ".8h", ".h", []> {
7690     bits<3> idx;
7691     let Inst{11} = idx{2};
7692     let Inst{21} = idx{1};
7693     let Inst{20} = idx{0};
7694   }
7695   } // Predicates = [HasNEON, HasFullFP16]
7696
7697   def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc, V64, V64,
7698                                           V128, VectorIndexS,
7699                                           asm, ".2s", ".2s", ".2s", ".s", []> {
7700     bits<2> idx;
7701     let Inst{11} = idx{1};
7702     let Inst{21} = idx{0};
7703   }
7704
7705   def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
7706                                       V128, V128,
7707                                       V128, VectorIndexS,
7708                                       asm, ".4s", ".4s", ".4s", ".s", []> {
7709     bits<2> idx;
7710     let Inst{11} = idx{1};
7711     let Inst{21} = idx{0};
7712   }
7713
7714   def v2i64_indexed : BaseSIMDIndexedTied<1, U, 0, 0b11, opc,
7715                                       V128, V128,
7716                                       V128, VectorIndexD,
7717                                       asm, ".2d", ".2d", ".2d", ".d", []> {
7718     bits<1> idx;
7719     let Inst{11} = idx{0};
7720     let Inst{21} = 0;
7721   }
7722
7723   let Predicates = [HasNEON, HasFullFP16] in {
7724   def v1i16_indexed : BaseSIMDIndexedTied<1, U, 1, 0b00, opc,
7725                                       FPR16Op, FPR16Op, V128_lo, VectorIndexH,
7726                                       asm, ".h", "", "", ".h", []> {
7727     bits<3> idx;
7728     let Inst{11} = idx{2};
7729     let Inst{21} = idx{1};
7730     let Inst{20} = idx{0};
7731   }
7732   } // Predicates = [HasNEON, HasFullFP16]
7733
7734   def v1i32_indexed : BaseSIMDIndexedTied<1, U, 1, 0b10, opc,
7735                                       FPR32Op, FPR32Op, V128, VectorIndexS,
7736                                       asm, ".s", "", "", ".s", []> {
7737     bits<2> idx;
7738     let Inst{11} = idx{1};
7739     let Inst{21} = idx{0};
7740   }
7741
7742   def v1i64_indexed : BaseSIMDIndexedTied<1, U, 1, 0b11, opc,
7743                                       FPR64Op, FPR64Op, V128, VectorIndexD,
7744                                       asm, ".d", "", "", ".d", []> {
7745     bits<1> idx;
7746     let Inst{11} = idx{0};
7747     let Inst{21} = 0;
7748   }
7749 }
7750
7751 multiclass SIMDIndexedHS<bit U, bits<4> opc, string asm,
7752                          SDPatternOperator OpNode> {
7753   def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc, V64, V64,
7754                                       V128_lo, VectorIndexH,
7755                                       asm, ".4h", ".4h", ".4h", ".h",
7756     [(set (v4i16 V64:$Rd),
7757         (OpNode (v4i16 V64:$Rn),
7758          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7759     bits<3> idx;
7760     let Inst{11} = idx{2};
7761     let Inst{21} = idx{1};
7762     let Inst{20} = idx{0};
7763   }
7764
7765   def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
7766                                       V128, V128,
7767                                       V128_lo, VectorIndexH,
7768                                       asm, ".8h", ".8h", ".8h", ".h",
7769     [(set (v8i16 V128:$Rd),
7770        (OpNode (v8i16 V128:$Rn),
7771          (v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7772     bits<3> idx;
7773     let Inst{11} = idx{2};
7774     let Inst{21} = idx{1};
7775     let Inst{20} = idx{0};
7776   }
7777
7778   def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
7779                                       V64, V64,
7780                                       V128, VectorIndexS,
7781                                       asm, ".2s", ".2s", ".2s",  ".s",
7782     [(set (v2i32 V64:$Rd),
7783        (OpNode (v2i32 V64:$Rn),
7784           (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7785     bits<2> idx;
7786     let Inst{11} = idx{1};
7787     let Inst{21} = idx{0};
7788   }
7789
7790   def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
7791                                       V128, V128,
7792                                       V128, VectorIndexS,
7793                                       asm, ".4s", ".4s", ".4s", ".s",
7794     [(set (v4i32 V128:$Rd),
7795        (OpNode (v4i32 V128:$Rn),
7796           (v4i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7797     bits<2> idx;
7798     let Inst{11} = idx{1};
7799     let Inst{21} = idx{0};
7800   }
7801
7802   def v1i16_indexed : BaseSIMDIndexed<1, U, 1, 0b01, opc,
7803                                       FPR16Op, FPR16Op, V128_lo, VectorIndexH,
7804                                       asm, ".h", "", "", ".h", []> {
7805     bits<3> idx;
7806     let Inst{11} = idx{2};
7807     let Inst{21} = idx{1};
7808     let Inst{20} = idx{0};
7809   }
7810
7811   def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
7812                                       FPR32Op, FPR32Op, V128, VectorIndexS,
7813                                       asm, ".s", "", "", ".s",
7814       [(set (i32 FPR32Op:$Rd),
7815             (OpNode FPR32Op:$Rn,
7816                     (i32 (vector_extract (v4i32 V128:$Rm),
7817                                          VectorIndexS:$idx))))]> {
7818     bits<2> idx;
7819     let Inst{11} = idx{1};
7820     let Inst{21} = idx{0};
7821   }
7822 }
7823
7824 multiclass SIMDVectorIndexedHS<bit U, bits<4> opc, string asm,
7825                                SDPatternOperator OpNode> {
7826   def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
7827                                       V64, V64,
7828                                       V128_lo, VectorIndexH,
7829                                       asm, ".4h", ".4h", ".4h", ".h",
7830     [(set (v4i16 V64:$Rd),
7831         (OpNode (v4i16 V64:$Rn),
7832          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7833     bits<3> idx;
7834     let Inst{11} = idx{2};
7835     let Inst{21} = idx{1};
7836     let Inst{20} = idx{0};
7837   }
7838
7839   def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
7840                                       V128, V128,
7841                                       V128_lo, VectorIndexH,
7842                                       asm, ".8h", ".8h", ".8h", ".h",
7843     [(set (v8i16 V128:$Rd),
7844        (OpNode (v8i16 V128:$Rn),
7845          (v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7846     bits<3> idx;
7847     let Inst{11} = idx{2};
7848     let Inst{21} = idx{1};
7849     let Inst{20} = idx{0};
7850   }
7851
7852   def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
7853                                       V64, V64,
7854                                       V128, VectorIndexS,
7855                                       asm, ".2s", ".2s", ".2s", ".s",
7856     [(set (v2i32 V64:$Rd),
7857        (OpNode (v2i32 V64:$Rn),
7858           (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7859     bits<2> idx;
7860     let Inst{11} = idx{1};
7861     let Inst{21} = idx{0};
7862   }
7863
7864   def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
7865                                       V128, V128,
7866                                       V128, VectorIndexS,
7867                                       asm, ".4s", ".4s", ".4s", ".s",
7868     [(set (v4i32 V128:$Rd),
7869        (OpNode (v4i32 V128:$Rn),
7870           (v4i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7871     bits<2> idx;
7872     let Inst{11} = idx{1};
7873     let Inst{21} = idx{0};
7874   }
7875 }
7876
7877 multiclass SIMDVectorIndexedHSTied<bit U, bits<4> opc, string asm,
7878                                    SDPatternOperator OpNode> {
7879   def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc, V64, V64,
7880                                           V128_lo, VectorIndexH,
7881                                           asm, ".4h", ".4h", ".4h", ".h",
7882     [(set (v4i16 V64:$dst),
7883         (OpNode (v4i16 V64:$Rd),(v4i16 V64:$Rn),
7884          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7885     bits<3> idx;
7886     let Inst{11} = idx{2};
7887     let Inst{21} = idx{1};
7888     let Inst{20} = idx{0};
7889   }
7890
7891   def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
7892                                       V128, V128,
7893                                       V128_lo, VectorIndexH,
7894                                       asm, ".8h", ".8h", ".8h", ".h",
7895     [(set (v8i16 V128:$dst),
7896        (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
7897          (v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7898     bits<3> idx;
7899     let Inst{11} = idx{2};
7900     let Inst{21} = idx{1};
7901     let Inst{20} = idx{0};
7902   }
7903
7904   def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
7905                                       V64, V64,
7906                                       V128, VectorIndexS,
7907                                       asm, ".2s", ".2s", ".2s", ".s",
7908     [(set (v2i32 V64:$dst),
7909        (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
7910           (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7911     bits<2> idx;
7912     let Inst{11} = idx{1};
7913     let Inst{21} = idx{0};
7914   }
7915
7916   def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
7917                                       V128, V128,
7918                                       V128, VectorIndexS,
7919                                       asm, ".4s", ".4s", ".4s", ".s",
7920     [(set (v4i32 V128:$dst),
7921        (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
7922           (v4i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7923     bits<2> idx;
7924     let Inst{11} = idx{1};
7925     let Inst{21} = idx{0};
7926   }
7927 }
7928
7929 multiclass SIMDIndexedLongSD<bit U, bits<4> opc, string asm,
7930                              SDPatternOperator OpNode> {
7931   def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
7932                                       V128, V64,
7933                                       V128_lo, VectorIndexH,
7934                                       asm, ".4s", ".4s", ".4h", ".h",
7935     [(set (v4i32 V128:$Rd),
7936         (OpNode (v4i16 V64:$Rn),
7937          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
7938     bits<3> idx;
7939     let Inst{11} = idx{2};
7940     let Inst{21} = idx{1};
7941     let Inst{20} = idx{0};
7942   }
7943
7944   def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
7945                                       V128, V128,
7946                                       V128_lo, VectorIndexH,
7947                                       asm#"2", ".4s", ".4s", ".8h", ".h",
7948     [(set (v4i32 V128:$Rd),
7949           (OpNode (extract_high_v8i16 V128:$Rn),
7950                   (extract_high_v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
7951                                                       VectorIndexH:$idx))))]> {
7952
7953     bits<3> idx;
7954     let Inst{11} = idx{2};
7955     let Inst{21} = idx{1};
7956     let Inst{20} = idx{0};
7957   }
7958
7959   def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
7960                                       V128, V64,
7961                                       V128, VectorIndexS,
7962                                       asm, ".2d", ".2d", ".2s", ".s",
7963     [(set (v2i64 V128:$Rd),
7964         (OpNode (v2i32 V64:$Rn),
7965          (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
7966     bits<2> idx;
7967     let Inst{11} = idx{1};
7968     let Inst{21} = idx{0};
7969   }
7970
7971   def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
7972                                       V128, V128,
7973                                       V128, VectorIndexS,
7974                                       asm#"2", ".2d", ".2d", ".4s", ".s",
7975     [(set (v2i64 V128:$Rd),
7976           (OpNode (extract_high_v4i32 V128:$Rn),
7977                   (extract_high_v4i32 (AArch64duplane32 (v4i32 V128:$Rm),
7978                                                       VectorIndexS:$idx))))]> {
7979     bits<2> idx;
7980     let Inst{11} = idx{1};
7981     let Inst{21} = idx{0};
7982   }
7983
7984   def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b01, opc,
7985                                       FPR32Op, FPR16Op, V128_lo, VectorIndexH,
7986                                       asm, ".h", "", "", ".h", []> {
7987     bits<3> idx;
7988     let Inst{11} = idx{2};
7989     let Inst{21} = idx{1};
7990     let Inst{20} = idx{0};
7991   }
7992
7993   def v1i64_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
7994                                       FPR64Op, FPR32Op, V128, VectorIndexS,
7995                                       asm, ".s", "", "", ".s", []> {
7996     bits<2> idx;
7997     let Inst{11} = idx{1};
7998     let Inst{21} = idx{0};
7999   }
8000 }
8001
8002 multiclass SIMDIndexedLongSQDMLXSDTied<bit U, bits<4> opc, string asm,
8003                                        SDPatternOperator Accum> {
8004   def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc,
8005                                       V128, V64,
8006                                       V128_lo, VectorIndexH,
8007                                       asm, ".4s", ".4s", ".4h", ".h",
8008     [(set (v4i32 V128:$dst),
8009           (Accum (v4i32 V128:$Rd),
8010                  (v4i32 (int_aarch64_neon_sqdmull
8011                              (v4i16 V64:$Rn),
8012                              (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
8013                                                     VectorIndexH:$idx))))))]> {
8014     bits<3> idx;
8015     let Inst{11} = idx{2};
8016     let Inst{21} = idx{1};
8017     let Inst{20} = idx{0};
8018   }
8019
8020   // FIXME: it would be nice to use the scalar (v1i32) instruction here, but an
8021   // intermediate EXTRACT_SUBREG would be untyped.
8022   def : Pat<(i32 (Accum (i32 FPR32Op:$Rd),
8023                 (i32 (vector_extract (v4i32
8024                          (int_aarch64_neon_sqdmull (v4i16 V64:$Rn),
8025                              (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
8026                                                     VectorIndexH:$idx)))),
8027                          (i64 0))))),
8028             (EXTRACT_SUBREG
8029                 (!cast<Instruction>(NAME # v4i16_indexed)
8030                     (SUBREG_TO_REG (i32 0), FPR32Op:$Rd, ssub), V64:$Rn,
8031                     V128_lo:$Rm, VectorIndexH:$idx),
8032                 ssub)>;
8033
8034   def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
8035                                       V128, V128,
8036                                       V128_lo, VectorIndexH,
8037                                       asm#"2", ".4s", ".4s", ".8h", ".h",
8038     [(set (v4i32 V128:$dst),
8039           (Accum (v4i32 V128:$Rd),
8040                  (v4i32 (int_aarch64_neon_sqdmull
8041                             (extract_high_v8i16 V128:$Rn),
8042                             (extract_high_v8i16
8043                                 (AArch64duplane16 (v8i16 V128_lo:$Rm),
8044                                                 VectorIndexH:$idx))))))]> {
8045     bits<3> idx;
8046     let Inst{11} = idx{2};
8047     let Inst{21} = idx{1};
8048     let Inst{20} = idx{0};
8049   }
8050
8051   def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
8052                                       V128, V64,
8053                                       V128, VectorIndexS,
8054                                       asm, ".2d", ".2d", ".2s", ".s",
8055     [(set (v2i64 V128:$dst),
8056         (Accum (v2i64 V128:$Rd),
8057                (v2i64 (int_aarch64_neon_sqdmull
8058                           (v2i32 V64:$Rn),
8059                           (v2i32 (AArch64duplane32 (v4i32 V128:$Rm),
8060                                                  VectorIndexS:$idx))))))]> {
8061     bits<2> idx;
8062     let Inst{11} = idx{1};
8063     let Inst{21} = idx{0};
8064   }
8065
8066   def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
8067                                       V128, V128,
8068                                       V128, VectorIndexS,
8069                                       asm#"2", ".2d", ".2d", ".4s", ".s",
8070     [(set (v2i64 V128:$dst),
8071           (Accum (v2i64 V128:$Rd),
8072                  (v2i64 (int_aarch64_neon_sqdmull
8073                             (extract_high_v4i32 V128:$Rn),
8074                             (extract_high_v4i32
8075                                 (AArch64duplane32 (v4i32 V128:$Rm),
8076                                                 VectorIndexS:$idx))))))]> {
8077     bits<2> idx;
8078     let Inst{11} = idx{1};
8079     let Inst{21} = idx{0};
8080   }
8081
8082   def v1i32_indexed : BaseSIMDIndexedTied<1, U, 1, 0b01, opc,
8083                                       FPR32Op, FPR16Op, V128_lo, VectorIndexH,
8084                                       asm, ".h", "", "", ".h", []> {
8085     bits<3> idx;
8086     let Inst{11} = idx{2};
8087     let Inst{21} = idx{1};
8088     let Inst{20} = idx{0};
8089   }
8090
8091
8092   def v1i64_indexed : BaseSIMDIndexedTied<1, U, 1, 0b10, opc,
8093                                       FPR64Op, FPR32Op, V128, VectorIndexS,
8094                                       asm, ".s", "", "", ".s",
8095     [(set (i64 FPR64Op:$dst),
8096           (Accum (i64 FPR64Op:$Rd),
8097                  (i64 (int_aarch64_neon_sqdmulls_scalar
8098                             (i32 FPR32Op:$Rn),
8099                             (i32 (vector_extract (v4i32 V128:$Rm),
8100                                                  VectorIndexS:$idx))))))]> {
8101
8102     bits<2> idx;
8103     let Inst{11} = idx{1};
8104     let Inst{21} = idx{0};
8105   }
8106 }
8107
8108 multiclass SIMDVectorIndexedLongSD<bit U, bits<4> opc, string asm,
8109                                    SDPatternOperator OpNode> {
8110   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
8111   def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
8112                                       V128, V64,
8113                                       V128_lo, VectorIndexH,
8114                                       asm, ".4s", ".4s", ".4h", ".h",
8115     [(set (v4i32 V128:$Rd),
8116         (OpNode (v4i16 V64:$Rn),
8117          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
8118     bits<3> idx;
8119     let Inst{11} = idx{2};
8120     let Inst{21} = idx{1};
8121     let Inst{20} = idx{0};
8122   }
8123
8124   def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
8125                                       V128, V128,
8126                                       V128_lo, VectorIndexH,
8127                                       asm#"2", ".4s", ".4s", ".8h", ".h",
8128     [(set (v4i32 V128:$Rd),
8129           (OpNode (extract_high_v8i16 V128:$Rn),
8130                   (extract_high_v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
8131                                                       VectorIndexH:$idx))))]> {
8132
8133     bits<3> idx;
8134     let Inst{11} = idx{2};
8135     let Inst{21} = idx{1};
8136     let Inst{20} = idx{0};
8137   }
8138
8139   def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
8140                                       V128, V64,
8141                                       V128, VectorIndexS,
8142                                       asm, ".2d", ".2d", ".2s", ".s",
8143     [(set (v2i64 V128:$Rd),
8144         (OpNode (v2i32 V64:$Rn),
8145          (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
8146     bits<2> idx;
8147     let Inst{11} = idx{1};
8148     let Inst{21} = idx{0};
8149   }
8150
8151   def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
8152                                       V128, V128,
8153                                       V128, VectorIndexS,
8154                                       asm#"2", ".2d", ".2d", ".4s", ".s",
8155     [(set (v2i64 V128:$Rd),
8156           (OpNode (extract_high_v4i32 V128:$Rn),
8157                   (extract_high_v4i32 (AArch64duplane32 (v4i32 V128:$Rm),
8158                                                       VectorIndexS:$idx))))]> {
8159     bits<2> idx;
8160     let Inst{11} = idx{1};
8161     let Inst{21} = idx{0};
8162   }
8163   }
8164 }
8165
8166 multiclass SIMDVectorIndexedLongSDTied<bit U, bits<4> opc, string asm,
8167                                        SDPatternOperator OpNode> {
8168   let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
8169   def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc,
8170                                       V128, V64,
8171                                       V128_lo, VectorIndexH,
8172                                       asm, ".4s", ".4s", ".4h", ".h",
8173     [(set (v4i32 V128:$dst),
8174         (OpNode (v4i32 V128:$Rd), (v4i16 V64:$Rn),
8175          (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
8176     bits<3> idx;
8177     let Inst{11} = idx{2};
8178     let Inst{21} = idx{1};
8179     let Inst{20} = idx{0};
8180   }
8181
8182   def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
8183                                       V128, V128,
8184                                       V128_lo, VectorIndexH,
8185                                       asm#"2", ".4s", ".4s", ".8h", ".h",
8186     [(set (v4i32 V128:$dst),
8187           (OpNode (v4i32 V128:$Rd),
8188                   (extract_high_v8i16 V128:$Rn),
8189                   (extract_high_v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
8190                                                       VectorIndexH:$idx))))]> {
8191     bits<3> idx;
8192     let Inst{11} = idx{2};
8193     let Inst{21} = idx{1};
8194     let Inst{20} = idx{0};
8195   }
8196
8197   def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
8198                                       V128, V64,
8199                                       V128, VectorIndexS,
8200                                       asm, ".2d", ".2d", ".2s", ".s",
8201     [(set (v2i64 V128:$dst),
8202         (OpNode (v2i64 V128:$Rd), (v2i32 V64:$Rn),
8203          (v2i32 (AArch64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
8204     bits<2> idx;
8205     let Inst{11} = idx{1};
8206     let Inst{21} = idx{0};
8207   }
8208
8209   def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
8210                                       V128, V128,
8211                                       V128, VectorIndexS,
8212                                       asm#"2", ".2d", ".2d", ".4s", ".s",
8213     [(set (v2i64 V128:$dst),
8214           (OpNode (v2i64 V128:$Rd),
8215                   (extract_high_v4i32 V128:$Rn),
8216                   (extract_high_v4i32 (AArch64duplane32 (v4i32 V128:$Rm),
8217                                                       VectorIndexS:$idx))))]> {
8218     bits<2> idx;
8219     let Inst{11} = idx{1};
8220     let Inst{21} = idx{0};
8221   }
8222   }
8223 }
8224
8225 //----------------------------------------------------------------------------
8226 // AdvSIMD scalar shift by immediate
8227 //----------------------------------------------------------------------------
8228
8229 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8230 class BaseSIMDScalarShift<bit U, bits<5> opc, bits<7> fixed_imm,
8231                      RegisterClass regtype1, RegisterClass regtype2,
8232                      Operand immtype, string asm, list<dag> pattern>
8233   : I<(outs regtype1:$Rd), (ins regtype2:$Rn, immtype:$imm),
8234       asm, "\t$Rd, $Rn, $imm", "", pattern>,
8235     Sched<[WriteV]> {
8236   bits<5> Rd;
8237   bits<5> Rn;
8238   bits<7> imm;
8239   let Inst{31-30} = 0b01;
8240   let Inst{29}    = U;
8241   let Inst{28-23} = 0b111110;
8242   let Inst{22-16} = fixed_imm;
8243   let Inst{15-11} = opc;
8244   let Inst{10}    = 1;
8245   let Inst{9-5} = Rn;
8246   let Inst{4-0} = Rd;
8247 }
8248
8249 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8250 class BaseSIMDScalarShiftTied<bit U, bits<5> opc, bits<7> fixed_imm,
8251                      RegisterClass regtype1, RegisterClass regtype2,
8252                      Operand immtype, string asm, list<dag> pattern>
8253   : I<(outs regtype1:$dst), (ins regtype1:$Rd, regtype2:$Rn, immtype:$imm),
8254       asm, "\t$Rd, $Rn, $imm", "$Rd = $dst", pattern>,
8255     Sched<[WriteV]> {
8256   bits<5> Rd;
8257   bits<5> Rn;
8258   bits<7> imm;
8259   let Inst{31-30} = 0b01;
8260   let Inst{29}    = U;
8261   let Inst{28-23} = 0b111110;
8262   let Inst{22-16} = fixed_imm;
8263   let Inst{15-11} = opc;
8264   let Inst{10}    = 1;
8265   let Inst{9-5} = Rn;
8266   let Inst{4-0} = Rd;
8267 }
8268
8269
8270 multiclass SIMDFPScalarRShift<bit U, bits<5> opc, string asm> {
8271   let Predicates = [HasNEON, HasFullFP16] in {
8272   def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
8273                               FPR16, FPR16, vecshiftR16, asm, []> {
8274     let Inst{19-16} = imm{3-0};
8275   }
8276   } // Predicates = [HasNEON, HasFullFP16]
8277   def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
8278                               FPR32, FPR32, vecshiftR32, asm, []> {
8279     let Inst{20-16} = imm{4-0};
8280   }
8281   def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
8282                               FPR64, FPR64, vecshiftR64, asm, []> {
8283     let Inst{21-16} = imm{5-0};
8284   }
8285 }
8286
8287 multiclass SIMDScalarRShiftD<bit U, bits<5> opc, string asm,
8288                              SDPatternOperator OpNode> {
8289   def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
8290                               FPR64, FPR64, vecshiftR64, asm,
8291   [(set (i64 FPR64:$Rd),
8292      (OpNode (i64 FPR64:$Rn), (i32 vecshiftR64:$imm)))]> {
8293     let Inst{21-16} = imm{5-0};
8294   }
8295
8296   def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rn), (i32 vecshiftR64:$imm))),
8297             (!cast<Instruction>(NAME # "d") FPR64:$Rn, vecshiftR64:$imm)>;
8298 }
8299
8300 multiclass SIMDScalarRShiftDTied<bit U, bits<5> opc, string asm,
8301                                  SDPatternOperator OpNode = null_frag> {
8302   def d : BaseSIMDScalarShiftTied<U, opc, {1,?,?,?,?,?,?},
8303                               FPR64, FPR64, vecshiftR64, asm,
8304   [(set (i64 FPR64:$dst), (OpNode (i64 FPR64:$Rd), (i64 FPR64:$Rn),
8305                                                    (i32 vecshiftR64:$imm)))]> {
8306     let Inst{21-16} = imm{5-0};
8307   }
8308
8309   def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rd), (v1i64 FPR64:$Rn),
8310                            (i32 vecshiftR64:$imm))),
8311             (!cast<Instruction>(NAME # "d") FPR64:$Rd, FPR64:$Rn,
8312                                             vecshiftR64:$imm)>;
8313 }
8314
8315 multiclass SIMDScalarLShiftD<bit U, bits<5> opc, string asm,
8316                              SDPatternOperator OpNode> {
8317   def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
8318                               FPR64, FPR64, vecshiftL64, asm,
8319     [(set (v1i64 FPR64:$Rd),
8320        (OpNode (v1i64 FPR64:$Rn), (i32 vecshiftL64:$imm)))]> {
8321     let Inst{21-16} = imm{5-0};
8322   }
8323 }
8324
8325 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8326 multiclass SIMDScalarLShiftDTied<bit U, bits<5> opc, string asm> {
8327   def d : BaseSIMDScalarShiftTied<U, opc, {1,?,?,?,?,?,?},
8328                               FPR64, FPR64, vecshiftL64, asm, []> {
8329     let Inst{21-16} = imm{5-0};
8330   }
8331 }
8332
8333 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8334 multiclass SIMDScalarRShiftBHS<bit U, bits<5> opc, string asm,
8335                                SDPatternOperator OpNode = null_frag> {
8336   def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
8337                               FPR8, FPR16, vecshiftR8, asm, []> {
8338     let Inst{18-16} = imm{2-0};
8339   }
8340
8341   def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
8342                               FPR16, FPR32, vecshiftR16, asm, []> {
8343     let Inst{19-16} = imm{3-0};
8344   }
8345
8346   def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
8347                               FPR32, FPR64, vecshiftR32, asm,
8348     [(set (i32 FPR32:$Rd), (OpNode (i64 FPR64:$Rn), vecshiftR32:$imm))]> {
8349     let Inst{20-16} = imm{4-0};
8350   }
8351 }
8352
8353 multiclass SIMDScalarLShiftBHSD<bit U, bits<5> opc, string asm,
8354                                 SDPatternOperator OpNode> {
8355   def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
8356                               FPR8, FPR8, vecshiftL8, asm, []> {
8357     let Inst{18-16} = imm{2-0};
8358   }
8359
8360   def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
8361                               FPR16, FPR16, vecshiftL16, asm, []> {
8362     let Inst{19-16} = imm{3-0};
8363   }
8364
8365   def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
8366                               FPR32, FPR32, vecshiftL32, asm,
8367     [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn), (i32 vecshiftL32:$imm)))]> {
8368     let Inst{20-16} = imm{4-0};
8369   }
8370
8371   def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
8372                               FPR64, FPR64, vecshiftL64, asm,
8373     [(set (i64 FPR64:$Rd), (OpNode (i64 FPR64:$Rn), (i32 vecshiftL64:$imm)))]> {
8374     let Inst{21-16} = imm{5-0};
8375   }
8376
8377   def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rn), (i32 vecshiftL64:$imm))),
8378             (!cast<Instruction>(NAME # "d") FPR64:$Rn, vecshiftL64:$imm)>;
8379 }
8380
8381 multiclass SIMDScalarRShiftBHSD<bit U, bits<5> opc, string asm> {
8382   def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
8383                               FPR8, FPR8, vecshiftR8, asm, []> {
8384     let Inst{18-16} = imm{2-0};
8385   }
8386
8387   def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
8388                               FPR16, FPR16, vecshiftR16, asm, []> {
8389     let Inst{19-16} = imm{3-0};
8390   }
8391
8392   def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
8393                               FPR32, FPR32, vecshiftR32, asm, []> {
8394     let Inst{20-16} = imm{4-0};
8395   }
8396
8397   def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
8398                               FPR64, FPR64, vecshiftR64, asm, []> {
8399     let Inst{21-16} = imm{5-0};
8400   }
8401 }
8402
8403 //----------------------------------------------------------------------------
8404 // AdvSIMD vector x indexed element
8405 //----------------------------------------------------------------------------
8406
8407 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8408 class BaseSIMDVectorShift<bit Q, bit U, bits<5> opc, bits<7> fixed_imm,
8409                      RegisterOperand dst_reg, RegisterOperand src_reg,
8410                      Operand immtype,
8411                      string asm, string dst_kind, string src_kind,
8412                      list<dag> pattern>
8413   : I<(outs dst_reg:$Rd), (ins src_reg:$Rn, immtype:$imm),
8414       asm, "{\t$Rd" # dst_kind # ", $Rn" # src_kind # ", $imm" #
8415            "|" # dst_kind # "\t$Rd, $Rn, $imm}", "", pattern>,
8416     Sched<[WriteV]> {
8417   bits<5> Rd;
8418   bits<5> Rn;
8419   let Inst{31}    = 0;
8420   let Inst{30}    = Q;
8421   let Inst{29}    = U;
8422   let Inst{28-23} = 0b011110;
8423   let Inst{22-16} = fixed_imm;
8424   let Inst{15-11} = opc;
8425   let Inst{10}    = 1;
8426   let Inst{9-5}   = Rn;
8427   let Inst{4-0}   = Rd;
8428 }
8429
8430 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
8431 class BaseSIMDVectorShiftTied<bit Q, bit U, bits<5> opc, bits<7> fixed_imm,
8432                      RegisterOperand vectype1, RegisterOperand vectype2,
8433                      Operand immtype,
8434                      string asm, string dst_kind, string src_kind,
8435                      list<dag> pattern>
8436   : I<(outs vectype1:$dst), (ins vectype1:$Rd, vectype2:$Rn, immtype:$imm),
8437       asm, "{\t$Rd" # dst_kind # ", $Rn" # src_kind # ", $imm" #
8438            "|" # dst_kind # "\t$Rd, $Rn, $imm}", "$Rd = $dst", pattern>,
8439     Sched<[WriteV]> {
8440   bits<5> Rd;
8441   bits<5> Rn;
8442   let Inst{31}    = 0;
8443   let Inst{30}    = Q;
8444   let Inst{29}    = U;
8445   let Inst{28-23} = 0b011110;
8446   let Inst{22-16} = fixed_imm;
8447   let Inst{15-11} = opc;
8448   let Inst{10}    = 1;
8449   let Inst{9-5}   = Rn;
8450   let Inst{4-0}   = Rd;
8451 }
8452
8453 multiclass SIMDVectorRShiftSD<bit U, bits<5> opc, string asm,
8454                               Intrinsic OpNode> {
8455   let Predicates = [HasNEON, HasFullFP16] in {
8456   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8457                                   V64, V64, vecshiftR16,
8458                                   asm, ".4h", ".4h",
8459       [(set (v4i16 V64:$Rd), (OpNode (v4f16 V64:$Rn), (i32 imm:$imm)))]> {
8460     bits<4> imm;
8461     let Inst{19-16} = imm;
8462   }
8463
8464   def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
8465                                   V128, V128, vecshiftR16,
8466                                   asm, ".8h", ".8h",
8467       [(set (v8i16 V128:$Rd), (OpNode (v8f16 V128:$Rn), (i32 imm:$imm)))]> {
8468     bits<4> imm;
8469     let Inst{19-16} = imm;
8470   }
8471   } // Predicates = [HasNEON, HasFullFP16]
8472   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8473                                   V64, V64, vecshiftR32,
8474                                   asm, ".2s", ".2s",
8475       [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (i32 imm:$imm)))]> {
8476     bits<5> imm;
8477     let Inst{20-16} = imm;
8478   }
8479
8480   def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
8481                                   V128, V128, vecshiftR32,
8482                                   asm, ".4s", ".4s",
8483       [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (i32 imm:$imm)))]> {
8484     bits<5> imm;
8485     let Inst{20-16} = imm;
8486   }
8487
8488   def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
8489                                   V128, V128, vecshiftR64,
8490                                   asm, ".2d", ".2d",
8491       [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (i32 imm:$imm)))]> {
8492     bits<6> imm;
8493     let Inst{21-16} = imm;
8494   }
8495 }
8496
8497 multiclass SIMDVectorRShiftToFP<bit U, bits<5> opc, string asm,
8498                                   Intrinsic OpNode> {
8499   let Predicates = [HasNEON, HasFullFP16] in {
8500   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8501                                   V64, V64, vecshiftR16,
8502                                   asm, ".4h", ".4h",
8503       [(set (v4f16 V64:$Rd), (OpNode (v4i16 V64:$Rn), (i32 imm:$imm)))]> {
8504     bits<4> imm;
8505     let Inst{19-16} = imm;
8506   }
8507
8508   def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
8509                                   V128, V128, vecshiftR16,
8510                                   asm, ".8h", ".8h",
8511       [(set (v8f16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (i32 imm:$imm)))]> {
8512     bits<4> imm;
8513     let Inst{19-16} = imm;
8514   }
8515   } // Predicates = [HasNEON, HasFullFP16]
8516
8517   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8518                                   V64, V64, vecshiftR32,
8519                                   asm, ".2s", ".2s",
8520       [(set (v2f32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (i32 imm:$imm)))]> {
8521     bits<5> imm;
8522     let Inst{20-16} = imm;
8523   }
8524
8525   def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
8526                                   V128, V128, vecshiftR32,
8527                                   asm, ".4s", ".4s",
8528       [(set (v4f32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (i32 imm:$imm)))]> {
8529     bits<5> imm;
8530     let Inst{20-16} = imm;
8531   }
8532
8533   def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
8534                                   V128, V128, vecshiftR64,
8535                                   asm, ".2d", ".2d",
8536       [(set (v2f64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (i32 imm:$imm)))]> {
8537     bits<6> imm;
8538     let Inst{21-16} = imm;
8539   }
8540 }
8541
8542 multiclass SIMDVectorRShiftNarrowBHS<bit U, bits<5> opc, string asm,
8543                                      SDPatternOperator OpNode> {
8544   def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
8545                                   V64, V128, vecshiftR16Narrow,
8546                                   asm, ".8b", ".8h",
8547       [(set (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn), vecshiftR16Narrow:$imm))]> {
8548     bits<3> imm;
8549     let Inst{18-16} = imm;
8550   }
8551
8552   def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
8553                                   V128, V128, vecshiftR16Narrow,
8554                                   asm#"2", ".16b", ".8h", []> {
8555     bits<3> imm;
8556     let Inst{18-16} = imm;
8557     let hasSideEffects = 0;
8558   }
8559
8560   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8561                                   V64, V128, vecshiftR32Narrow,
8562                                   asm, ".4h", ".4s",
8563       [(set (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn), vecshiftR32Narrow:$imm))]> {
8564     bits<4> imm;
8565     let Inst{19-16} = imm;
8566   }
8567
8568   def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
8569                                   V128, V128, vecshiftR32Narrow,
8570                                   asm#"2", ".8h", ".4s", []> {
8571     bits<4> imm;
8572     let Inst{19-16} = imm;
8573     let hasSideEffects = 0;
8574   }
8575
8576   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8577                                   V64, V128, vecshiftR64Narrow,
8578                                   asm, ".2s", ".2d",
8579       [(set (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn), vecshiftR64Narrow:$imm))]> {
8580     bits<5> imm;
8581     let Inst{20-16} = imm;
8582   }
8583
8584   def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
8585                                   V128, V128, vecshiftR64Narrow,
8586                                   asm#"2", ".4s", ".2d", []> {
8587     bits<5> imm;
8588     let Inst{20-16} = imm;
8589     let hasSideEffects = 0;
8590   }
8591
8592   // TableGen doesn't like patters w/ INSERT_SUBREG on the instructions
8593   // themselves, so put them here instead.
8594
8595   // Patterns involving what's effectively an insert high and a normal
8596   // intrinsic, represented by CONCAT_VECTORS.
8597   def : Pat<(concat_vectors (v8i8 V64:$Rd),(OpNode (v8i16 V128:$Rn),
8598                                                    vecshiftR16Narrow:$imm)),
8599             (!cast<Instruction>(NAME # "v16i8_shift")
8600                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
8601                 V128:$Rn, vecshiftR16Narrow:$imm)>;
8602   def : Pat<(concat_vectors (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn),
8603                                                      vecshiftR32Narrow:$imm)),
8604             (!cast<Instruction>(NAME # "v8i16_shift")
8605                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
8606                 V128:$Rn, vecshiftR32Narrow:$imm)>;
8607   def : Pat<(concat_vectors (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn),
8608                                                      vecshiftR64Narrow:$imm)),
8609             (!cast<Instruction>(NAME # "v4i32_shift")
8610                 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
8611                 V128:$Rn, vecshiftR64Narrow:$imm)>;
8612 }
8613
8614 multiclass SIMDVectorLShiftBHSD<bit U, bits<5> opc, string asm,
8615                                 SDPatternOperator OpNode> {
8616   def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
8617                                   V64, V64, vecshiftL8,
8618                                   asm, ".8b", ".8b",
8619                  [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn),
8620                        (i32 vecshiftL8:$imm)))]> {
8621     bits<3> imm;
8622     let Inst{18-16} = imm;
8623   }
8624
8625   def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
8626                                   V128, V128, vecshiftL8,
8627                                   asm, ".16b", ".16b",
8628              [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn),
8629                    (i32 vecshiftL8:$imm)))]> {
8630     bits<3> imm;
8631     let Inst{18-16} = imm;
8632   }
8633
8634   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8635                                   V64, V64, vecshiftL16,
8636                                   asm, ".4h", ".4h",
8637               [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn),
8638                     (i32 vecshiftL16:$imm)))]> {
8639     bits<4> imm;
8640     let Inst{19-16} = imm;
8641   }
8642
8643   def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
8644                                   V128, V128, vecshiftL16,
8645                                   asm, ".8h", ".8h",
8646             [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
8647                   (i32 vecshiftL16:$imm)))]> {
8648     bits<4> imm;
8649     let Inst{19-16} = imm;
8650   }
8651
8652   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8653                                   V64, V64, vecshiftL32,
8654                                   asm, ".2s", ".2s",
8655               [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn),
8656                     (i32 vecshiftL32:$imm)))]> {
8657     bits<5> imm;
8658     let Inst{20-16} = imm;
8659   }
8660
8661   def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
8662                                   V128, V128, vecshiftL32,
8663                                   asm, ".4s", ".4s",
8664             [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
8665                   (i32 vecshiftL32:$imm)))]> {
8666     bits<5> imm;
8667     let Inst{20-16} = imm;
8668   }
8669
8670   def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
8671                                   V128, V128, vecshiftL64,
8672                                   asm, ".2d", ".2d",
8673             [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
8674                   (i32 vecshiftL64:$imm)))]> {
8675     bits<6> imm;
8676     let Inst{21-16} = imm;
8677   }
8678 }
8679
8680 multiclass SIMDVectorRShiftBHSD<bit U, bits<5> opc, string asm,
8681                                 SDPatternOperator OpNode> {
8682   def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
8683                                   V64, V64, vecshiftR8,
8684                                   asm, ".8b", ".8b",
8685                  [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn),
8686                        (i32 vecshiftR8:$imm)))]> {
8687     bits<3> imm;
8688     let Inst{18-16} = imm;
8689   }
8690
8691   def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
8692                                   V128, V128, vecshiftR8,
8693                                   asm, ".16b", ".16b",
8694              [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn),
8695                    (i32 vecshiftR8:$imm)))]> {
8696     bits<3> imm;
8697     let Inst{18-16} = imm;
8698   }
8699
8700   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8701                                   V64, V64, vecshiftR16,
8702                                   asm, ".4h", ".4h",
8703               [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn),
8704                     (i32 vecshiftR16:$imm)))]> {
8705     bits<4> imm;
8706     let Inst{19-16} = imm;
8707   }
8708
8709   def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
8710                                   V128, V128, vecshiftR16,
8711                                   asm, ".8h", ".8h",
8712             [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
8713                   (i32 vecshiftR16:$imm)))]> {
8714     bits<4> imm;
8715     let Inst{19-16} = imm;
8716   }
8717
8718   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8719                                   V64, V64, vecshiftR32,
8720                                   asm, ".2s", ".2s",
8721               [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn),
8722                     (i32 vecshiftR32:$imm)))]> {
8723     bits<5> imm;
8724     let Inst{20-16} = imm;
8725   }
8726
8727   def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
8728                                   V128, V128, vecshiftR32,
8729                                   asm, ".4s", ".4s",
8730             [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
8731                   (i32 vecshiftR32:$imm)))]> {
8732     bits<5> imm;
8733     let Inst{20-16} = imm;
8734   }
8735
8736   def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
8737                                   V128, V128, vecshiftR64,
8738                                   asm, ".2d", ".2d",
8739             [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
8740                   (i32 vecshiftR64:$imm)))]> {
8741     bits<6> imm;
8742     let Inst{21-16} = imm;
8743   }
8744 }
8745
8746 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
8747 multiclass SIMDVectorRShiftBHSDTied<bit U, bits<5> opc, string asm,
8748                                     SDPatternOperator OpNode = null_frag> {
8749   def v8i8_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,0,1,?,?,?},
8750                                   V64, V64, vecshiftR8, asm, ".8b", ".8b",
8751                  [(set (v8i8 V64:$dst),
8752                    (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn),
8753                            (i32 vecshiftR8:$imm)))]> {
8754     bits<3> imm;
8755     let Inst{18-16} = imm;
8756   }
8757
8758   def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
8759                                   V128, V128, vecshiftR8, asm, ".16b", ".16b",
8760              [(set (v16i8 V128:$dst),
8761                (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
8762                        (i32 vecshiftR8:$imm)))]> {
8763     bits<3> imm;
8764     let Inst{18-16} = imm;
8765   }
8766
8767   def v4i16_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,1,?,?,?,?},
8768                                   V64, V64, vecshiftR16, asm, ".4h", ".4h",
8769               [(set (v4i16 V64:$dst),
8770                 (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn),
8771                         (i32 vecshiftR16:$imm)))]> {
8772     bits<4> imm;
8773     let Inst{19-16} = imm;
8774   }
8775
8776   def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
8777                                   V128, V128, vecshiftR16, asm, ".8h", ".8h",
8778             [(set (v8i16 V128:$dst),
8779               (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
8780                       (i32 vecshiftR16:$imm)))]> {
8781     bits<4> imm;
8782     let Inst{19-16} = imm;
8783   }
8784
8785   def v2i32_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,1,?,?,?,?,?},
8786                                   V64, V64, vecshiftR32, asm, ".2s", ".2s",
8787               [(set (v2i32 V64:$dst),
8788                 (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
8789                         (i32 vecshiftR32:$imm)))]> {
8790     bits<5> imm;
8791     let Inst{20-16} = imm;
8792   }
8793
8794   def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
8795                                   V128, V128, vecshiftR32, asm, ".4s", ".4s",
8796             [(set (v4i32 V128:$dst),
8797               (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
8798                       (i32 vecshiftR32:$imm)))]> {
8799     bits<5> imm;
8800     let Inst{20-16} = imm;
8801   }
8802
8803   def v2i64_shift : BaseSIMDVectorShiftTied<1, U, opc, {1,?,?,?,?,?,?},
8804                                   V128, V128, vecshiftR64,
8805                                   asm, ".2d", ".2d", [(set (v2i64 V128:$dst),
8806               (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn),
8807                       (i32 vecshiftR64:$imm)))]> {
8808     bits<6> imm;
8809     let Inst{21-16} = imm;
8810   }
8811 }
8812
8813 multiclass SIMDVectorLShiftBHSDTied<bit U, bits<5> opc, string asm,
8814                                     SDPatternOperator OpNode = null_frag> {
8815   def v8i8_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,0,1,?,?,?},
8816                                   V64, V64, vecshiftL8,
8817                                   asm, ".8b", ".8b",
8818                     [(set (v8i8 V64:$dst),
8819                           (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn),
8820                                   (i32 vecshiftL8:$imm)))]> {
8821     bits<3> imm;
8822     let Inst{18-16} = imm;
8823   }
8824
8825   def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
8826                                   V128, V128, vecshiftL8,
8827                                   asm, ".16b", ".16b",
8828                     [(set (v16i8 V128:$dst),
8829                           (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
8830                                   (i32 vecshiftL8:$imm)))]> {
8831     bits<3> imm;
8832     let Inst{18-16} = imm;
8833   }
8834
8835   def v4i16_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,1,?,?,?,?},
8836                                   V64, V64, vecshiftL16,
8837                                   asm, ".4h", ".4h",
8838                     [(set (v4i16 V64:$dst),
8839                            (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn),
8840                                    (i32 vecshiftL16:$imm)))]> {
8841     bits<4> imm;
8842     let Inst{19-16} = imm;
8843   }
8844
8845   def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
8846                                   V128, V128, vecshiftL16,
8847                                   asm, ".8h", ".8h",
8848                     [(set (v8i16 V128:$dst),
8849                           (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
8850                                   (i32 vecshiftL16:$imm)))]> {
8851     bits<4> imm;
8852     let Inst{19-16} = imm;
8853   }
8854
8855   def v2i32_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,1,?,?,?,?,?},
8856                                   V64, V64, vecshiftL32,
8857                                   asm, ".2s", ".2s",
8858                     [(set (v2i32 V64:$dst),
8859                           (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
8860                                   (i32 vecshiftL32:$imm)))]> {
8861     bits<5> imm;
8862     let Inst{20-16} = imm;
8863   }
8864
8865   def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
8866                                   V128, V128, vecshiftL32,
8867                                   asm, ".4s", ".4s",
8868                     [(set (v4i32 V128:$dst),
8869                           (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
8870                                   (i32 vecshiftL32:$imm)))]> {
8871     bits<5> imm;
8872     let Inst{20-16} = imm;
8873   }
8874
8875   def v2i64_shift : BaseSIMDVectorShiftTied<1, U, opc, {1,?,?,?,?,?,?},
8876                                   V128, V128, vecshiftL64,
8877                                   asm, ".2d", ".2d",
8878                     [(set (v2i64 V128:$dst),
8879                           (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn),
8880                                   (i32 vecshiftL64:$imm)))]> {
8881     bits<6> imm;
8882     let Inst{21-16} = imm;
8883   }
8884 }
8885
8886 multiclass SIMDVectorLShiftLongBHSD<bit U, bits<5> opc, string asm,
8887                                    SDPatternOperator OpNode> {
8888   def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
8889                                   V128, V64, vecshiftL8, asm, ".8h", ".8b",
8890       [(set (v8i16 V128:$Rd), (OpNode (v8i8 V64:$Rn), vecshiftL8:$imm))]> {
8891     bits<3> imm;
8892     let Inst{18-16} = imm;
8893   }
8894
8895   def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
8896                                   V128, V128, vecshiftL8,
8897                                   asm#"2", ".8h", ".16b",
8898       [(set (v8i16 V128:$Rd),
8899             (OpNode (extract_high_v16i8 V128:$Rn), vecshiftL8:$imm))]> {
8900     bits<3> imm;
8901     let Inst{18-16} = imm;
8902   }
8903
8904   def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
8905                                   V128, V64, vecshiftL16, asm, ".4s", ".4h",
8906       [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), vecshiftL16:$imm))]> {
8907     bits<4> imm;
8908     let Inst{19-16} = imm;
8909   }
8910
8911   def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
8912                                   V128, V128, vecshiftL16,
8913                                   asm#"2", ".4s", ".8h",
8914       [(set (v4i32 V128:$Rd),
8915             (OpNode (extract_high_v8i16 V128:$Rn), vecshiftL16:$imm))]> {
8916
8917     bits<4> imm;
8918     let Inst{19-16} = imm;
8919   }
8920
8921   def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
8922                                   V128, V64, vecshiftL32, asm, ".2d", ".2s",
8923       [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), vecshiftL32:$imm))]> {
8924     bits<5> imm;
8925     let Inst{20-16} = imm;
8926   }
8927
8928   def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
8929                                   V128, V128, vecshiftL32,
8930                                   asm#"2", ".2d", ".4s",
8931       [(set (v2i64 V128:$Rd),
8932             (OpNode (extract_high_v4i32 V128:$Rn), vecshiftL32:$imm))]> {
8933     bits<5> imm;
8934     let Inst{20-16} = imm;
8935   }
8936 }
8937
8938
8939 //---
8940 // Vector load/store
8941 //---
8942 // SIMD ldX/stX no-index memory references don't allow the optional
8943 // ", #0" constant and handle post-indexing explicitly, so we use
8944 // a more specialized parse method for them. Otherwise, it's the same as
8945 // the general GPR64sp handling.
8946
8947 class BaseSIMDLdSt<bit Q, bit L, bits<4> opcode, bits<2> size,
8948                    string asm, dag oops, dag iops, list<dag> pattern>
8949   : I<oops, iops, asm, "\t$Vt, [$Rn]", "", pattern> {
8950   bits<5> Vt;
8951   bits<5> Rn;
8952   let Inst{31} = 0;
8953   let Inst{30} = Q;
8954   let Inst{29-23} = 0b0011000;
8955   let Inst{22} = L;
8956   let Inst{21-16} = 0b000000;
8957   let Inst{15-12} = opcode;
8958   let Inst{11-10} = size;
8959   let Inst{9-5} = Rn;
8960   let Inst{4-0} = Vt;
8961 }
8962
8963 class BaseSIMDLdStPost<bit Q, bit L, bits<4> opcode, bits<2> size,
8964                        string asm, dag oops, dag iops>
8965   : I<oops, iops, asm, "\t$Vt, [$Rn], $Xm", "$Rn = $wback", []> {
8966   bits<5> Vt;
8967   bits<5> Rn;
8968   bits<5> Xm;
8969   let Inst{31} = 0;
8970   let Inst{30} = Q;
8971   let Inst{29-23} = 0b0011001;
8972   let Inst{22} = L;
8973   let Inst{21} = 0;
8974   let Inst{20-16} = Xm;
8975   let Inst{15-12} = opcode;
8976   let Inst{11-10} = size;
8977   let Inst{9-5} = Rn;
8978   let Inst{4-0} = Vt;
8979 }
8980
8981 // The immediate form of AdvSIMD post-indexed addressing is encoded with
8982 // register post-index addressing from the zero register.
8983 multiclass SIMDLdStAliases<string BaseName, string asm, string layout, string Count,
8984                            int Offset, int Size> {
8985   // E.g. "ld1 { v0.8b, v1.8b }, [x1], #16"
8986   //      "ld1\t$Vt, [$Rn], #16"
8987   // may get mapped to
8988   //      (LD1Twov8b_POST VecListTwo8b:$Vt, GPR64sp:$Rn, XZR)
8989   def : InstAlias<asm # "\t$Vt, [$Rn], #" # Offset,
8990                   (!cast<Instruction>(BaseName # Count # "v" # layout # "_POST")
8991                       GPR64sp:$Rn,
8992                       !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
8993                       XZR), 1>;
8994
8995   // E.g. "ld1.8b { v0, v1 }, [x1], #16"
8996   //      "ld1.8b\t$Vt, [$Rn], #16"
8997   // may get mapped to
8998   //      (LD1Twov8b_POST VecListTwo64:$Vt, GPR64sp:$Rn, XZR)
8999   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn], #" # Offset,
9000                   (!cast<Instruction>(BaseName # Count # "v" # layout # "_POST")
9001                       GPR64sp:$Rn,
9002                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9003                       XZR), 0>;
9004
9005   // E.g. "ld1.8b { v0, v1 }, [x1]"
9006   //      "ld1\t$Vt, [$Rn]"
9007   // may get mapped to
9008   //      (LD1Twov8b VecListTwo64:$Vt, GPR64sp:$Rn)
9009   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn]",
9010                   (!cast<Instruction>(BaseName # Count # "v" # layout)
9011                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9012                       GPR64sp:$Rn), 0>;
9013
9014   // E.g. "ld1.8b { v0, v1 }, [x1], x2"
9015   //      "ld1\t$Vt, [$Rn], $Xm"
9016   // may get mapped to
9017   //      (LD1Twov8b_POST VecListTwo64:$Vt, GPR64sp:$Rn, GPR64pi8:$Xm)
9018   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn], $Xm",
9019                   (!cast<Instruction>(BaseName # Count # "v" # layout # "_POST")
9020                       GPR64sp:$Rn,
9021                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9022                       !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
9023 }
9024
9025 multiclass BaseSIMDLdN<string BaseName, string Count, string asm, string veclist,
9026                        int Offset128, int Offset64, bits<4> opcode> {
9027   let hasSideEffects = 0, mayLoad = 1, mayStore = 0 in {
9028     def v16b: BaseSIMDLdSt<1, 1, opcode, 0b00, asm,
9029                            (outs !cast<RegisterOperand>(veclist # "16b"):$Vt),
9030                            (ins GPR64sp:$Rn), []>;
9031     def v8h : BaseSIMDLdSt<1, 1, opcode, 0b01, asm,
9032                            (outs !cast<RegisterOperand>(veclist # "8h"):$Vt),
9033                            (ins GPR64sp:$Rn), []>;
9034     def v4s : BaseSIMDLdSt<1, 1, opcode, 0b10, asm,
9035                            (outs !cast<RegisterOperand>(veclist # "4s"):$Vt),
9036                            (ins GPR64sp:$Rn), []>;
9037     def v2d : BaseSIMDLdSt<1, 1, opcode, 0b11, asm,
9038                            (outs !cast<RegisterOperand>(veclist # "2d"):$Vt),
9039                            (ins GPR64sp:$Rn), []>;
9040     def v8b : BaseSIMDLdSt<0, 1, opcode, 0b00, asm,
9041                            (outs !cast<RegisterOperand>(veclist # "8b"):$Vt),
9042                            (ins GPR64sp:$Rn), []>;
9043     def v4h : BaseSIMDLdSt<0, 1, opcode, 0b01, asm,
9044                            (outs !cast<RegisterOperand>(veclist # "4h"):$Vt),
9045                            (ins GPR64sp:$Rn), []>;
9046     def v2s : BaseSIMDLdSt<0, 1, opcode, 0b10, asm,
9047                            (outs !cast<RegisterOperand>(veclist # "2s"):$Vt),
9048                            (ins GPR64sp:$Rn), []>;
9049
9050
9051     def v16b_POST: BaseSIMDLdStPost<1, 1, opcode, 0b00, asm,
9052                        (outs GPR64sp:$wback,
9053                              !cast<RegisterOperand>(veclist # "16b"):$Vt),
9054                        (ins GPR64sp:$Rn,
9055                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9056     def v8h_POST : BaseSIMDLdStPost<1, 1, opcode, 0b01, asm,
9057                        (outs GPR64sp:$wback,
9058                              !cast<RegisterOperand>(veclist # "8h"):$Vt),
9059                        (ins GPR64sp:$Rn,
9060                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9061     def v4s_POST : BaseSIMDLdStPost<1, 1, opcode, 0b10, asm,
9062                        (outs GPR64sp:$wback,
9063                              !cast<RegisterOperand>(veclist # "4s"):$Vt),
9064                        (ins GPR64sp:$Rn,
9065                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9066     def v2d_POST : BaseSIMDLdStPost<1, 1, opcode, 0b11, asm,
9067                        (outs GPR64sp:$wback,
9068                              !cast<RegisterOperand>(veclist # "2d"):$Vt),
9069                        (ins GPR64sp:$Rn,
9070                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9071     def v8b_POST : BaseSIMDLdStPost<0, 1, opcode, 0b00, asm,
9072                        (outs GPR64sp:$wback,
9073                              !cast<RegisterOperand>(veclist # "8b"):$Vt),
9074                        (ins GPR64sp:$Rn,
9075                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9076     def v4h_POST : BaseSIMDLdStPost<0, 1, opcode, 0b01, asm,
9077                        (outs GPR64sp:$wback,
9078                              !cast<RegisterOperand>(veclist # "4h"):$Vt),
9079                        (ins GPR64sp:$Rn,
9080                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9081     def v2s_POST : BaseSIMDLdStPost<0, 1, opcode, 0b10, asm,
9082                        (outs GPR64sp:$wback,
9083                              !cast<RegisterOperand>(veclist # "2s"):$Vt),
9084                        (ins GPR64sp:$Rn,
9085                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9086   }
9087
9088   defm : SIMDLdStAliases<BaseName, asm, "16b", Count, Offset128, 128>;
9089   defm : SIMDLdStAliases<BaseName, asm, "8h", Count, Offset128, 128>;
9090   defm : SIMDLdStAliases<BaseName, asm, "4s", Count, Offset128, 128>;
9091   defm : SIMDLdStAliases<BaseName, asm, "2d", Count, Offset128, 128>;
9092   defm : SIMDLdStAliases<BaseName, asm, "8b", Count, Offset64, 64>;
9093   defm : SIMDLdStAliases<BaseName, asm, "4h", Count, Offset64, 64>;
9094   defm : SIMDLdStAliases<BaseName, asm, "2s", Count, Offset64, 64>;
9095 }
9096
9097 // Only ld1/st1 has a v1d version.
9098 multiclass BaseSIMDStN<string BaseName, string Count, string asm, string veclist,
9099                        int Offset128, int Offset64, bits<4> opcode> {
9100   let hasSideEffects = 0, mayStore = 1, mayLoad = 0 in {
9101     def v16b : BaseSIMDLdSt<1, 0, opcode, 0b00, asm, (outs),
9102                             (ins !cast<RegisterOperand>(veclist # "16b"):$Vt,
9103                                  GPR64sp:$Rn), []>;
9104     def v8h : BaseSIMDLdSt<1, 0, opcode, 0b01, asm, (outs),
9105                            (ins !cast<RegisterOperand>(veclist # "8h"):$Vt,
9106                                 GPR64sp:$Rn), []>;
9107     def v4s : BaseSIMDLdSt<1, 0, opcode, 0b10, asm, (outs),
9108                            (ins !cast<RegisterOperand>(veclist # "4s"):$Vt,
9109                                 GPR64sp:$Rn), []>;
9110     def v2d : BaseSIMDLdSt<1, 0, opcode, 0b11, asm, (outs),
9111                            (ins !cast<RegisterOperand>(veclist # "2d"):$Vt,
9112                                 GPR64sp:$Rn), []>;
9113     def v8b : BaseSIMDLdSt<0, 0, opcode, 0b00, asm, (outs),
9114                            (ins !cast<RegisterOperand>(veclist # "8b"):$Vt,
9115                                 GPR64sp:$Rn), []>;
9116     def v4h : BaseSIMDLdSt<0, 0, opcode, 0b01, asm, (outs),
9117                            (ins !cast<RegisterOperand>(veclist # "4h"):$Vt,
9118                                 GPR64sp:$Rn), []>;
9119     def v2s : BaseSIMDLdSt<0, 0, opcode, 0b10, asm, (outs),
9120                            (ins !cast<RegisterOperand>(veclist # "2s"):$Vt,
9121                                 GPR64sp:$Rn), []>;
9122
9123     def v16b_POST : BaseSIMDLdStPost<1, 0, opcode, 0b00, asm,
9124                        (outs GPR64sp:$wback),
9125                        (ins !cast<RegisterOperand>(veclist # "16b"):$Vt,
9126                             GPR64sp:$Rn,
9127                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9128     def v8h_POST : BaseSIMDLdStPost<1, 0, opcode, 0b01, asm,
9129                        (outs GPR64sp:$wback),
9130                        (ins !cast<RegisterOperand>(veclist # "8h"):$Vt,
9131                             GPR64sp:$Rn,
9132                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9133     def v4s_POST : BaseSIMDLdStPost<1, 0, opcode, 0b10, asm,
9134                        (outs GPR64sp:$wback),
9135                        (ins !cast<RegisterOperand>(veclist # "4s"):$Vt,
9136                             GPR64sp:$Rn,
9137                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9138     def v2d_POST : BaseSIMDLdStPost<1, 0, opcode, 0b11, asm,
9139                        (outs GPR64sp:$wback),
9140                        (ins !cast<RegisterOperand>(veclist # "2d"):$Vt,
9141                             GPR64sp:$Rn,
9142                             !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
9143     def v8b_POST : BaseSIMDLdStPost<0, 0, opcode, 0b00, asm,
9144                        (outs GPR64sp:$wback),
9145                        (ins !cast<RegisterOperand>(veclist # "8b"):$Vt,
9146                             GPR64sp:$Rn,
9147                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9148     def v4h_POST : BaseSIMDLdStPost<0, 0, opcode, 0b01, asm,
9149                        (outs GPR64sp:$wback),
9150                        (ins !cast<RegisterOperand>(veclist # "4h"):$Vt,
9151                             GPR64sp:$Rn,
9152                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9153     def v2s_POST : BaseSIMDLdStPost<0, 0, opcode, 0b10, asm,
9154                        (outs GPR64sp:$wback),
9155                        (ins !cast<RegisterOperand>(veclist # "2s"):$Vt,
9156                             GPR64sp:$Rn,
9157                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9158   }
9159
9160   defm : SIMDLdStAliases<BaseName, asm, "16b", Count, Offset128, 128>;
9161   defm : SIMDLdStAliases<BaseName, asm, "8h", Count, Offset128, 128>;
9162   defm : SIMDLdStAliases<BaseName, asm, "4s", Count, Offset128, 128>;
9163   defm : SIMDLdStAliases<BaseName, asm, "2d", Count, Offset128, 128>;
9164   defm : SIMDLdStAliases<BaseName, asm, "8b", Count, Offset64, 64>;
9165   defm : SIMDLdStAliases<BaseName, asm, "4h", Count, Offset64, 64>;
9166   defm : SIMDLdStAliases<BaseName, asm, "2s", Count, Offset64, 64>;
9167 }
9168
9169 multiclass BaseSIMDLd1<string BaseName, string Count, string asm, string veclist,
9170                        int Offset128, int Offset64, bits<4> opcode>
9171   : BaseSIMDLdN<BaseName, Count, asm, veclist, Offset128, Offset64, opcode> {
9172
9173   // LD1 instructions have extra "1d" variants.
9174   let hasSideEffects = 0, mayLoad = 1, mayStore = 0 in {
9175     def v1d : BaseSIMDLdSt<0, 1, opcode, 0b11, asm,
9176                            (outs !cast<RegisterOperand>(veclist # "1d"):$Vt),
9177                            (ins GPR64sp:$Rn), []>;
9178
9179     def v1d_POST : BaseSIMDLdStPost<0, 1, opcode, 0b11, asm,
9180                        (outs GPR64sp:$wback,
9181                              !cast<RegisterOperand>(veclist # "1d"):$Vt),
9182                        (ins GPR64sp:$Rn,
9183                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9184   }
9185
9186   defm : SIMDLdStAliases<BaseName, asm, "1d", Count, Offset64, 64>;
9187 }
9188
9189 multiclass BaseSIMDSt1<string BaseName, string Count, string asm, string veclist,
9190                        int Offset128, int Offset64, bits<4> opcode>
9191   : BaseSIMDStN<BaseName, Count, asm, veclist, Offset128, Offset64, opcode> {
9192
9193   // ST1 instructions have extra "1d" variants.
9194   let hasSideEffects = 0, mayLoad = 0, mayStore = 1 in {
9195     def v1d : BaseSIMDLdSt<0, 0, opcode, 0b11, asm, (outs),
9196                            (ins !cast<RegisterOperand>(veclist # "1d"):$Vt,
9197                                 GPR64sp:$Rn), []>;
9198
9199     def v1d_POST : BaseSIMDLdStPost<0, 0, opcode, 0b11, asm,
9200                        (outs GPR64sp:$wback),
9201                        (ins !cast<RegisterOperand>(veclist # "1d"):$Vt,
9202                             GPR64sp:$Rn,
9203                             !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
9204   }
9205
9206   defm : SIMDLdStAliases<BaseName, asm, "1d", Count, Offset64, 64>;
9207 }
9208
9209 multiclass SIMDLd1Multiple<string asm> {
9210   defm One   : BaseSIMDLd1<NAME, "One", asm, "VecListOne", 16, 8,  0b0111>;
9211   defm Two   : BaseSIMDLd1<NAME, "Two", asm, "VecListTwo", 32, 16, 0b1010>;
9212   defm Three : BaseSIMDLd1<NAME, "Three", asm, "VecListThree", 48, 24, 0b0110>;
9213   defm Four  : BaseSIMDLd1<NAME, "Four", asm, "VecListFour", 64, 32, 0b0010>;
9214 }
9215
9216 multiclass SIMDSt1Multiple<string asm> {
9217   defm One   : BaseSIMDSt1<NAME, "One", asm, "VecListOne", 16, 8,  0b0111>;
9218   defm Two   : BaseSIMDSt1<NAME, "Two", asm, "VecListTwo", 32, 16, 0b1010>;
9219   defm Three : BaseSIMDSt1<NAME, "Three", asm, "VecListThree", 48, 24, 0b0110>;
9220   defm Four  : BaseSIMDSt1<NAME, "Four", asm, "VecListFour", 64, 32, 0b0010>;
9221 }
9222
9223 multiclass SIMDLd2Multiple<string asm> {
9224   defm Two : BaseSIMDLdN<NAME, "Two", asm, "VecListTwo", 32, 16, 0b1000>;
9225 }
9226
9227 multiclass SIMDSt2Multiple<string asm> {
9228   defm Two : BaseSIMDStN<NAME, "Two", asm, "VecListTwo", 32, 16, 0b1000>;
9229 }
9230
9231 multiclass SIMDLd3Multiple<string asm> {
9232   defm Three : BaseSIMDLdN<NAME, "Three", asm, "VecListThree", 48, 24, 0b0100>;
9233 }
9234
9235 multiclass SIMDSt3Multiple<string asm> {
9236   defm Three : BaseSIMDStN<NAME, "Three", asm, "VecListThree", 48, 24, 0b0100>;
9237 }
9238
9239 multiclass SIMDLd4Multiple<string asm> {
9240   defm Four : BaseSIMDLdN<NAME, "Four", asm, "VecListFour", 64, 32, 0b0000>;
9241 }
9242
9243 multiclass SIMDSt4Multiple<string asm> {
9244   defm Four : BaseSIMDStN<NAME, "Four", asm, "VecListFour", 64, 32, 0b0000>;
9245 }
9246
9247 //---
9248 // AdvSIMD Load/store single-element
9249 //---
9250
9251 class BaseSIMDLdStSingle<bit L, bit R, bits<3> opcode,
9252                          string asm, string operands, string cst,
9253                          dag oops, dag iops, list<dag> pattern>
9254   : I<oops, iops, asm, operands, cst, pattern> {
9255   bits<5> Vt;
9256   bits<5> Rn;
9257   let Inst{31} = 0;
9258   let Inst{29-24} = 0b001101;
9259   let Inst{22} = L;
9260   let Inst{21} = R;
9261   let Inst{15-13} = opcode;
9262   let Inst{9-5} = Rn;
9263   let Inst{4-0} = Vt;
9264 }
9265
9266 class BaseSIMDLdStSingleTied<bit L, bit R, bits<3> opcode,
9267                          string asm, string operands, string cst,
9268                          dag oops, dag iops, list<dag> pattern>
9269   : I<oops, iops, asm, operands, "$Vt = $dst," # cst, pattern> {
9270   bits<5> Vt;
9271   bits<5> Rn;
9272   let Inst{31} = 0;
9273   let Inst{29-24} = 0b001101;
9274   let Inst{22} = L;
9275   let Inst{21} = R;
9276   let Inst{15-13} = opcode;
9277   let Inst{9-5} = Rn;
9278   let Inst{4-0} = Vt;
9279 }
9280
9281
9282 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9283 class BaseSIMDLdR<bit Q, bit R, bits<3> opcode, bit S, bits<2> size, string asm,
9284                   DAGOperand listtype>
9285   : BaseSIMDLdStSingle<1, R, opcode, asm, "\t$Vt, [$Rn]", "",
9286                        (outs listtype:$Vt), (ins GPR64sp:$Rn),
9287                        []> {
9288   let Inst{30} = Q;
9289   let Inst{23} = 0;
9290   let Inst{20-16} = 0b00000;
9291   let Inst{12} = S;
9292   let Inst{11-10} = size;
9293 }
9294 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9295 class BaseSIMDLdRPost<bit Q, bit R, bits<3> opcode, bit S, bits<2> size,
9296                       string asm, DAGOperand listtype, DAGOperand GPR64pi>
9297   : BaseSIMDLdStSingle<1, R, opcode, asm, "\t$Vt, [$Rn], $Xm",
9298                        "$Rn = $wback",
9299                        (outs GPR64sp:$wback, listtype:$Vt),
9300                        (ins GPR64sp:$Rn, GPR64pi:$Xm), []> {
9301   bits<5> Xm;
9302   let Inst{30} = Q;
9303   let Inst{23} = 1;
9304   let Inst{20-16} = Xm;
9305   let Inst{12} = S;
9306   let Inst{11-10} = size;
9307 }
9308
9309 multiclass SIMDLdrAliases<string BaseName, string asm, string layout, string Count,
9310                           int Offset, int Size> {
9311   // E.g. "ld1r { v0.8b }, [x1], #1"
9312   //      "ld1r.8b\t$Vt, [$Rn], #1"
9313   // may get mapped to
9314   //      (LD1Rv8b_POST VecListOne8b:$Vt, GPR64sp:$Rn, XZR)
9315   def : InstAlias<asm # "\t$Vt, [$Rn], #" # Offset,
9316                   (!cast<Instruction>(BaseName # "v" # layout # "_POST")
9317                       GPR64sp:$Rn,
9318                       !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
9319                       XZR), 1>;
9320
9321   // E.g. "ld1r.8b { v0 }, [x1], #1"
9322   //      "ld1r.8b\t$Vt, [$Rn], #1"
9323   // may get mapped to
9324   //      (LD1Rv8b_POST VecListOne64:$Vt, GPR64sp:$Rn, XZR)
9325   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn], #" # Offset,
9326                   (!cast<Instruction>(BaseName # "v" # layout # "_POST")
9327                       GPR64sp:$Rn,
9328                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9329                       XZR), 0>;
9330
9331   // E.g. "ld1r.8b { v0 }, [x1]"
9332   //      "ld1r.8b\t$Vt, [$Rn]"
9333   // may get mapped to
9334   //      (LD1Rv8b VecListOne64:$Vt, GPR64sp:$Rn)
9335   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn]",
9336                   (!cast<Instruction>(BaseName # "v" # layout)
9337                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9338                       GPR64sp:$Rn), 0>;
9339
9340   // E.g. "ld1r.8b { v0 }, [x1], x2"
9341   //      "ld1r.8b\t$Vt, [$Rn], $Xm"
9342   // may get mapped to
9343   //      (LD1Rv8b_POST VecListOne64:$Vt, GPR64sp:$Rn, GPR64pi1:$Xm)
9344   def : InstAlias<asm # "." # layout # "\t$Vt, [$Rn], $Xm",
9345                   (!cast<Instruction>(BaseName # "v" # layout # "_POST")
9346                       GPR64sp:$Rn,
9347                       !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
9348                       !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
9349 }
9350
9351 multiclass SIMDLdR<bit R, bits<3> opcode, bit S, string asm, string Count,
9352   int Offset1, int Offset2, int Offset4, int Offset8> {
9353   def v8b : BaseSIMDLdR<0, R, opcode, S, 0b00, asm,
9354                         !cast<DAGOperand>("VecList" # Count # "8b")>;
9355   def v16b: BaseSIMDLdR<1, R, opcode, S, 0b00, asm,
9356                         !cast<DAGOperand>("VecList" # Count #"16b")>;
9357   def v4h : BaseSIMDLdR<0, R, opcode, S, 0b01, asm,
9358                         !cast<DAGOperand>("VecList" # Count #"4h")>;
9359   def v8h : BaseSIMDLdR<1, R, opcode, S, 0b01, asm,
9360                         !cast<DAGOperand>("VecList" # Count #"8h")>;
9361   def v2s : BaseSIMDLdR<0, R, opcode, S, 0b10, asm,
9362                         !cast<DAGOperand>("VecList" # Count #"2s")>;
9363   def v4s : BaseSIMDLdR<1, R, opcode, S, 0b10, asm,
9364                         !cast<DAGOperand>("VecList" # Count #"4s")>;
9365   def v1d : BaseSIMDLdR<0, R, opcode, S, 0b11, asm,
9366                         !cast<DAGOperand>("VecList" # Count #"1d")>;
9367   def v2d : BaseSIMDLdR<1, R, opcode, S, 0b11, asm,
9368                         !cast<DAGOperand>("VecList" # Count #"2d")>;
9369
9370   def v8b_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b00, asm,
9371                                  !cast<DAGOperand>("VecList" # Count # "8b"),
9372                                  !cast<DAGOperand>("GPR64pi" # Offset1)>;
9373   def v16b_POST: BaseSIMDLdRPost<1, R, opcode, S, 0b00, asm,
9374                                  !cast<DAGOperand>("VecList" # Count # "16b"),
9375                                  !cast<DAGOperand>("GPR64pi" # Offset1)>;
9376   def v4h_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b01, asm,
9377                                  !cast<DAGOperand>("VecList" # Count # "4h"),
9378                                  !cast<DAGOperand>("GPR64pi" # Offset2)>;
9379   def v8h_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b01, asm,
9380                                  !cast<DAGOperand>("VecList" # Count # "8h"),
9381                                  !cast<DAGOperand>("GPR64pi" # Offset2)>;
9382   def v2s_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b10, asm,
9383                                  !cast<DAGOperand>("VecList" # Count # "2s"),
9384                                  !cast<DAGOperand>("GPR64pi" # Offset4)>;
9385   def v4s_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b10, asm,
9386                                  !cast<DAGOperand>("VecList" # Count # "4s"),
9387                                  !cast<DAGOperand>("GPR64pi" # Offset4)>;
9388   def v1d_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b11, asm,
9389                                  !cast<DAGOperand>("VecList" # Count # "1d"),
9390                                  !cast<DAGOperand>("GPR64pi" # Offset8)>;
9391   def v2d_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b11, asm,
9392                                  !cast<DAGOperand>("VecList" # Count # "2d"),
9393                                  !cast<DAGOperand>("GPR64pi" # Offset8)>;
9394
9395   defm : SIMDLdrAliases<NAME, asm, "8b",  Count, Offset1,  64>;
9396   defm : SIMDLdrAliases<NAME, asm, "16b", Count, Offset1, 128>;
9397   defm : SIMDLdrAliases<NAME, asm, "4h",  Count, Offset2,  64>;
9398   defm : SIMDLdrAliases<NAME, asm, "8h",  Count, Offset2, 128>;
9399   defm : SIMDLdrAliases<NAME, asm, "2s",  Count, Offset4,  64>;
9400   defm : SIMDLdrAliases<NAME, asm, "4s",  Count, Offset4, 128>;
9401   defm : SIMDLdrAliases<NAME, asm, "1d",  Count, Offset8,  64>;
9402   defm : SIMDLdrAliases<NAME, asm, "2d",  Count, Offset8, 128>;
9403 }
9404
9405 class SIMDLdStSingleB<bit L, bit R, bits<3> opcode, string asm,
9406                       dag oops, dag iops, list<dag> pattern>
9407   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "", oops, iops,
9408                        pattern> {
9409   // idx encoded in Q:S:size fields.
9410   bits<4> idx;
9411   let Inst{30} = idx{3};
9412   let Inst{23} = 0;
9413   let Inst{20-16} = 0b00000;
9414   let Inst{12} = idx{2};
9415   let Inst{11-10} = idx{1-0};
9416 }
9417 class SIMDLdStSingleBTied<bit L, bit R, bits<3> opcode, string asm,
9418                       dag oops, dag iops, list<dag> pattern>
9419   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "",
9420                            oops, iops, pattern> {
9421   // idx encoded in Q:S:size fields.
9422   bits<4> idx;
9423   let Inst{30} = idx{3};
9424   let Inst{23} = 0;
9425   let Inst{20-16} = 0b00000;
9426   let Inst{12} = idx{2};
9427   let Inst{11-10} = idx{1-0};
9428 }
9429 class SIMDLdStSingleBPost<bit L, bit R, bits<3> opcode, string asm,
9430                           dag oops, dag iops>
9431   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9432                        "$Rn = $wback", oops, iops, []> {
9433   // idx encoded in Q:S:size fields.
9434   bits<4> idx;
9435   bits<5> Xm;
9436   let Inst{30} = idx{3};
9437   let Inst{23} = 1;
9438   let Inst{20-16} = Xm;
9439   let Inst{12} = idx{2};
9440   let Inst{11-10} = idx{1-0};
9441 }
9442 class SIMDLdStSingleBTiedPost<bit L, bit R, bits<3> opcode, string asm,
9443                           dag oops, dag iops>
9444   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9445                            "$Rn = $wback", oops, iops, []> {
9446   // idx encoded in Q:S:size fields.
9447   bits<4> idx;
9448   bits<5> Xm;
9449   let Inst{30} = idx{3};
9450   let Inst{23} = 1;
9451   let Inst{20-16} = Xm;
9452   let Inst{12} = idx{2};
9453   let Inst{11-10} = idx{1-0};
9454 }
9455
9456 class SIMDLdStSingleH<bit L, bit R, bits<3> opcode, bit size, string asm,
9457                       dag oops, dag iops, list<dag> pattern>
9458   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "", oops, iops,
9459                        pattern> {
9460   // idx encoded in Q:S:size<1> fields.
9461   bits<3> idx;
9462   let Inst{30} = idx{2};
9463   let Inst{23} = 0;
9464   let Inst{20-16} = 0b00000;
9465   let Inst{12} = idx{1};
9466   let Inst{11} = idx{0};
9467   let Inst{10} = size;
9468 }
9469 class SIMDLdStSingleHTied<bit L, bit R, bits<3> opcode, bit size, string asm,
9470                       dag oops, dag iops, list<dag> pattern>
9471   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "",
9472                            oops, iops, pattern> {
9473   // idx encoded in Q:S:size<1> fields.
9474   bits<3> idx;
9475   let Inst{30} = idx{2};
9476   let Inst{23} = 0;
9477   let Inst{20-16} = 0b00000;
9478   let Inst{12} = idx{1};
9479   let Inst{11} = idx{0};
9480   let Inst{10} = size;
9481 }
9482
9483 class SIMDLdStSingleHPost<bit L, bit R, bits<3> opcode, bit size, string asm,
9484                           dag oops, dag iops>
9485   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9486                        "$Rn = $wback", oops, iops, []> {
9487   // idx encoded in Q:S:size<1> fields.
9488   bits<3> idx;
9489   bits<5> Xm;
9490   let Inst{30} = idx{2};
9491   let Inst{23} = 1;
9492   let Inst{20-16} = Xm;
9493   let Inst{12} = idx{1};
9494   let Inst{11} = idx{0};
9495   let Inst{10} = size;
9496 }
9497 class SIMDLdStSingleHTiedPost<bit L, bit R, bits<3> opcode, bit size, string asm,
9498                           dag oops, dag iops>
9499   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9500                            "$Rn = $wback", oops, iops, []> {
9501   // idx encoded in Q:S:size<1> fields.
9502   bits<3> idx;
9503   bits<5> Xm;
9504   let Inst{30} = idx{2};
9505   let Inst{23} = 1;
9506   let Inst{20-16} = Xm;
9507   let Inst{12} = idx{1};
9508   let Inst{11} = idx{0};
9509   let Inst{10} = size;
9510 }
9511 class SIMDLdStSingleS<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
9512                       dag oops, dag iops, list<dag> pattern>
9513   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "", oops, iops,
9514                        pattern> {
9515   // idx encoded in Q:S fields.
9516   bits<2> idx;
9517   let Inst{30} = idx{1};
9518   let Inst{23} = 0;
9519   let Inst{20-16} = 0b00000;
9520   let Inst{12} = idx{0};
9521   let Inst{11-10} = size;
9522 }
9523 class SIMDLdStSingleSTied<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
9524                       dag oops, dag iops, list<dag> pattern>
9525   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "",
9526                            oops, iops, pattern> {
9527   // idx encoded in Q:S fields.
9528   bits<2> idx;
9529   let Inst{30} = idx{1};
9530   let Inst{23} = 0;
9531   let Inst{20-16} = 0b00000;
9532   let Inst{12} = idx{0};
9533   let Inst{11-10} = size;
9534 }
9535 class SIMDLdStSingleSPost<bit L, bit R, bits<3> opcode, bits<2> size,
9536                           string asm, dag oops, dag iops>
9537   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9538                        "$Rn = $wback", oops, iops, []> {
9539   // idx encoded in Q:S fields.
9540   bits<2> idx;
9541   bits<5> Xm;
9542   let Inst{30} = idx{1};
9543   let Inst{23} = 1;
9544   let Inst{20-16} = Xm;
9545   let Inst{12} = idx{0};
9546   let Inst{11-10} = size;
9547 }
9548 class SIMDLdStSingleSTiedPost<bit L, bit R, bits<3> opcode, bits<2> size,
9549                           string asm, dag oops, dag iops>
9550   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9551                            "$Rn = $wback", oops, iops, []> {
9552   // idx encoded in Q:S fields.
9553   bits<2> idx;
9554   bits<5> Xm;
9555   let Inst{30} = idx{1};
9556   let Inst{23} = 1;
9557   let Inst{20-16} = Xm;
9558   let Inst{12} = idx{0};
9559   let Inst{11-10} = size;
9560 }
9561 class SIMDLdStSingleD<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
9562                       dag oops, dag iops, list<dag> pattern>
9563   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "", oops, iops,
9564                        pattern> {
9565   // idx encoded in Q field.
9566   bits<1> idx;
9567   let Inst{30} = idx;
9568   let Inst{23} = 0;
9569   let Inst{20-16} = 0b00000;
9570   let Inst{12} = 0;
9571   let Inst{11-10} = size;
9572 }
9573 class SIMDLdStSingleDTied<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
9574                       dag oops, dag iops, list<dag> pattern>
9575   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn]", "",
9576                            oops, iops, pattern> {
9577   // idx encoded in Q field.
9578   bits<1> idx;
9579   let Inst{30} = idx;
9580   let Inst{23} = 0;
9581   let Inst{20-16} = 0b00000;
9582   let Inst{12} = 0;
9583   let Inst{11-10} = size;
9584 }
9585 class SIMDLdStSingleDPost<bit L, bit R, bits<3> opcode, bits<2> size,
9586                           string asm, dag oops, dag iops>
9587   : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9588                        "$Rn = $wback", oops, iops, []> {
9589   // idx encoded in Q field.
9590   bits<1> idx;
9591   bits<5> Xm;
9592   let Inst{30} = idx;
9593   let Inst{23} = 1;
9594   let Inst{20-16} = Xm;
9595   let Inst{12} = 0;
9596   let Inst{11-10} = size;
9597 }
9598 class SIMDLdStSingleDTiedPost<bit L, bit R, bits<3> opcode, bits<2> size,
9599                           string asm, dag oops, dag iops>
9600   : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, [$Rn], $Xm",
9601                            "$Rn = $wback", oops, iops, []> {
9602   // idx encoded in Q field.
9603   bits<1> idx;
9604   bits<5> Xm;
9605   let Inst{30} = idx;
9606   let Inst{23} = 1;
9607   let Inst{20-16} = Xm;
9608   let Inst{12} = 0;
9609   let Inst{11-10} = size;
9610 }
9611
9612 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9613 multiclass SIMDLdSingleBTied<bit R, bits<3> opcode, string asm,
9614                          RegisterOperand listtype,
9615                          RegisterOperand GPR64pi> {
9616   def i8 : SIMDLdStSingleBTied<1, R, opcode, asm,
9617                            (outs listtype:$dst),
9618                            (ins listtype:$Vt, VectorIndexB:$idx,
9619                                 GPR64sp:$Rn), []>;
9620
9621   def i8_POST : SIMDLdStSingleBTiedPost<1, R, opcode, asm,
9622                             (outs GPR64sp:$wback, listtype:$dst),
9623                             (ins listtype:$Vt, VectorIndexB:$idx,
9624                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9625 }
9626 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9627 multiclass SIMDLdSingleHTied<bit R, bits<3> opcode, bit size, string asm,
9628                          RegisterOperand listtype,
9629                          RegisterOperand GPR64pi> {
9630   def i16 : SIMDLdStSingleHTied<1, R, opcode, size, asm,
9631                             (outs listtype:$dst),
9632                             (ins listtype:$Vt, VectorIndexH:$idx,
9633                                  GPR64sp:$Rn), []>;
9634
9635   def i16_POST : SIMDLdStSingleHTiedPost<1, R, opcode, size, asm,
9636                             (outs GPR64sp:$wback, listtype:$dst),
9637                             (ins listtype:$Vt, VectorIndexH:$idx,
9638                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9639 }
9640 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9641 multiclass SIMDLdSingleSTied<bit R, bits<3> opcode, bits<2> size,string asm,
9642                          RegisterOperand listtype,
9643                          RegisterOperand GPR64pi> {
9644   def i32 : SIMDLdStSingleSTied<1, R, opcode, size, asm,
9645                             (outs listtype:$dst),
9646                             (ins listtype:$Vt, VectorIndexS:$idx,
9647                                  GPR64sp:$Rn), []>;
9648
9649   def i32_POST : SIMDLdStSingleSTiedPost<1, R, opcode, size, asm,
9650                             (outs GPR64sp:$wback, listtype:$dst),
9651                             (ins listtype:$Vt, VectorIndexS:$idx,
9652                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9653 }
9654 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
9655 multiclass SIMDLdSingleDTied<bit R, bits<3> opcode, bits<2> size, string asm,
9656                          RegisterOperand listtype, RegisterOperand GPR64pi> {
9657   def i64 : SIMDLdStSingleDTied<1, R, opcode, size, asm,
9658                             (outs listtype:$dst),
9659                             (ins listtype:$Vt, VectorIndexD:$idx,
9660                                  GPR64sp:$Rn), []>;
9661
9662   def i64_POST : SIMDLdStSingleDTiedPost<1, R, opcode, size, asm,
9663                             (outs GPR64sp:$wback, listtype:$dst),
9664                             (ins listtype:$Vt, VectorIndexD:$idx,
9665                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9666 }
9667 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
9668 multiclass SIMDStSingleB<bit R, bits<3> opcode, string asm,
9669                          RegisterOperand listtype, RegisterOperand GPR64pi> {
9670   def i8 : SIMDLdStSingleB<0, R, opcode, asm,
9671                            (outs), (ins listtype:$Vt, VectorIndexB:$idx,
9672                                         GPR64sp:$Rn), []>;
9673
9674   def i8_POST : SIMDLdStSingleBPost<0, R, opcode, asm,
9675                                     (outs GPR64sp:$wback),
9676                                     (ins listtype:$Vt, VectorIndexB:$idx,
9677                                          GPR64sp:$Rn, GPR64pi:$Xm)>;
9678 }
9679 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
9680 multiclass SIMDStSingleH<bit R, bits<3> opcode, bit size, string asm,
9681                          RegisterOperand listtype, RegisterOperand GPR64pi> {
9682   def i16 : SIMDLdStSingleH<0, R, opcode, size, asm,
9683                             (outs), (ins listtype:$Vt, VectorIndexH:$idx,
9684                                          GPR64sp:$Rn), []>;
9685
9686   def i16_POST : SIMDLdStSingleHPost<0, R, opcode, size, asm,
9687                             (outs GPR64sp:$wback),
9688                             (ins listtype:$Vt, VectorIndexH:$idx,
9689                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9690 }
9691 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
9692 multiclass SIMDStSingleS<bit R, bits<3> opcode, bits<2> size,string asm,
9693                          RegisterOperand listtype, RegisterOperand GPR64pi> {
9694   def i32 : SIMDLdStSingleS<0, R, opcode, size, asm,
9695                             (outs), (ins listtype:$Vt, VectorIndexS:$idx,
9696                                          GPR64sp:$Rn), []>;
9697
9698   def i32_POST : SIMDLdStSingleSPost<0, R, opcode, size, asm,
9699                             (outs GPR64sp:$wback),
9700                             (ins listtype:$Vt, VectorIndexS:$idx,
9701                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9702 }
9703 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
9704 multiclass SIMDStSingleD<bit R, bits<3> opcode, bits<2> size, string asm,
9705                          RegisterOperand listtype, RegisterOperand GPR64pi> {
9706   def i64 : SIMDLdStSingleD<0, R, opcode, size, asm,
9707                             (outs), (ins listtype:$Vt, VectorIndexD:$idx,
9708                                          GPR64sp:$Rn), []>;
9709
9710   def i64_POST : SIMDLdStSingleDPost<0, R, opcode, size, asm,
9711                             (outs GPR64sp:$wback),
9712                             (ins listtype:$Vt, VectorIndexD:$idx,
9713                                  GPR64sp:$Rn, GPR64pi:$Xm)>;
9714 }
9715
9716 multiclass SIMDLdStSingleAliases<string asm, string layout, string Type,
9717                                  string Count, int Offset, Operand idxtype> {
9718   // E.g. "ld1 { v0.8b }[0], [x1], #1"
9719   //      "ld1\t$Vt, [$Rn], #1"
9720   // may get mapped to
9721   //      (LD1Rv8b_POST VecListOne8b:$Vt, GPR64sp:$Rn, XZR)
9722   def : InstAlias<asm # "\t$Vt$idx, [$Rn], #" # Offset,
9723                   (!cast<Instruction>(NAME # Type  # "_POST")
9724                       GPR64sp:$Rn,
9725                       !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
9726                       idxtype:$idx, XZR), 1>;
9727
9728   // E.g. "ld1.8b { v0 }[0], [x1], #1"
9729   //      "ld1.8b\t$Vt, [$Rn], #1"
9730   // may get mapped to
9731   //      (LD1Rv8b_POST VecListOne64:$Vt, GPR64sp:$Rn, XZR)
9732   def : InstAlias<asm # "." # layout # "\t$Vt$idx, [$Rn], #" # Offset,
9733                   (!cast<Instruction>(NAME # Type # "_POST")
9734                       GPR64sp:$Rn,
9735                       !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
9736                       idxtype:$idx, XZR), 0>;
9737
9738   // E.g. "ld1.8b { v0 }[0], [x1]"
9739   //      "ld1.8b\t$Vt, [$Rn]"
9740   // may get mapped to
9741   //      (LD1Rv8b VecListOne64:$Vt, GPR64sp:$Rn)
9742   def : InstAlias<asm # "." # layout # "\t$Vt$idx, [$Rn]",
9743                       (!cast<Instruction>(NAME # Type)
9744                          !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
9745                          idxtype:$idx, GPR64sp:$Rn), 0>;
9746
9747   // E.g. "ld1.8b { v0 }[0], [x1], x2"
9748   //      "ld1.8b\t$Vt, [$Rn], $Xm"
9749   // may get mapped to
9750   //      (LD1Rv8b_POST VecListOne64:$Vt, GPR64sp:$Rn, GPR64pi1:$Xm)
9751   def : InstAlias<asm # "." # layout # "\t$Vt$idx, [$Rn], $Xm",
9752                       (!cast<Instruction>(NAME # Type # "_POST")
9753                          GPR64sp:$Rn,
9754                          !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
9755                          idxtype:$idx,
9756                          !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
9757 }
9758
9759 multiclass SIMDLdSt1SingleAliases<string asm> {
9760   defm "" : SIMDLdStSingleAliases<asm, "b", "i8",  "One", 1, VectorIndexB>;
9761   defm "" : SIMDLdStSingleAliases<asm, "h", "i16", "One", 2, VectorIndexH>;
9762   defm "" : SIMDLdStSingleAliases<asm, "s", "i32", "One", 4, VectorIndexS>;
9763   defm "" : SIMDLdStSingleAliases<asm, "d", "i64", "One", 8, VectorIndexD>;
9764 }
9765
9766 multiclass SIMDLdSt2SingleAliases<string asm> {
9767   defm "" : SIMDLdStSingleAliases<asm, "b", "i8",  "Two", 2,  VectorIndexB>;
9768   defm "" : SIMDLdStSingleAliases<asm, "h", "i16", "Two", 4,  VectorIndexH>;
9769   defm "" : SIMDLdStSingleAliases<asm, "s", "i32", "Two", 8,  VectorIndexS>;
9770   defm "" : SIMDLdStSingleAliases<asm, "d", "i64", "Two", 16, VectorIndexD>;
9771 }
9772
9773 multiclass SIMDLdSt3SingleAliases<string asm> {
9774   defm "" : SIMDLdStSingleAliases<asm, "b", "i8",  "Three", 3,  VectorIndexB>;
9775   defm "" : SIMDLdStSingleAliases<asm, "h", "i16", "Three", 6,  VectorIndexH>;
9776   defm "" : SIMDLdStSingleAliases<asm, "s", "i32", "Three", 12, VectorIndexS>;
9777   defm "" : SIMDLdStSingleAliases<asm, "d", "i64", "Three", 24, VectorIndexD>;
9778 }
9779
9780 multiclass SIMDLdSt4SingleAliases<string asm> {
9781   defm "" : SIMDLdStSingleAliases<asm, "b", "i8",  "Four", 4,  VectorIndexB>;
9782   defm "" : SIMDLdStSingleAliases<asm, "h", "i16", "Four", 8,  VectorIndexH>;
9783   defm "" : SIMDLdStSingleAliases<asm, "s", "i32", "Four", 16, VectorIndexS>;
9784   defm "" : SIMDLdStSingleAliases<asm, "d", "i64", "Four", 32, VectorIndexD>;
9785 }
9786 } // end of 'let Predicates = [HasNEON]'
9787
9788 //----------------------------------------------------------------------------
9789 // AdvSIMD v8.1 Rounding Double Multiply Add/Subtract
9790 //----------------------------------------------------------------------------
9791
9792 let Predicates = [HasNEON, HasRDM] in {
9793
9794 class BaseSIMDThreeSameVectorTiedR0<bit Q, bit U, bits<2> size, bits<5> opcode,
9795                                     RegisterOperand regtype, string asm,
9796                                     string kind, list<dag> pattern>
9797   : BaseSIMDThreeSameVectorTied<Q, U, {size,0}, opcode, regtype, asm, kind,
9798                                 pattern> {
9799 }
9800 multiclass SIMDThreeSameVectorSQRDMLxHTiedHS<bit U, bits<5> opc, string asm,
9801                                              SDPatternOperator Accum> {
9802   def v4i16 : BaseSIMDThreeSameVectorTiedR0<0, U, 0b01, opc, V64, asm, ".4h",
9803     [(set (v4i16 V64:$dst),
9804           (Accum (v4i16 V64:$Rd),
9805                  (v4i16 (int_aarch64_neon_sqrdmulh (v4i16 V64:$Rn),
9806                                                    (v4i16 V64:$Rm)))))]>;
9807   def v8i16 : BaseSIMDThreeSameVectorTiedR0<1, U, 0b01, opc, V128, asm, ".8h",
9808     [(set (v8i16 V128:$dst),
9809           (Accum (v8i16 V128:$Rd),
9810                  (v8i16 (int_aarch64_neon_sqrdmulh (v8i16 V128:$Rn),
9811                                                    (v8i16 V128:$Rm)))))]>;
9812   def v2i32 : BaseSIMDThreeSameVectorTiedR0<0, U, 0b10, opc, V64, asm, ".2s",
9813     [(set (v2i32 V64:$dst),
9814           (Accum (v2i32 V64:$Rd),
9815                  (v2i32 (int_aarch64_neon_sqrdmulh (v2i32 V64:$Rn),
9816                                                    (v2i32 V64:$Rm)))))]>;
9817   def v4i32 : BaseSIMDThreeSameVectorTiedR0<1, U, 0b10, opc, V128, asm, ".4s",
9818     [(set (v4i32 V128:$dst),
9819           (Accum (v4i32 V128:$Rd),
9820                  (v4i32 (int_aarch64_neon_sqrdmulh (v4i32 V128:$Rn),
9821                                                    (v4i32 V128:$Rm)))))]>;
9822 }
9823
9824 multiclass SIMDIndexedSQRDMLxHSDTied<bit U, bits<4> opc, string asm,
9825                                      SDPatternOperator Accum> {
9826   def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc,
9827                                           V64, V64, V128_lo, VectorIndexH,
9828                                           asm, ".4h", ".4h", ".4h", ".h",
9829     [(set (v4i16 V64:$dst),
9830           (Accum (v4i16 V64:$Rd),
9831                  (v4i16 (int_aarch64_neon_sqrdmulh
9832                           (v4i16 V64:$Rn),
9833                           (v4i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
9834                                                     VectorIndexH:$idx))))))]> {
9835     bits<3> idx;
9836     let Inst{11} = idx{2};
9837     let Inst{21} = idx{1};
9838     let Inst{20} = idx{0};
9839   }
9840
9841   def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
9842                                           V128, V128, V128_lo, VectorIndexH,
9843                                           asm, ".8h", ".8h", ".8h", ".h",
9844     [(set (v8i16 V128:$dst),
9845           (Accum (v8i16 V128:$Rd),
9846                  (v8i16 (int_aarch64_neon_sqrdmulh
9847                           (v8i16 V128:$Rn),
9848                           (v8i16 (AArch64duplane16 (v8i16 V128_lo:$Rm),
9849                                                    VectorIndexH:$idx))))))]> {
9850     bits<3> idx;
9851     let Inst{11} = idx{2};
9852     let Inst{21} = idx{1};
9853     let Inst{20} = idx{0};
9854   }
9855
9856   def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
9857                                           V64, V64, V128, VectorIndexS,
9858                                           asm, ".2s", ".2s", ".2s", ".s",
9859     [(set (v2i32 V64:$dst),
9860         (Accum (v2i32 V64:$Rd),
9861                (v2i32 (int_aarch64_neon_sqrdmulh
9862                         (v2i32 V64:$Rn),
9863                         (v2i32 (AArch64duplane32 (v4i32 V128:$Rm),
9864                                                  VectorIndexS:$idx))))))]> {
9865     bits<2> idx;
9866     let Inst{11} = idx{1};
9867     let Inst{21} = idx{0};
9868   }
9869
9870   // FIXME: it would be nice to use the scalar (v1i32) instruction here, but
9871   // an intermediate EXTRACT_SUBREG would be untyped.
9872   // FIXME: direct EXTRACT_SUBREG from v2i32 to i32 is illegal, that's why we
9873   // got it lowered here as (i32 vector_extract (v4i32 insert_subvector(..)))
9874   def : Pat<(i32 (Accum (i32 FPR32Op:$Rd),
9875                        (i32 (vector_extract
9876                                (v4i32 (insert_subvector
9877                                        (undef),
9878                                         (v2i32 (int_aarch64_neon_sqrdmulh
9879                                                  (v2i32 V64:$Rn),
9880                                                  (v2i32 (AArch64duplane32
9881                                                           (v4i32 V128:$Rm),
9882                                                           VectorIndexS:$idx)))),
9883                                       (i32 0))),
9884                                (i64 0))))),
9885             (EXTRACT_SUBREG
9886                 (v2i32 (!cast<Instruction>(NAME # v2i32_indexed)
9887                           (v2i32 (INSERT_SUBREG (v2i32 (IMPLICIT_DEF)),
9888                                                 FPR32Op:$Rd,
9889                                                 ssub)),
9890                           V64:$Rn,
9891                           V128:$Rm,
9892                           VectorIndexS:$idx)),
9893                 ssub)>;
9894
9895   def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
9896                                           V128, V128, V128, VectorIndexS,
9897                                           asm, ".4s", ".4s", ".4s", ".s",
9898     [(set (v4i32 V128:$dst),
9899           (Accum (v4i32 V128:$Rd),
9900                  (v4i32 (int_aarch64_neon_sqrdmulh
9901                           (v4i32 V128:$Rn),
9902                           (v4i32 (AArch64duplane32 (v4i32 V128:$Rm),
9903                                                    VectorIndexS:$idx))))))]> {
9904     bits<2> idx;
9905     let Inst{11} = idx{1};
9906     let Inst{21} = idx{0};
9907   }
9908
9909   // FIXME: it would be nice to use the scalar (v1i32) instruction here, but
9910   // an intermediate EXTRACT_SUBREG would be untyped.
9911   def : Pat<(i32 (Accum (i32 FPR32Op:$Rd),
9912                         (i32 (vector_extract
9913                                (v4i32 (int_aarch64_neon_sqrdmulh
9914                                         (v4i32 V128:$Rn),
9915                                         (v4i32 (AArch64duplane32
9916                                                  (v4i32 V128:$Rm),
9917                                                  VectorIndexS:$idx)))),
9918                                (i64 0))))),
9919             (EXTRACT_SUBREG
9920                 (v4i32 (!cast<Instruction>(NAME # v4i32_indexed)
9921                          (v4i32 (INSERT_SUBREG (v4i32 (IMPLICIT_DEF)),
9922                                                FPR32Op:$Rd,
9923                                                ssub)),
9924                          V128:$Rn,
9925                          V128:$Rm,
9926                          VectorIndexS:$idx)),
9927                 ssub)>;
9928
9929   def i16_indexed : BaseSIMDIndexedTied<1, U, 1, 0b01, opc,
9930                                         FPR16Op, FPR16Op, V128_lo,
9931                                         VectorIndexH, asm, ".h", "", "", ".h",
9932                                         []> {
9933     bits<3> idx;
9934     let Inst{11} = idx{2};
9935     let Inst{21} = idx{1};
9936     let Inst{20} = idx{0};
9937   }
9938
9939   def i32_indexed : BaseSIMDIndexedTied<1, U, 1, 0b10, opc,
9940                                         FPR32Op, FPR32Op, V128, VectorIndexS,
9941                                         asm, ".s", "", "", ".s",
9942     [(set (i32 FPR32Op:$dst),
9943           (Accum (i32 FPR32Op:$Rd),
9944                  (i32 (int_aarch64_neon_sqrdmulh
9945                         (i32 FPR32Op:$Rn),
9946                         (i32 (vector_extract (v4i32 V128:$Rm),
9947                                              VectorIndexS:$idx))))))]> {
9948     bits<2> idx;
9949     let Inst{11} = idx{1};
9950     let Inst{21} = idx{0};
9951   }
9952 }
9953 } // let Predicates = [HasNeon, HasRDM]
9954
9955 //----------------------------------------------------------------------------
9956 // ARMv8.3 Complex ADD/MLA instructions
9957 //----------------------------------------------------------------------------
9958
9959 class ComplexRotationOperand<int Angle, int Remainder, string Type>
9960   : AsmOperandClass {
9961   let PredicateMethod = "isComplexRotation<" # Angle # ", " # Remainder # ">";
9962   let DiagnosticType = "InvalidComplexRotation" # Type;
9963   let Name = "ComplexRotation" # Type;
9964 }
9965 def complexrotateop : Operand<i32> {
9966   let ParserMatchClass = ComplexRotationOperand<90, 0, "Even">;
9967   let PrintMethod = "printComplexRotationOp<90, 0>";
9968 }
9969 def complexrotateopodd : Operand<i32> {
9970   let ParserMatchClass = ComplexRotationOperand<180, 90, "Odd">;
9971   let PrintMethod = "printComplexRotationOp<180, 90>";
9972 }
9973
9974 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
9975 class BaseSIMDThreeSameVectorComplex<bit Q, bit U, bits<2> size, bits<3> opcode,
9976                                      RegisterOperand regtype, Operand rottype,
9977                                      string asm, string kind, list<dag> pattern>
9978   : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, rottype:$rot), asm,
9979       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind # ", $rot"
9980       "|" # kind # "\t$Rd, $Rn, $Rm, $rot}", "", pattern>,
9981     Sched<[WriteV]> {
9982   bits<5> Rd;
9983   bits<5> Rn;
9984   bits<5> Rm;
9985   bits<1> rot;
9986   let Inst{31}    = 0;
9987   let Inst{30}    = Q;
9988   let Inst{29}    = U;
9989   let Inst{28-24} = 0b01110;
9990   let Inst{23-22} = size;
9991   let Inst{21}    = 0;
9992   let Inst{20-16} = Rm;
9993   let Inst{15-13} = opcode;
9994   // Non-tied version (FCADD) only has one rotation bit
9995   let Inst{12}    = rot;
9996   let Inst{11}    = 0;
9997   let Inst{10}    = 1;
9998   let Inst{9-5}   = Rn;
9999   let Inst{4-0}   = Rd;
10000 }
10001
10002 //8.3 CompNum - Floating-point complex number support
10003 multiclass SIMDThreeSameVectorComplexHSD<bit U, bits<3> opcode, Operand rottype,
10004                                           string asm, SDPatternOperator OpNode>{
10005   let Predicates = [HasComplxNum, HasNEON, HasFullFP16] in {
10006   def v4f16 : BaseSIMDThreeSameVectorComplex<0, U, 0b01, opcode, V64, rottype,
10007               asm, ".4h",
10008               [(set (v4f16 V64:$dst), (OpNode (v4f16 V64:$Rd),
10009                                               (v4f16 V64:$Rn),
10010                                               (v4f16 V64:$Rm),
10011                                               (rottype i32:$rot)))]>;
10012
10013   def v8f16 : BaseSIMDThreeSameVectorComplex<1, U, 0b01, opcode, V128, rottype,
10014               asm, ".8h",
10015               [(set (v8f16 V128:$dst), (OpNode (v8f16 V128:$Rd),
10016                                                (v8f16 V128:$Rn),
10017                                                (v8f16 V128:$Rm),
10018                                                (rottype i32:$rot)))]>;
10019   }
10020
10021   let Predicates = [HasComplxNum, HasNEON] in {
10022   def v2f32 : BaseSIMDThreeSameVectorComplex<0, U, 0b10, opcode, V64, rottype,
10023               asm, ".2s",
10024               [(set (v2f32 V64:$dst), (OpNode (v2f32 V64:$Rd),
10025                                               (v2f32 V64:$Rn),
10026                                               (v2f32 V64:$Rm),
10027                                               (rottype i32:$rot)))]>;
10028
10029   def v4f32 : BaseSIMDThreeSameVectorComplex<1, U, 0b10, opcode, V128, rottype,
10030               asm, ".4s",
10031               [(set (v4f32 V128:$dst), (OpNode (v4f32 V128:$Rd),
10032                                                (v4f32 V128:$Rn),
10033                                                (v4f32 V128:$Rm),
10034                                                (rottype i32:$rot)))]>;
10035
10036   def v2f64 : BaseSIMDThreeSameVectorComplex<1, U, 0b11, opcode, V128, rottype,
10037               asm, ".2d",
10038               [(set (v2f64 V128:$dst), (OpNode (v2f64 V128:$Rd),
10039                                                (v2f64 V128:$Rn),
10040                                                (v2f64 V128:$Rm),
10041                                                (rottype i32:$rot)))]>;
10042   }
10043 }
10044
10045 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
10046 class BaseSIMDThreeSameVectorTiedComplex<bit Q, bit U, bits<2> size,
10047                                          bits<3> opcode,
10048                                          RegisterOperand regtype,
10049                                          Operand rottype, string asm,
10050                                          string kind, list<dag> pattern>
10051   : I<(outs regtype:$dst),
10052       (ins regtype:$Rd, regtype:$Rn, regtype:$Rm, rottype:$rot), asm,
10053       "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind # ", $rot"
10054       "|" # kind # "\t$Rd, $Rn, $Rm, $rot}", "$Rd = $dst", pattern>,
10055     Sched<[WriteV]> {
10056   bits<5> Rd;
10057   bits<5> Rn;
10058   bits<5> Rm;
10059   bits<2> rot;
10060   let Inst{31}    = 0;
10061   let Inst{30}    = Q;
10062   let Inst{29}    = U;
10063   let Inst{28-24} = 0b01110;
10064   let Inst{23-22} = size;
10065   let Inst{21}    = 0;
10066   let Inst{20-16} = Rm;
10067   let Inst{15-13} = opcode;
10068   let Inst{12-11} = rot;
10069   let Inst{10}    = 1;
10070   let Inst{9-5}   = Rn;
10071   let Inst{4-0}   = Rd;
10072 }
10073
10074 multiclass SIMDThreeSameVectorTiedComplexHSD<bit U, bits<3> opcode,
10075                                              Operand rottype, string asm,
10076                                              SDPatternOperator OpNode> {
10077   let Predicates = [HasComplxNum, HasNEON, HasFullFP16] in {
10078   def v4f16 : BaseSIMDThreeSameVectorTiedComplex<0, U, 0b01, opcode, V64,
10079               rottype, asm, ".4h",
10080               [(set (v4f16 V64:$dst), (OpNode (v4f16 V64:$Rd),
10081                                               (v4f16 V64:$Rn),
10082                                               (v4f16 V64:$Rm),
10083                                               (rottype i32:$rot)))]>;
10084
10085   def v8f16 : BaseSIMDThreeSameVectorTiedComplex<1, U, 0b01, opcode, V128,
10086               rottype, asm, ".8h",
10087               [(set (v8f16 V128:$dst), (OpNode (v8f16 V128:$Rd),
10088                                                (v8f16 V128:$Rn),
10089                                                (v8f16 V128:$Rm),
10090                                                (rottype i32:$rot)))]>;
10091   }
10092
10093   let Predicates = [HasComplxNum, HasNEON] in {
10094   def v2f32 : BaseSIMDThreeSameVectorTiedComplex<0, U, 0b10, opcode, V64,
10095               rottype, asm, ".2s",
10096               [(set (v2f32 V64:$dst), (OpNode (v2f32 V64:$Rd),
10097                                               (v2f32 V64:$Rn),
10098                                               (v2f32 V64:$Rm),
10099                                               (rottype i32:$rot)))]>;
10100
10101   def v4f32 : BaseSIMDThreeSameVectorTiedComplex<1, U, 0b10, opcode, V128,
10102               rottype, asm, ".4s",
10103               [(set (v4f32 V128:$dst), (OpNode (v4f32 V128:$Rd),
10104                                                (v4f32 V128:$Rn),
10105                                                (v4f32 V128:$Rm),
10106                                                (rottype i32:$rot)))]>;
10107
10108   def v2f64 : BaseSIMDThreeSameVectorTiedComplex<1, U, 0b11, opcode, V128,
10109               rottype, asm, ".2d",
10110               [(set (v2f64 V128:$dst), (OpNode (v2f64 V128:$Rd),
10111                                                (v2f64 V128:$Rn),
10112                                                (v2f64 V128:$Rm),
10113                                                (rottype i32:$rot)))]>;
10114   }
10115 }
10116
10117 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
10118 class BaseSIMDIndexedTiedComplex<bit Q, bit U, bit Scalar, bits<2> size,
10119                                  bit opc1, bit opc2, RegisterOperand dst_reg,
10120                                  RegisterOperand lhs_reg,
10121                                  RegisterOperand rhs_reg, Operand vec_idx,
10122                                  Operand rottype, string asm, string apple_kind,
10123                                  string dst_kind, string lhs_kind,
10124                                  string rhs_kind, list<dag> pattern>
10125   : I<(outs dst_reg:$dst),
10126       (ins dst_reg:$Rd, lhs_reg:$Rn, rhs_reg:$Rm, vec_idx:$idx, rottype:$rot),
10127       asm,
10128       "{\t$Rd" # dst_kind # ", $Rn" # lhs_kind # ", $Rm" # rhs_kind #
10129       "$idx, $rot" # "|" # apple_kind #
10130       "\t$Rd, $Rn, $Rm$idx, $rot}", "$Rd = $dst", pattern>,
10131     Sched<[WriteV]> {
10132   bits<5> Rd;
10133   bits<5> Rn;
10134   bits<5> Rm;
10135   bits<2> rot;
10136
10137   let Inst{31}    = 0;
10138   let Inst{30}    = Q;
10139   let Inst{29}    = U;
10140   let Inst{28}    = Scalar;
10141   let Inst{27-24} = 0b1111;
10142   let Inst{23-22} = size;
10143   // Bit 21 must be set by the derived class.
10144   let Inst{20-16} = Rm;
10145   let Inst{15}    = opc1;
10146   let Inst{14-13} = rot;
10147   let Inst{12}    = opc2;
10148   // Bit 11 must be set by the derived class.
10149   let Inst{10}    = 0;
10150   let Inst{9-5}   = Rn;
10151   let Inst{4-0}   = Rd;
10152 }
10153
10154 // The complex instructions index by pairs of elements, so the VectorIndexes
10155 // don't match the lane types, and the index bits are different to the other
10156 // classes.
10157 multiclass SIMDIndexedTiedComplexHSD<bit U, bit opc1, bit opc2, Operand rottype,
10158                                      string asm, SDPatternOperator OpNode> {
10159   let Predicates = [HasComplxNum, HasNEON, HasFullFP16] in {
10160   def v4f16_indexed : BaseSIMDIndexedTiedComplex<0, 1, 0, 0b01, opc1, opc2, V64,
10161                       V64, V128, VectorIndexD, rottype, asm, ".4h", ".4h",
10162                       ".4h", ".h", []> {
10163     bits<1> idx;
10164     let Inst{11} = 0;
10165     let Inst{21} = idx{0};
10166   }
10167
10168   def v8f16_indexed : BaseSIMDIndexedTiedComplex<1, 1, 0, 0b01, opc1, opc2,
10169                       V128, V128, V128, VectorIndexS, rottype, asm, ".8h",
10170                       ".8h", ".8h", ".h", []> {
10171     bits<2> idx;
10172     let Inst{11} = idx{1};
10173     let Inst{21} = idx{0};
10174   }
10175   } // Predicates = HasComplxNum, HasNEON, HasFullFP16]
10176
10177   let Predicates = [HasComplxNum, HasNEON] in {
10178   def v4f32_indexed : BaseSIMDIndexedTiedComplex<1, 1, 0, 0b10, opc1, opc2,
10179                       V128, V128, V128, VectorIndexD, rottype, asm, ".4s",
10180                       ".4s", ".4s", ".s", []> {
10181     bits<1> idx;
10182     let Inst{11} = idx{0};
10183     let Inst{21} = 0;
10184   }
10185   } // Predicates = [HasComplxNum, HasNEON]
10186 }
10187
10188 //----------------------------------------------------------------------------
10189 // Crypto extensions
10190 //----------------------------------------------------------------------------
10191
10192 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
10193 class AESBase<bits<4> opc, string asm, dag outs, dag ins, string cstr,
10194               list<dag> pat>
10195   : I<outs, ins, asm, "{\t$Rd.16b, $Rn.16b|.16b\t$Rd, $Rn}", cstr, pat>,
10196     Sched<[WriteV]>{
10197   bits<5> Rd;
10198   bits<5> Rn;
10199   let Inst{31-16} = 0b0100111000101000;
10200   let Inst{15-12} = opc;
10201   let Inst{11-10} = 0b10;
10202   let Inst{9-5}   = Rn;
10203   let Inst{4-0}   = Rd;
10204 }
10205
10206 class AESInst<bits<4> opc, string asm, Intrinsic OpNode>
10207   : AESBase<opc, asm, (outs V128:$Rd), (ins V128:$Rn), "",
10208             [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
10209
10210 class AESTiedInst<bits<4> opc, string asm, Intrinsic OpNode>
10211   : AESBase<opc, asm, (outs V128:$dst), (ins V128:$Rd, V128:$Rn),
10212             "$Rd = $dst",
10213             [(set (v16i8 V128:$dst),
10214                   (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn)))]>;
10215
10216 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
10217 class SHA3OpTiedInst<bits<3> opc, string asm, string dst_lhs_kind,
10218                      dag oops, dag iops, list<dag> pat>
10219   : I<oops, iops, asm,
10220       "{\t$Rd" # dst_lhs_kind # ", $Rn" # dst_lhs_kind # ", $Rm.4s" #
10221       "|.4s\t$Rd, $Rn, $Rm}", "$Rd = $dst", pat>,
10222     Sched<[WriteV]>{
10223   bits<5> Rd;
10224   bits<5> Rn;
10225   bits<5> Rm;
10226   let Inst{31-21} = 0b01011110000;
10227   let Inst{20-16} = Rm;
10228   let Inst{15}    = 0;
10229   let Inst{14-12} = opc;
10230   let Inst{11-10} = 0b00;
10231   let Inst{9-5}   = Rn;
10232   let Inst{4-0}   = Rd;
10233 }
10234
10235 class SHATiedInstQSV<bits<3> opc, string asm, Intrinsic OpNode>
10236   : SHA3OpTiedInst<opc, asm, "", (outs FPR128:$dst),
10237                    (ins FPR128:$Rd, FPR32:$Rn, V128:$Rm),
10238                    [(set (v4i32 FPR128:$dst),
10239                          (OpNode (v4i32 FPR128:$Rd), (i32 FPR32:$Rn),
10240                                  (v4i32 V128:$Rm)))]>;
10241
10242 class SHATiedInstVVV<bits<3> opc, string asm, Intrinsic OpNode>
10243   : SHA3OpTiedInst<opc, asm, ".4s", (outs V128:$dst),
10244                    (ins V128:$Rd, V128:$Rn, V128:$Rm),
10245                    [(set (v4i32 V128:$dst),
10246                          (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
10247                                  (v4i32 V128:$Rm)))]>;
10248
10249 class SHATiedInstQQV<bits<3> opc, string asm, Intrinsic OpNode>
10250   : SHA3OpTiedInst<opc, asm, "", (outs FPR128:$dst),
10251                    (ins FPR128:$Rd, FPR128:$Rn, V128:$Rm),
10252                    [(set (v4i32 FPR128:$dst),
10253                          (OpNode (v4i32 FPR128:$Rd), (v4i32 FPR128:$Rn),
10254                                  (v4i32 V128:$Rm)))]>;
10255
10256 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
10257 class SHA2OpInst<bits<4> opc, string asm, string kind,
10258                  string cstr, dag oops, dag iops,
10259                  list<dag> pat>
10260   : I<oops, iops, asm, "{\t$Rd" # kind # ", $Rn" # kind #
10261                        "|" # kind # "\t$Rd, $Rn}", cstr, pat>,
10262     Sched<[WriteV]>{
10263   bits<5> Rd;
10264   bits<5> Rn;
10265   let Inst{31-16} = 0b0101111000101000;
10266   let Inst{15-12} = opc;
10267   let Inst{11-10} = 0b10;
10268   let Inst{9-5}   = Rn;
10269   let Inst{4-0}   = Rd;
10270 }
10271
10272 class SHATiedInstVV<bits<4> opc, string asm, Intrinsic OpNode>
10273   : SHA2OpInst<opc, asm, ".4s", "$Rd = $dst", (outs V128:$dst),
10274                (ins V128:$Rd, V128:$Rn),
10275                [(set (v4i32 V128:$dst),
10276                      (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn)))]>;
10277
10278 class SHAInstSS<bits<4> opc, string asm, Intrinsic OpNode>
10279   : SHA2OpInst<opc, asm, "", "", (outs FPR32:$Rd), (ins FPR32:$Rn),
10280                [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn)))]>;
10281
10282 // Armv8.2-A Crypto extensions
10283 class BaseCryptoV82<dag oops, dag iops, string asm, string asmops, string cst,
10284                     list<dag> pattern>
10285   : I <oops, iops, asm, asmops, cst, pattern>, Sched<[WriteV]> {
10286   bits<5> Vd;
10287   bits<5> Vn;
10288   let Inst{31-25} = 0b1100111;
10289   let Inst{9-5}   = Vn;
10290   let Inst{4-0}   = Vd;
10291 }
10292
10293 class CryptoRRTied<bits<1>op0, bits<2>op1, string asm, string asmops>
10294   : BaseCryptoV82<(outs V128:$Vd), (ins V128:$Vn, V128:$Vm), asm, asmops,
10295                   "$Vm = $Vd", []> {
10296   let Inst{31-25} = 0b1100111;
10297   let Inst{24-21} = 0b0110;
10298   let Inst{20-15} = 0b000001;
10299   let Inst{14}    = op0;
10300   let Inst{13-12} = 0b00;
10301   let Inst{11-10} = op1;
10302 }
10303 class CryptoRRTied_2D<bits<1>op0, bits<2>op1, string asm>
10304   : CryptoRRTied<op0, op1, asm, "{\t$Vd.2d, $Vn.2d}">;
10305 class CryptoRRTied_4S<bits<1>op0, bits<2>op1, string asm>
10306   : CryptoRRTied<op0, op1, asm, "{\t$Vd.4s, $Vn.4s}">;
10307
10308 class CryptoRRR<bits<1> op0, bits<2>op1, dag oops, dag iops, string asm,
10309                 string asmops, string cst>
10310   : BaseCryptoV82<oops, iops, asm , asmops, cst, []> {
10311   bits<5> Vm;
10312   let Inst{24-21} = 0b0011;
10313   let Inst{20-16} = Vm;
10314   let Inst{15}    = 0b1;
10315   let Inst{14}    = op0;
10316   let Inst{13-12} = 0b00;
10317   let Inst{11-10} = op1;
10318 }
10319 class CryptoRRR_2D<bits<1> op0, bits<2>op1, string asm>
10320   : CryptoRRR<op0, op1, (outs V128:$Vd), (ins V128:$Vn, V128:$Vm), asm,
10321               "{\t$Vd.2d, $Vn.2d, $Vm.2d}", "">;
10322 class CryptoRRRTied_2D<bits<1> op0, bits<2>op1, string asm>
10323   : CryptoRRR<op0, op1, (outs V128:$Vdst), (ins V128:$Vd, V128:$Vn, V128:$Vm), asm,
10324               "{\t$Vd.2d, $Vn.2d, $Vm.2d}", "$Vd = $Vdst">;
10325 class CryptoRRR_4S<bits<1> op0, bits<2>op1, string asm>
10326   : CryptoRRR<op0, op1, (outs V128:$Vd), (ins V128:$Vn, V128:$Vm), asm,
10327               "{\t$Vd.4s, $Vn.4s, $Vm.4s}", "">;
10328 class CryptoRRRTied_4S<bits<1> op0, bits<2>op1, string asm>
10329   : CryptoRRR<op0, op1, (outs V128:$Vdst), (ins V128:$Vd, V128:$Vn, V128:$Vm), asm,
10330               "{\t$Vd.4s, $Vn.4s, $Vm.4s}", "$Vd = $Vdst">;
10331 class CryptoRRRTied<bits<1> op0, bits<2>op1, string asm>
10332   : CryptoRRR<op0, op1, (outs FPR128:$Vdst), (ins FPR128:$Vd, FPR128:$Vn, V128:$Vm),
10333               asm, "{\t$Vd, $Vn, $Vm.2d}", "$Vd = $Vdst">;
10334
10335 class CryptoRRRR<bits<2>op0, string asm, string asmops>
10336   : BaseCryptoV82<(outs V128:$Vd), (ins V128:$Vn, V128:$Vm, V128:$Va), asm,
10337                   asmops, "", []> {
10338   bits<5> Vm;
10339   bits<5> Va;
10340   let Inst{24-23} = 0b00;
10341   let Inst{22-21} = op0;
10342   let Inst{20-16} = Vm;
10343   let Inst{15}    = 0b0;
10344   let Inst{14-10} = Va;
10345 }
10346 class CryptoRRRR_16B<bits<2>op0, string asm>
10347  : CryptoRRRR<op0, asm, "{\t$Vd.16b, $Vn.16b, $Vm.16b, $Va.16b}"> {
10348 }
10349 class CryptoRRRR_4S<bits<2>op0, string asm>
10350  : CryptoRRRR<op0, asm, "{\t$Vd.4s, $Vn.4s, $Vm.4s, $Va.4s}"> {
10351 }
10352
10353 class CryptoRRRi6<string asm>
10354   : BaseCryptoV82<(outs V128:$Vd), (ins V128:$Vn, V128:$Vm, uimm6:$imm), asm,
10355                   "{\t$Vd.2d, $Vn.2d, $Vm.2d, $imm}", "", []> {
10356   bits<6> imm;
10357   bits<5> Vm;
10358   let Inst{24-21} = 0b0100;
10359   let Inst{20-16} = Vm;
10360   let Inst{15-10} = imm;
10361   let Inst{9-5}   = Vn;
10362   let Inst{4-0}   = Vd;
10363 }
10364
10365 class CryptoRRRi2Tied<bits<1>op0, bits<2>op1, string asm>
10366   : BaseCryptoV82<(outs V128:$Vdst),
10367                   (ins V128:$Vd, V128:$Vn, V128:$Vm, VectorIndexS:$imm),
10368                   asm, "{\t$Vd.4s, $Vn.4s, $Vm.s$imm}", "$Vd = $Vdst", []> {
10369   bits<2> imm;
10370   bits<5> Vm;
10371   let Inst{24-21} = 0b0010;
10372   let Inst{20-16} = Vm;
10373   let Inst{15}    = 0b1;
10374   let Inst{14}    = op0;
10375   let Inst{13-12} = imm;
10376   let Inst{11-10} = op1;
10377 }
10378
10379 //----------------------------------------------------------------------------
10380 // v8.1 atomic instructions extension:
10381 // * CAS
10382 // * CASP
10383 // * SWP
10384 // * LDOPregister<OP>, and aliases STOPregister<OP>
10385
10386 // Instruction encodings:
10387 //
10388 //      31 30|29  24|23|22|21|20 16|15|14  10|9 5|4 0
10389 // CAS  SZ   |001000|1 |A |1 |Rs   |R |11111 |Rn |Rt
10390 // CASP  0|SZ|001000|0 |A |1 |Rs   |R |11111 |Rn |Rt
10391 // SWP  SZ   |111000|A |R |1 |Rs   |1 |OPC|00|Rn |Rt
10392 // LD   SZ   |111000|A |R |1 |Rs   |0 |OPC|00|Rn |Rt
10393 // ST   SZ   |111000|A |R |1 |Rs   |0 |OPC|00|Rn |11111
10394
10395 // Instruction syntax:
10396 //
10397 // CAS{<order>}[<size>] <Ws>, <Wt>, [<Xn|SP>]
10398 // CAS{<order>} <Xs>, <Xt>, [<Xn|SP>]
10399 // CASP{<order>} <Ws>, <W(s+1)>, <Wt>, <W(t+1)>, [<Xn|SP>]
10400 // CASP{<order>} <Xs>, <X(s+1)>, <Xt>, <X(t+1)>, [<Xn|SP>]
10401 // SWP{<order>}[<size>] <Ws>, <Wt>, [<Xn|SP>]
10402 // SWP{<order>} <Xs>, <Xt>, [<Xn|SP>]
10403 // LD<OP>{<order>}[<size>] <Ws>, <Wt>, [<Xn|SP>]
10404 // LD<OP>{<order>} <Xs>, <Xt>, [<Xn|SP>]
10405 // ST<OP>{<order>}[<size>] <Ws>, [<Xn|SP>]
10406 // ST<OP>{<order>} <Xs>, [<Xn|SP>]
10407
10408 let Predicates = [HasLSE], mayLoad = 1, mayStore = 1, hasSideEffects = 1 in
10409 class BaseCASEncoding<dag oops, dag iops, string asm, string operands,
10410                       string cstr, list<dag> pattern>
10411       : I<oops, iops, asm, operands, cstr, pattern> {
10412   bits<2> Sz;
10413   bit NP;
10414   bit Acq;
10415   bit Rel;
10416   bits<5> Rs;
10417   bits<5> Rn;
10418   bits<5> Rt;
10419   let Inst{31-30} = Sz;
10420   let Inst{29-24} = 0b001000;
10421   let Inst{23} = NP;
10422   let Inst{22} = Acq;
10423   let Inst{21} = 0b1;
10424   let Inst{20-16} = Rs;
10425   let Inst{15} = Rel;
10426   let Inst{14-10} = 0b11111;
10427   let Inst{9-5} = Rn;
10428   let Inst{4-0} = Rt;
10429   let Predicates = [HasLSE];
10430 }
10431
10432 class BaseCAS<string order, string size, RegisterClass RC>
10433       : BaseCASEncoding<(outs RC:$out),(ins RC:$Rs, RC:$Rt, GPR64sp:$Rn),
10434                         "cas" # order # size, "\t$Rs, $Rt, [$Rn]",
10435                         "$out = $Rs",[]>,
10436         Sched<[WriteAtomic]> {
10437   let NP = 1;
10438 }
10439
10440 multiclass CompareAndSwap<bits<1> Acq, bits<1> Rel, string order> {
10441   let Sz = 0b00, Acq = Acq, Rel = Rel in def B : BaseCAS<order, "b", GPR32>;
10442   let Sz = 0b01, Acq = Acq, Rel = Rel in def H : BaseCAS<order, "h", GPR32>;
10443   let Sz = 0b10, Acq = Acq, Rel = Rel in def W : BaseCAS<order, "", GPR32>;
10444   let Sz = 0b11, Acq = Acq, Rel = Rel in def X : BaseCAS<order, "", GPR64>;
10445 }
10446
10447 class BaseCASP<string order, string size, RegisterOperand RC>
10448       : BaseCASEncoding<(outs RC:$out),(ins RC:$Rs, RC:$Rt, GPR64sp:$Rn),
10449                         "casp" # order # size, "\t$Rs, $Rt, [$Rn]",
10450                         "$out = $Rs",[]>,
10451         Sched<[WriteAtomic]> {
10452   let NP = 0;
10453 }
10454
10455 multiclass CompareAndSwapPair<bits<1> Acq, bits<1> Rel, string order> {
10456   let Sz = 0b00, Acq = Acq, Rel = Rel in
10457     def W : BaseCASP<order, "", WSeqPairClassOperand>;
10458   let Sz = 0b01, Acq = Acq, Rel = Rel in
10459     def X : BaseCASP<order, "", XSeqPairClassOperand>;
10460 }
10461
10462 let Predicates = [HasLSE] in
10463 class BaseSWP<string order, string size, RegisterClass RC>
10464       : I<(outs RC:$Rt),(ins RC:$Rs, GPR64sp:$Rn), "swp" # order # size,
10465           "\t$Rs, $Rt, [$Rn]","",[]>,
10466         Sched<[WriteAtomic]> {
10467   bits<2> Sz;
10468   bit Acq;
10469   bit Rel;
10470   bits<5> Rs;
10471   bits<3> opc = 0b000;
10472   bits<5> Rn;
10473   bits<5> Rt;
10474   let Inst{31-30} = Sz;
10475   let Inst{29-24} = 0b111000;
10476   let Inst{23} = Acq;
10477   let Inst{22} = Rel;
10478   let Inst{21} = 0b1;
10479   let Inst{20-16} = Rs;
10480   let Inst{15} = 0b1;
10481   let Inst{14-12} = opc;
10482   let Inst{11-10} = 0b00;
10483   let Inst{9-5} = Rn;
10484   let Inst{4-0} = Rt;
10485   let Predicates = [HasLSE];
10486 }
10487
10488 multiclass Swap<bits<1> Acq, bits<1> Rel, string order> {
10489   let Sz = 0b00, Acq = Acq, Rel = Rel in def B : BaseSWP<order, "b", GPR32>;
10490   let Sz = 0b01, Acq = Acq, Rel = Rel in def H : BaseSWP<order, "h", GPR32>;
10491   let Sz = 0b10, Acq = Acq, Rel = Rel in def W : BaseSWP<order, "", GPR32>;
10492   let Sz = 0b11, Acq = Acq, Rel = Rel in def X : BaseSWP<order, "", GPR64>;
10493 }
10494
10495 let Predicates = [HasLSE], mayLoad = 1, mayStore = 1, hasSideEffects = 1 in
10496 class BaseLDOPregister<string op, string order, string size, RegisterClass RC>
10497       : I<(outs RC:$Rt),(ins RC:$Rs, GPR64sp:$Rn), "ld" # op # order # size,
10498           "\t$Rs, $Rt, [$Rn]","",[]>,
10499         Sched<[WriteAtomic]> {
10500   bits<2> Sz;
10501   bit Acq;
10502   bit Rel;
10503   bits<5> Rs;
10504   bits<3> opc;
10505   bits<5> Rn;
10506   bits<5> Rt;
10507   let Inst{31-30} = Sz;
10508   let Inst{29-24} = 0b111000;
10509   let Inst{23} = Acq;
10510   let Inst{22} = Rel;
10511   let Inst{21} = 0b1;
10512   let Inst{20-16} = Rs;
10513   let Inst{15} = 0b0;
10514   let Inst{14-12} = opc;
10515   let Inst{11-10} = 0b00;
10516   let Inst{9-5} = Rn;
10517   let Inst{4-0} = Rt;
10518   let Predicates = [HasLSE];
10519 }
10520
10521 multiclass LDOPregister<bits<3> opc, string op, bits<1> Acq, bits<1> Rel,
10522                         string order> {
10523   let Sz = 0b00, Acq = Acq, Rel = Rel, opc = opc in
10524     def B : BaseLDOPregister<op, order, "b", GPR32>;
10525   let Sz = 0b01, Acq = Acq, Rel = Rel, opc = opc in
10526     def H : BaseLDOPregister<op, order, "h", GPR32>;
10527   let Sz = 0b10, Acq = Acq, Rel = Rel, opc = opc in
10528     def W : BaseLDOPregister<op, order, "", GPR32>;
10529   let Sz = 0b11, Acq = Acq, Rel = Rel, opc = opc in
10530     def X : BaseLDOPregister<op, order, "", GPR64>;
10531 }
10532
10533 // Differing SrcRHS and DstRHS allow you to cover CLR & SUB by giving a more
10534 // complex DAG for DstRHS.
10535 let Predicates = [HasLSE] in
10536 multiclass LDOPregister_patterns_ord_dag<string inst, string suffix, string op,
10537                                          string size, dag SrcRHS, dag DstRHS> {
10538   def : Pat<(!cast<PatFrag>(op#"_"#size#"_monotonic") GPR64sp:$Rn, SrcRHS),
10539             (!cast<Instruction>(inst # suffix) DstRHS, GPR64sp:$Rn)>;
10540   def : Pat<(!cast<PatFrag>(op#"_"#size#"_acquire") GPR64sp:$Rn, SrcRHS),
10541             (!cast<Instruction>(inst # "A" # suffix) DstRHS, GPR64sp:$Rn)>;
10542   def : Pat<(!cast<PatFrag>(op#"_"#size#"_release") GPR64sp:$Rn, SrcRHS),
10543             (!cast<Instruction>(inst # "L" # suffix) DstRHS, GPR64sp:$Rn)>;
10544   def : Pat<(!cast<PatFrag>(op#"_"#size#"_acq_rel") GPR64sp:$Rn, SrcRHS),
10545             (!cast<Instruction>(inst # "AL" # suffix) DstRHS, GPR64sp:$Rn)>;
10546   def : Pat<(!cast<PatFrag>(op#"_"#size#"_seq_cst") GPR64sp:$Rn, SrcRHS),
10547             (!cast<Instruction>(inst # "AL" # suffix) DstRHS, GPR64sp:$Rn)>;
10548 }
10549
10550 multiclass LDOPregister_patterns_ord<string inst, string suffix, string op,
10551                                      string size, dag RHS> {
10552   defm : LDOPregister_patterns_ord_dag<inst, suffix, op, size, RHS, RHS>;
10553 }
10554
10555 multiclass LDOPregister_patterns_ord_mod<string inst, string suffix, string op,
10556                                          string size, dag LHS, dag RHS> {
10557   defm : LDOPregister_patterns_ord_dag<inst, suffix, op, size, LHS, RHS>;
10558 }
10559
10560 multiclass LDOPregister_patterns<string inst, string op> {
10561   defm : LDOPregister_patterns_ord<inst, "X", op, "64", (i64 GPR64:$Rm)>;
10562   defm : LDOPregister_patterns_ord<inst, "W", op, "32", (i32 GPR32:$Rm)>;
10563   defm : LDOPregister_patterns_ord<inst, "H", op, "16", (i32 GPR32:$Rm)>;
10564   defm : LDOPregister_patterns_ord<inst, "B", op, "8",  (i32 GPR32:$Rm)>;
10565 }
10566
10567 multiclass LDOPregister_patterns_mod<string inst, string op, string mod> {
10568   defm : LDOPregister_patterns_ord_mod<inst, "X", op, "64",
10569                         (i64 GPR64:$Rm),
10570                         (i64 (!cast<Instruction>(mod#Xrr) XZR, GPR64:$Rm))>;
10571   defm : LDOPregister_patterns_ord_mod<inst, "W", op, "32",
10572                         (i32 GPR32:$Rm),
10573                         (i32 (!cast<Instruction>(mod#Wrr) WZR, GPR32:$Rm))>;
10574   defm : LDOPregister_patterns_ord_mod<inst, "H", op, "16",
10575                         (i32 GPR32:$Rm),
10576                         (i32 (!cast<Instruction>(mod#Wrr) WZR, GPR32:$Rm))>;
10577   defm : LDOPregister_patterns_ord_mod<inst, "B", op, "8",
10578                         (i32 GPR32:$Rm),
10579                         (i32 (!cast<Instruction>(mod#Wrr) WZR, GPR32:$Rm))>;
10580 }
10581
10582 let Predicates = [HasLSE] in
10583 multiclass CASregister_patterns_ord_dag<string inst, string suffix, string op,
10584                                         string size, dag OLD, dag NEW> {
10585   def : Pat<(!cast<PatFrag>(op#"_"#size#"_monotonic") GPR64sp:$Rn, OLD, NEW),
10586             (!cast<Instruction>(inst # suffix) OLD, NEW, GPR64sp:$Rn)>;
10587   def : Pat<(!cast<PatFrag>(op#"_"#size#"_acquire") GPR64sp:$Rn, OLD, NEW),
10588             (!cast<Instruction>(inst # "A" # suffix) OLD, NEW, GPR64sp:$Rn)>;
10589   def : Pat<(!cast<PatFrag>(op#"_"#size#"_release") GPR64sp:$Rn, OLD, NEW),
10590             (!cast<Instruction>(inst # "L" # suffix) OLD, NEW, GPR64sp:$Rn)>;
10591   def : Pat<(!cast<PatFrag>(op#"_"#size#"_acq_rel") GPR64sp:$Rn, OLD, NEW),
10592             (!cast<Instruction>(inst # "AL" # suffix) OLD, NEW, GPR64sp:$Rn)>;
10593   def : Pat<(!cast<PatFrag>(op#"_"#size#"_seq_cst") GPR64sp:$Rn, OLD, NEW),
10594             (!cast<Instruction>(inst # "AL" # suffix) OLD, NEW, GPR64sp:$Rn)>;
10595 }
10596
10597 multiclass CASregister_patterns_ord<string inst, string suffix, string op,
10598                                     string size, dag OLD, dag NEW> {
10599   defm : CASregister_patterns_ord_dag<inst, suffix, op, size, OLD, NEW>;
10600 }
10601
10602 multiclass CASregister_patterns<string inst, string op> {
10603   defm : CASregister_patterns_ord<inst, "X", op, "64",
10604                         (i64 GPR64:$Rold), (i64 GPR64:$Rnew)>;
10605   defm : CASregister_patterns_ord<inst, "W", op, "32",
10606                         (i32 GPR32:$Rold), (i32 GPR32:$Rnew)>;
10607   defm : CASregister_patterns_ord<inst, "H", op, "16",
10608                         (i32 GPR32:$Rold), (i32 GPR32:$Rnew)>;
10609   defm : CASregister_patterns_ord<inst, "B", op, "8",
10610                         (i32 GPR32:$Rold), (i32 GPR32:$Rnew)>;
10611 }
10612
10613 let Predicates = [HasLSE] in
10614 class BaseSTOPregister<string asm, RegisterClass OP, Register Reg,
10615                         Instruction inst> :
10616       InstAlias<asm # "\t$Rs, [$Rn]", (inst Reg, OP:$Rs, GPR64sp:$Rn)>;
10617
10618 multiclass STOPregister<string asm, string instr> {
10619   def : BaseSTOPregister<asm # "lb", GPR32, WZR,
10620                     !cast<Instruction>(instr # "LB")>;
10621   def : BaseSTOPregister<asm # "lh", GPR32, WZR,
10622                     !cast<Instruction>(instr # "LH")>;
10623   def : BaseSTOPregister<asm # "l",  GPR32, WZR,
10624                     !cast<Instruction>(instr # "LW")>;
10625   def : BaseSTOPregister<asm # "l",  GPR64, XZR,
10626                     !cast<Instruction>(instr # "LX")>;
10627   def : BaseSTOPregister<asm # "b",  GPR32, WZR,
10628                     !cast<Instruction>(instr # "B")>;
10629   def : BaseSTOPregister<asm # "h",  GPR32, WZR,
10630                     !cast<Instruction>(instr # "H")>;
10631   def : BaseSTOPregister<asm,        GPR32, WZR,
10632                     !cast<Instruction>(instr # "W")>;
10633   def : BaseSTOPregister<asm,        GPR64, XZR,
10634                     !cast<Instruction>(instr # "X")>;
10635 }
10636
10637 //----------------------------------------------------------------------------
10638 // Allow the size specifier tokens to be upper case, not just lower.
10639 def : TokenAlias<".4B", ".4b">;  // Add dot product
10640 def : TokenAlias<".8B", ".8b">;
10641 def : TokenAlias<".4H", ".4h">;
10642 def : TokenAlias<".2S", ".2s">;
10643 def : TokenAlias<".1D", ".1d">;
10644 def : TokenAlias<".16B", ".16b">;
10645 def : TokenAlias<".8H", ".8h">;
10646 def : TokenAlias<".4S", ".4s">;
10647 def : TokenAlias<".2D", ".2d">;
10648 def : TokenAlias<".1Q", ".1q">;
10649 def : TokenAlias<".2H", ".2h">;
10650 def : TokenAlias<".B", ".b">;
10651 def : TokenAlias<".H", ".h">;
10652 def : TokenAlias<".S", ".s">;
10653 def : TokenAlias<".D", ".d">;
10654 def : TokenAlias<".Q", ".q">;