contrib/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

   1 //==- AArch64AsmParser.cpp - Parse AArch64 assembly to MCInst instructions -==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MCTargetDesc/AArch64AddressingModes.h"
  11 #include "MCTargetDesc/AArch64MCExpr.h"
  12 #include "MCTargetDesc/AArch64MCTargetDesc.h"
  13 #include "MCTargetDesc/AArch64TargetStreamer.h"
  14 #include "Utils/AArch64BaseInfo.h"
  15 #include "llvm/ADT/APFloat.h"
  16 #include "llvm/ADT/APInt.h"
  17 #include "llvm/ADT/ArrayRef.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/ADT/StringMap.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/ADT/StringSwitch.h"
  24 #include "llvm/ADT/Twine.h"
  25 #include "llvm/MC/MCContext.h"
  26 #include "llvm/MC/MCExpr.h"
  27 #include "llvm/MC/MCInst.h"
  28 #include "llvm/MC/MCLinkerOptimizationHint.h"
  29 #include "llvm/MC/MCObjectFileInfo.h"
  30 #include "llvm/MC/MCParser/MCAsmLexer.h"
  31 #include "llvm/MC/MCParser/MCAsmParser.h"
  32 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
  33 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  34 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
  35 #include "llvm/MC/MCRegisterInfo.h"
  36 #include "llvm/MC/MCStreamer.h"
  37 #include "llvm/MC/MCSubtargetInfo.h"
  38 #include "llvm/MC/MCSymbol.h"
  39 #include "llvm/MC/MCTargetOptions.h"
  40 #include "llvm/MC/SubtargetFeature.h"
  41 #include "llvm/Support/Casting.h"
  42 #include "llvm/Support/Compiler.h"
  43 #include "llvm/Support/ErrorHandling.h"
  44 #include "llvm/Support/MathExtras.h"
  45 #include "llvm/Support/SMLoc.h"
  46 #include "llvm/Support/TargetParser.h"
  47 #include "llvm/Support/TargetRegistry.h"
  48 #include "llvm/Support/raw_ostream.h"
  49 #include <cassert>
  50 #include <cctype>
  51 #include <cstdint>
  52 #include <cstdio>
  53 #include <string>
  54 #include <tuple>
  55 #include <utility>
  56 #include <vector>
  57
  58 using namespace llvm;
  59
  60 namespace {
  61
  62 class AArch64AsmParser : public MCTargetAsmParser {
  63 private:
  64   StringRef Mnemonic; ///< Instruction mnemonic.
  65
  66   // Map of register aliases registers via the .req directive.
  67   StringMap<std::pair<bool, unsigned>> RegisterReqs;
  68
  69   AArch64TargetStreamer &getTargetStreamer() {
  70     MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
  71     return static_cast<AArch64TargetStreamer &>(TS);
  72   }
  73
  74   SMLoc getLoc() const { return getParser().getTok().getLoc(); }
  75
  76   bool parseSysAlias(StringRef Name, SMLoc NameLoc, OperandVector &Operands);
  77   void createSysAlias(uint16_t Encoding, OperandVector &Operands, SMLoc S);
  78   AArch64CC::CondCode parseCondCodeString(StringRef Cond);
  79   bool parseCondCode(OperandVector &Operands, bool invertCondCode);
  80   unsigned matchRegisterNameAlias(StringRef Name, bool isVector);
  81   int tryParseRegister();
  82   int tryMatchVectorRegister(StringRef &Kind, bool expected);
  83   bool parseRegister(OperandVector &Operands);
  84   bool parseSymbolicImmVal(const MCExpr *&ImmVal);
  85   bool parseVectorList(OperandVector &Operands);
  86   bool parseOperand(OperandVector &Operands, bool isCondCode,
  87                     bool invertCondCode);
  88
  89   bool showMatchError(SMLoc Loc, unsigned ErrCode);
  90
  91   bool parseDirectiveArch(SMLoc L);
  92   bool parseDirectiveCPU(SMLoc L);
  93   bool parseDirectiveWord(unsigned Size, SMLoc L);
  94   bool parseDirectiveInst(SMLoc L);
  95
  96   bool parseDirectiveTLSDescCall(SMLoc L);
  97
  98   bool parseDirectiveLOH(StringRef LOH, SMLoc L);
  99   bool parseDirectiveLtorg(SMLoc L);
 100
 101   bool parseDirectiveReq(StringRef Name, SMLoc L);
 102   bool parseDirectiveUnreq(SMLoc L);
 103
 104   bool validateInstruction(MCInst &Inst, SmallVectorImpl<SMLoc> &Loc);
 105   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
 106                                OperandVector &Operands, MCStreamer &Out,
 107                                uint64_t &ErrorInfo,
 108                                bool MatchingInlineAsm) override;
 109 /// @name Auto-generated Match Functions
 110 /// {
 111
 112 #define GET_ASSEMBLER_HEADER
 113 #include "AArch64GenAsmMatcher.inc"
 114
 115   /// }
 116
 117   OperandMatchResultTy tryParseOptionalShiftExtend(OperandVector &Operands);
 118   OperandMatchResultTy tryParseBarrierOperand(OperandVector &Operands);
 119   OperandMatchResultTy tryParseMRSSystemRegister(OperandVector &Operands);
 120   OperandMatchResultTy tryParseSysReg(OperandVector &Operands);
 121   OperandMatchResultTy tryParseSysCROperand(OperandVector &Operands);
 122   OperandMatchResultTy tryParsePrefetch(OperandVector &Operands);
 123   OperandMatchResultTy tryParsePSBHint(OperandVector &Operands);
 124   OperandMatchResultTy tryParseAdrpLabel(OperandVector &Operands);
 125   OperandMatchResultTy tryParseAdrLabel(OperandVector &Operands);
 126   OperandMatchResultTy tryParseFPImm(OperandVector &Operands);
 127   OperandMatchResultTy tryParseAddSubImm(OperandVector &Operands);
 128   OperandMatchResultTy tryParseGPR64sp0Operand(OperandVector &Operands);
 129   bool tryParseVectorRegister(OperandVector &Operands);
 130   OperandMatchResultTy tryParseGPRSeqPair(OperandVector &Operands);
 131
 132 public:
 133   enum AArch64MatchResultTy {
 134     Match_InvalidSuffix = FIRST_TARGET_MATCH_RESULT_TY,
 135 #define GET_OPERAND_DIAGNOSTIC_TYPES
 136 #include "AArch64GenAsmMatcher.inc"
 137   };
 138   bool IsILP32;
 139
 140   AArch64AsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
 141                    const MCInstrInfo &MII, const MCTargetOptions &Options)
 142     : MCTargetAsmParser(Options, STI) {
 143     IsILP32 = Options.getABIName() == "ilp32";
 144     MCAsmParserExtension::Initialize(Parser);
 145     MCStreamer &S = getParser().getStreamer();
 146     if (S.getTargetStreamer() == nullptr)
 147       new AArch64TargetStreamer(S);
 148
 149     // Initialize the set of available features.
 150     setAvailableFeatures(ComputeAvailableFeatures(getSTI().getFeatureBits()));
 151   }
 152
 153   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 154                         SMLoc NameLoc, OperandVector &Operands) override;
 155   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
 156   bool ParseDirective(AsmToken DirectiveID) override;
 157   unsigned validateTargetOperandClass(MCParsedAsmOperand &Op,
 158                                       unsigned Kind) override;
 159
 160   static bool classifySymbolRef(const MCExpr *Expr,
 161                                 AArch64MCExpr::VariantKind &ELFRefKind,
 162                                 MCSymbolRefExpr::VariantKind &DarwinRefKind,
 163                                 int64_t &Addend);
 164 };
 165
 166 /// AArch64Operand - Instances of this class represent a parsed AArch64 machine
 167 /// instruction.
 168 class AArch64Operand : public MCParsedAsmOperand {
 169 private:
 170   enum KindTy {
 171     k_Immediate,
 172     k_ShiftedImm,
 173     k_CondCode,
 174     k_Register,
 175     k_VectorList,
 176     k_VectorIndex,
 177     k_Token,
 178     k_SysReg,
 179     k_SysCR,
 180     k_Prefetch,
 181     k_ShiftExtend,
 182     k_FPImm,
 183     k_Barrier,
 184     k_PSBHint,
 185   } Kind;
 186
 187   SMLoc StartLoc, EndLoc;
 188
 189   struct TokOp {
 190     const char *Data;
 191     unsigned Length;
 192     bool IsSuffix; // Is the operand actually a suffix on the mnemonic.
 193   };
 194
 195   struct RegOp {
 196     unsigned RegNum;
 197     bool isVector;
 198   };
 199
 200   struct VectorListOp {
 201     unsigned RegNum;
 202     unsigned Count;
 203     unsigned NumElements;
 204     unsigned ElementKind;
 205   };
 206
 207   struct VectorIndexOp {
 208     unsigned Val;
 209   };
 210
 211   struct ImmOp {
 212     const MCExpr *Val;
 213   };
 214
 215   struct ShiftedImmOp {
 216     const MCExpr *Val;
 217     unsigned ShiftAmount;
 218   };
 219
 220   struct CondCodeOp {
 221     AArch64CC::CondCode Code;
 222   };
 223
 224   struct FPImmOp {
 225     unsigned Val; // Encoded 8-bit representation.
 226   };
 227
 228   struct BarrierOp {
 229     const char *Data;
 230     unsigned Length;
 231     unsigned Val; // Not the enum since not all values have names.
 232   };
 233
 234   struct SysRegOp {
 235     const char *Data;
 236     unsigned Length;
 237     uint32_t MRSReg;
 238     uint32_t MSRReg;
 239     uint32_t PStateField;
 240   };
 241
 242   struct SysCRImmOp {
 243     unsigned Val;
 244   };
 245
 246   struct PrefetchOp {
 247     const char *Data;
 248     unsigned Length;
 249     unsigned Val;
 250   };
 251
 252   struct PSBHintOp {
 253     const char *Data;
 254     unsigned Length;
 255     unsigned Val;
 256   };
 257
 258   struct ShiftExtendOp {
 259     AArch64_AM::ShiftExtendType Type;
 260     unsigned Amount;
 261     bool HasExplicitAmount;
 262   };
 263
 264   struct ExtendOp {
 265     unsigned Val;
 266   };
 267
 268   union {
 269     struct TokOp Tok;
 270     struct RegOp Reg;
 271     struct VectorListOp VectorList;
 272     struct VectorIndexOp VectorIndex;
 273     struct ImmOp Imm;
 274     struct ShiftedImmOp ShiftedImm;
 275     struct CondCodeOp CondCode;
 276     struct FPImmOp FPImm;
 277     struct BarrierOp Barrier;
 278     struct SysRegOp SysReg;
 279     struct SysCRImmOp SysCRImm;
 280     struct PrefetchOp Prefetch;
 281     struct PSBHintOp PSBHint;
 282     struct ShiftExtendOp ShiftExtend;
 283   };
 284
 285   // Keep the MCContext around as the MCExprs may need manipulated during
 286   // the add<>Operands() calls.
 287   MCContext &Ctx;
 288
 289 public:
 290   AArch64Operand(KindTy K, MCContext &Ctx) : Kind(K), Ctx(Ctx) {}
 291
 292   AArch64Operand(const AArch64Operand &o) : MCParsedAsmOperand(), Ctx(o.Ctx) {
 293     Kind = o.Kind;
 294     StartLoc = o.StartLoc;
 295     EndLoc = o.EndLoc;
 296     switch (Kind) {
 297     case k_Token:
 298       Tok = o.Tok;
 299       break;
 300     case k_Immediate:
 301       Imm = o.Imm;
 302       break;
 303     case k_ShiftedImm:
 304       ShiftedImm = o.ShiftedImm;
 305       break;
 306     case k_CondCode:
 307       CondCode = o.CondCode;
 308       break;
 309     case k_FPImm:
 310       FPImm = o.FPImm;
 311       break;
 312     case k_Barrier:
 313       Barrier = o.Barrier;
 314       break;
 315     case k_Register:
 316       Reg = o.Reg;
 317       break;
 318     case k_VectorList:
 319       VectorList = o.VectorList;
 320       break;
 321     case k_VectorIndex:
 322       VectorIndex = o.VectorIndex;
 323       break;
 324     case k_SysReg:
 325       SysReg = o.SysReg;
 326       break;
 327     case k_SysCR:
 328       SysCRImm = o.SysCRImm;
 329       break;
 330     case k_Prefetch:
 331       Prefetch = o.Prefetch;
 332       break;
 333     case k_PSBHint:
 334       PSBHint = o.PSBHint;
 335       break;
 336     case k_ShiftExtend:
 337       ShiftExtend = o.ShiftExtend;
 338       break;
 339     }
 340   }
 341
 342   /// getStartLoc - Get the location of the first token of this operand.
 343   SMLoc getStartLoc() const override { return StartLoc; }
 344   /// getEndLoc - Get the location of the last token of this operand.
 345   SMLoc getEndLoc() const override { return EndLoc; }
 346
 347   StringRef getToken() const {
 348     assert(Kind == k_Token && "Invalid access!");
 349     return StringRef(Tok.Data, Tok.Length);
 350   }
 351
 352   bool isTokenSuffix() const {
 353     assert(Kind == k_Token && "Invalid access!");
 354     return Tok.IsSuffix;
 355   }
 356
 357   const MCExpr *getImm() const {
 358     assert(Kind == k_Immediate && "Invalid access!");
 359     return Imm.Val;
 360   }
 361
 362   const MCExpr *getShiftedImmVal() const {
 363     assert(Kind == k_ShiftedImm && "Invalid access!");
 364     return ShiftedImm.Val;
 365   }
 366
 367   unsigned getShiftedImmShift() const {
 368     assert(Kind == k_ShiftedImm && "Invalid access!");
 369     return ShiftedImm.ShiftAmount;
 370   }
 371
 372   AArch64CC::CondCode getCondCode() const {
 373     assert(Kind == k_CondCode && "Invalid access!");
 374     return CondCode.Code;
 375   }
 376
 377   unsigned getFPImm() const {
 378     assert(Kind == k_FPImm && "Invalid access!");
 379     return FPImm.Val;
 380   }
 381
 382   unsigned getBarrier() const {
 383     assert(Kind == k_Barrier && "Invalid access!");
 384     return Barrier.Val;
 385   }
 386
 387   StringRef getBarrierName() const {
 388     assert(Kind == k_Barrier && "Invalid access!");
 389     return StringRef(Barrier.Data, Barrier.Length);
 390   }
 391
 392   unsigned getReg() const override {
 393     assert(Kind == k_Register && "Invalid access!");
 394     return Reg.RegNum;
 395   }
 396
 397   unsigned getVectorListStart() const {
 398     assert(Kind == k_VectorList && "Invalid access!");
 399     return VectorList.RegNum;
 400   }
 401
 402   unsigned getVectorListCount() const {
 403     assert(Kind == k_VectorList && "Invalid access!");
 404     return VectorList.Count;
 405   }
 406
 407   unsigned getVectorIndex() const {
 408     assert(Kind == k_VectorIndex && "Invalid access!");
 409     return VectorIndex.Val;
 410   }
 411
 412   StringRef getSysReg() const {
 413     assert(Kind == k_SysReg && "Invalid access!");
 414     return StringRef(SysReg.Data, SysReg.Length);
 415   }
 416
 417   unsigned getSysCR() const {
 418     assert(Kind == k_SysCR && "Invalid access!");
 419     return SysCRImm.Val;
 420   }
 421
 422   unsigned getPrefetch() const {
 423     assert(Kind == k_Prefetch && "Invalid access!");
 424     return Prefetch.Val;
 425   }
 426
 427   unsigned getPSBHint() const {
 428     assert(Kind == k_PSBHint && "Invalid access!");
 429     return PSBHint.Val;
 430   }
 431
 432   StringRef getPSBHintName() const {
 433     assert(Kind == k_PSBHint && "Invalid access!");
 434     return StringRef(PSBHint.Data, PSBHint.Length);
 435   }
 436
 437   StringRef getPrefetchName() const {
 438     assert(Kind == k_Prefetch && "Invalid access!");
 439     return StringRef(Prefetch.Data, Prefetch.Length);
 440   }
 441
 442   AArch64_AM::ShiftExtendType getShiftExtendType() const {
 443     assert(Kind == k_ShiftExtend && "Invalid access!");
 444     return ShiftExtend.Type;
 445   }
 446
 447   unsigned getShiftExtendAmount() const {
 448     assert(Kind == k_ShiftExtend && "Invalid access!");
 449     return ShiftExtend.Amount;
 450   }
 451
 452   bool hasShiftExtendAmount() const {
 453     assert(Kind == k_ShiftExtend && "Invalid access!");
 454     return ShiftExtend.HasExplicitAmount;
 455   }
 456
 457   bool isImm() const override { return Kind == k_Immediate; }
 458   bool isMem() const override { return false; }
 459   bool isSImm9() const {
 460     if (!isImm())
 461       return false;
 462     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 463     if (!MCE)
 464       return false;
 465     int64_t Val = MCE->getValue();
 466     return (Val >= -256 && Val < 256);
 467   }
 468   bool isSImm7s4() const {
 469     if (!isImm())
 470       return false;
 471     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 472     if (!MCE)
 473       return false;
 474     int64_t Val = MCE->getValue();
 475     return (Val >= -256 && Val <= 252 && (Val & 3) == 0);
 476   }
 477   bool isSImm7s8() const {
 478     if (!isImm())
 479       return false;
 480     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 481     if (!MCE)
 482       return false;
 483     int64_t Val = MCE->getValue();
 484     return (Val >= -512 && Val <= 504 && (Val & 7) == 0);
 485   }
 486   bool isSImm7s16() const {
 487     if (!isImm())
 488       return false;
 489     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 490     if (!MCE)
 491       return false;
 492     int64_t Val = MCE->getValue();
 493     return (Val >= -1024 && Val <= 1008 && (Val & 15) == 0);
 494   }
 495
 496   bool isSymbolicUImm12Offset(const MCExpr *Expr, unsigned Scale) const {
 497     AArch64MCExpr::VariantKind ELFRefKind;
 498     MCSymbolRefExpr::VariantKind DarwinRefKind;
 499     int64_t Addend;
 500     if (!AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind, DarwinRefKind,
 501                                            Addend)) {
 502       // If we don't understand the expression, assume the best and
 503       // let the fixup and relocation code deal with it.
 504       return true;
 505     }
 506
 507     if (DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
 508         ELFRefKind == AArch64MCExpr::VK_LO12 ||
 509         ELFRefKind == AArch64MCExpr::VK_GOT_LO12 ||
 510         ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
 511         ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
 512         ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
 513         ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
 514         ELFRefKind == AArch64MCExpr::VK_GOTTPREL_LO12_NC ||
 515         ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12) {
 516       // Note that we don't range-check the addend. It's adjusted modulo page
 517       // size when converted, so there is no "out of range" condition when using
 518       // @pageoff.
 519       return Addend >= 0 && (Addend % Scale) == 0;
 520     } else if (DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF ||
 521                DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF) {
 522       // @gotpageoff/@tlvppageoff can only be used directly, not with an addend.
 523       return Addend == 0;
 524     }
 525
 526     return false;
 527   }
 528
 529   template <int Scale> bool isUImm12Offset() const {
 530     if (!isImm())
 531       return false;
 532
 533     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 534     if (!MCE)
 535       return isSymbolicUImm12Offset(getImm(), Scale);
 536
 537     int64_t Val = MCE->getValue();
 538     return (Val % Scale) == 0 && Val >= 0 && (Val / Scale) < 0x1000;
 539   }
 540
 541   template <int N, int M>
 542   bool isImmInRange() const {
 543     if (!isImm())
 544       return false;
 545     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 546     if (!MCE)
 547       return false;
 548     int64_t Val = MCE->getValue();
 549     return (Val >= N && Val <= M);
 550   }
 551
 552   bool isLogicalImm32() const {
 553     if (!isImm())
 554       return false;
 555     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 556     if (!MCE)
 557       return false;
 558     int64_t Val = MCE->getValue();
 559     if (Val >> 32 != 0 && Val >> 32 != ~0LL)
 560       return false;
 561     Val &= 0xFFFFFFFF;
 562     return AArch64_AM::isLogicalImmediate(Val, 32);
 563   }
 564
 565   bool isLogicalImm64() const {
 566     if (!isImm())
 567       return false;
 568     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 569     if (!MCE)
 570       return false;
 571     return AArch64_AM::isLogicalImmediate(MCE->getValue(), 64);
 572   }
 573
 574   bool isLogicalImm32Not() const {
 575     if (!isImm())
 576       return false;
 577     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 578     if (!MCE)
 579       return false;
 580     int64_t Val = ~MCE->getValue() & 0xFFFFFFFF;
 581     return AArch64_AM::isLogicalImmediate(Val, 32);
 582   }
 583
 584   bool isLogicalImm64Not() const {
 585     if (!isImm())
 586       return false;
 587     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 588     if (!MCE)
 589       return false;
 590     return AArch64_AM::isLogicalImmediate(~MCE->getValue(), 64);
 591   }
 592
 593   bool isShiftedImm() const { return Kind == k_ShiftedImm; }
 594
 595   bool isAddSubImm() const {
 596     if (!isShiftedImm() && !isImm())
 597       return false;
 598
 599     const MCExpr *Expr;
 600
 601     // An ADD/SUB shifter is either 'lsl #0' or 'lsl #12'.
 602     if (isShiftedImm()) {
 603       unsigned Shift = ShiftedImm.ShiftAmount;
 604       Expr = ShiftedImm.Val;
 605       if (Shift != 0 && Shift != 12)
 606         return false;
 607     } else {
 608       Expr = getImm();
 609     }
 610
 611     AArch64MCExpr::VariantKind ELFRefKind;
 612     MCSymbolRefExpr::VariantKind DarwinRefKind;
 613     int64_t Addend;
 614     if (AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind,
 615                                           DarwinRefKind, Addend)) {
 616       return DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF
 617           || DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF
 618           || (DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF && Addend == 0)
 619           || ELFRefKind == AArch64MCExpr::VK_LO12
 620           || ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12
 621           || ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12
 622           || ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC
 623           || ELFRefKind == AArch64MCExpr::VK_TPREL_HI12
 624           || ELFRefKind == AArch64MCExpr::VK_TPREL_LO12
 625           || ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC
 626           || ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12;
 627     }
 628
 629     // If it's a constant, it should be a real immediate in range:
 630     if (auto *CE = dyn_cast<MCConstantExpr>(Expr))
 631       return CE->getValue() >= 0 && CE->getValue() <= 0xfff;
 632
 633     // If it's an expression, we hope for the best and let the fixup/relocation
 634     // code deal with it.
 635     return true;
 636   }
 637
 638   bool isAddSubImmNeg() const {
 639     if (!isShiftedImm() && !isImm())
 640       return false;
 641
 642     const MCExpr *Expr;
 643
 644     // An ADD/SUB shifter is either 'lsl #0' or 'lsl #12'.
 645     if (isShiftedImm()) {
 646       unsigned Shift = ShiftedImm.ShiftAmount;
 647       Expr = ShiftedImm.Val;
 648       if (Shift != 0 && Shift != 12)
 649         return false;
 650     } else
 651       Expr = getImm();
 652
 653     // Otherwise it should be a real negative immediate in range:
 654     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr);
 655     return CE != nullptr && CE->getValue() < 0 && -CE->getValue() <= 0xfff;
 656   }
 657
 658   bool isCondCode() const { return Kind == k_CondCode; }
 659
 660   bool isSIMDImmType10() const {
 661     if (!isImm())
 662       return false;
 663     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 664     if (!MCE)
 665       return false;
 666     return AArch64_AM::isAdvSIMDModImmType10(MCE->getValue());
 667   }
 668
 669   template<int N>
 670   bool isBranchTarget() const {
 671     if (!isImm())
 672       return false;
 673     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
 674     if (!MCE)
 675       return true;
 676     int64_t Val = MCE->getValue();
 677     if (Val & 0x3)
 678       return false;
 679     assert(N > 0 && "Branch target immediate cannot be 0 bits!");
 680     return (Val >= -((1<<(N-1)) << 2) && Val <= (((1<<(N-1))-1) << 2));
 681   }
 682
 683   bool
 684   isMovWSymbol(ArrayRef<AArch64MCExpr::VariantKind> AllowedModifiers) const {
 685     if (!isImm())
 686       return false;
 687
 688     AArch64MCExpr::VariantKind ELFRefKind;
 689     MCSymbolRefExpr::VariantKind DarwinRefKind;
 690     int64_t Addend;
 691     if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFRefKind,
 692                                              DarwinRefKind, Addend)) {
 693       return false;
 694     }
 695     if (DarwinRefKind != MCSymbolRefExpr::VK_None)
 696       return false;
 697
 698     for (unsigned i = 0; i != AllowedModifiers.size(); ++i) {
 699       if (ELFRefKind == AllowedModifiers[i])
 700         return Addend == 0;
 701     }
 702
 703     return false;
 704   }
 705
 706   bool isMovZSymbolG3() const {
 707     return isMovWSymbol(AArch64MCExpr::VK_ABS_G3);
 708   }
 709
 710   bool isMovZSymbolG2() const {
 711     return isMovWSymbol({AArch64MCExpr::VK_ABS_G2, AArch64MCExpr::VK_ABS_G2_S,
 712                          AArch64MCExpr::VK_TPREL_G2,
 713                          AArch64MCExpr::VK_DTPREL_G2});
 714   }
 715
 716   bool isMovZSymbolG1() const {
 717     return isMovWSymbol({
 718         AArch64MCExpr::VK_ABS_G1, AArch64MCExpr::VK_ABS_G1_S,
 719         AArch64MCExpr::VK_GOTTPREL_G1, AArch64MCExpr::VK_TPREL_G1,
 720         AArch64MCExpr::VK_DTPREL_G1,
 721     });
 722   }
 723
 724   bool isMovZSymbolG0() const {
 725     return isMovWSymbol({AArch64MCExpr::VK_ABS_G0, AArch64MCExpr::VK_ABS_G0_S,
 726                          AArch64MCExpr::VK_TPREL_G0,
 727                          AArch64MCExpr::VK_DTPREL_G0});
 728   }
 729
 730   bool isMovKSymbolG3() const {
 731     return isMovWSymbol(AArch64MCExpr::VK_ABS_G3);
 732   }
 733
 734   bool isMovKSymbolG2() const {
 735     return isMovWSymbol(AArch64MCExpr::VK_ABS_G2_NC);
 736   }
 737
 738   bool isMovKSymbolG1() const {
 739     return isMovWSymbol({AArch64MCExpr::VK_ABS_G1_NC,
 740                          AArch64MCExpr::VK_TPREL_G1_NC,
 741                          AArch64MCExpr::VK_DTPREL_G1_NC});
 742   }
 743
 744   bool isMovKSymbolG0() const {
 745     return isMovWSymbol(
 746         {AArch64MCExpr::VK_ABS_G0_NC, AArch64MCExpr::VK_GOTTPREL_G0_NC,
 747          AArch64MCExpr::VK_TPREL_G0_NC, AArch64MCExpr::VK_DTPREL_G0_NC});
 748   }
 749
 750   template<int RegWidth, int Shift>
 751   bool isMOVZMovAlias() const {
 752     if (!isImm()) return false;
 753
 754     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 755     if (!CE) return false;
 756     uint64_t Value = CE->getValue();
 757
 758     return AArch64_AM::isMOVZMovAlias(Value, Shift, RegWidth);
 759   }
 760
 761   template<int RegWidth, int Shift>
 762   bool isMOVNMovAlias() const {
 763     if (!isImm()) return false;
 764
 765     const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(getImm());
 766     if (!CE) return false;
 767     uint64_t Value = CE->getValue();
 768
 769     return AArch64_AM::isMOVNMovAlias(Value, Shift, RegWidth);
 770   }
 771
 772   bool isFPImm() const { return Kind == k_FPImm; }
 773   bool isBarrier() const { return Kind == k_Barrier; }
 774   bool isSysReg() const { return Kind == k_SysReg; }
 775
 776   bool isMRSSystemRegister() const {
 777     if (!isSysReg()) return false;
 778
 779     return SysReg.MRSReg != -1U;
 780   }
 781
 782   bool isMSRSystemRegister() const {
 783     if (!isSysReg()) return false;
 784     return SysReg.MSRReg != -1U;
 785   }
 786
 787   bool isSystemPStateFieldWithImm0_1() const {
 788     if (!isSysReg()) return false;
 789     return (SysReg.PStateField == AArch64PState::PAN ||
 790             SysReg.PStateField == AArch64PState::UAO);
 791   }
 792
 793   bool isSystemPStateFieldWithImm0_15() const {
 794     if (!isSysReg() || isSystemPStateFieldWithImm0_1()) return false;
 795     return SysReg.PStateField != -1U;
 796   }
 797
 798   bool isReg() const override { return Kind == k_Register && !Reg.isVector; }
 799   bool isVectorReg() const { return Kind == k_Register && Reg.isVector; }
 800
 801   bool isVectorRegLo() const {
 802     return Kind == k_Register && Reg.isVector &&
 803            AArch64MCRegisterClasses[AArch64::FPR128_loRegClassID].contains(
 804                Reg.RegNum);
 805   }
 806
 807   bool isGPR32as64() const {
 808     return Kind == k_Register && !Reg.isVector &&
 809       AArch64MCRegisterClasses[AArch64::GPR64RegClassID].contains(Reg.RegNum);
 810   }
 811
 812   bool isWSeqPair() const {
 813     return Kind == k_Register && !Reg.isVector &&
 814            AArch64MCRegisterClasses[AArch64::WSeqPairsClassRegClassID].contains(
 815                Reg.RegNum);
 816   }
 817
 818   bool isXSeqPair() const {
 819     return Kind == k_Register && !Reg.isVector &&
 820            AArch64MCRegisterClasses[AArch64::XSeqPairsClassRegClassID].contains(
 821                Reg.RegNum);
 822   }
 823
 824   bool isGPR64sp0() const {
 825     return Kind == k_Register && !Reg.isVector &&
 826       AArch64MCRegisterClasses[AArch64::GPR64spRegClassID].contains(Reg.RegNum);
 827   }
 828
 829   /// Is this a vector list with the type implicit (presumably attached to the
 830   /// instruction itself)?
 831   template <unsigned NumRegs> bool isImplicitlyTypedVectorList() const {
 832     return Kind == k_VectorList && VectorList.Count == NumRegs &&
 833            !VectorList.ElementKind;
 834   }
 835
 836   template <unsigned NumRegs, unsigned NumElements, char ElementKind>
 837   bool isTypedVectorList() const {
 838     if (Kind != k_VectorList)
 839       return false;
 840     if (VectorList.Count != NumRegs)
 841       return false;
 842     if (VectorList.ElementKind != ElementKind)
 843       return false;
 844     return VectorList.NumElements == NumElements;
 845   }
 846
 847   bool isVectorIndex1() const {
 848     return Kind == k_VectorIndex && VectorIndex.Val == 1;
 849   }
 850
 851   bool isVectorIndexB() const {
 852     return Kind == k_VectorIndex && VectorIndex.Val < 16;
 853   }
 854
 855   bool isVectorIndexH() const {
 856     return Kind == k_VectorIndex && VectorIndex.Val < 8;
 857   }
 858
 859   bool isVectorIndexS() const {
 860     return Kind == k_VectorIndex && VectorIndex.Val < 4;
 861   }
 862
 863   bool isVectorIndexD() const {
 864     return Kind == k_VectorIndex && VectorIndex.Val < 2;
 865   }
 866
 867   bool isToken() const override { return Kind == k_Token; }
 868
 869   bool isTokenEqual(StringRef Str) const {
 870     return Kind == k_Token && getToken() == Str;
 871   }
 872   bool isSysCR() const { return Kind == k_SysCR; }
 873   bool isPrefetch() const { return Kind == k_Prefetch; }
 874   bool isPSBHint() const { return Kind == k_PSBHint; }
 875   bool isShiftExtend() const { return Kind == k_ShiftExtend; }
 876   bool isShifter() const {
 877     if (!isShiftExtend())
 878       return false;
 879
 880     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
 881     return (ST == AArch64_AM::LSL || ST == AArch64_AM::LSR ||
 882             ST == AArch64_AM::ASR || ST == AArch64_AM::ROR ||
 883             ST == AArch64_AM::MSL);
 884   }
 885   bool isExtend() const {
 886     if (!isShiftExtend())
 887       return false;
 888
 889     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
 890     return (ET == AArch64_AM::UXTB || ET == AArch64_AM::SXTB ||
 891             ET == AArch64_AM::UXTH || ET == AArch64_AM::SXTH ||
 892             ET == AArch64_AM::UXTW || ET == AArch64_AM::SXTW ||
 893             ET == AArch64_AM::UXTX || ET == AArch64_AM::SXTX ||
 894             ET == AArch64_AM::LSL) &&
 895            getShiftExtendAmount() <= 4;
 896   }
 897
 898   bool isExtend64() const {
 899     if (!isExtend())
 900       return false;
 901     // UXTX and SXTX require a 64-bit source register (the ExtendLSL64 class).
 902     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
 903     return ET != AArch64_AM::UXTX && ET != AArch64_AM::SXTX;
 904   }
 905
 906   bool isExtendLSL64() const {
 907     if (!isExtend())
 908       return false;
 909     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
 910     return (ET == AArch64_AM::UXTX || ET == AArch64_AM::SXTX ||
 911             ET == AArch64_AM::LSL) &&
 912            getShiftExtendAmount() <= 4;
 913   }
 914
 915   template<int Width> bool isMemXExtend() const {
 916     if (!isExtend())
 917       return false;
 918     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
 919     return (ET == AArch64_AM::LSL || ET == AArch64_AM::SXTX) &&
 920            (getShiftExtendAmount() == Log2_32(Width / 8) ||
 921             getShiftExtendAmount() == 0);
 922   }
 923
 924   template<int Width> bool isMemWExtend() const {
 925     if (!isExtend())
 926       return false;
 927     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
 928     return (ET == AArch64_AM::UXTW || ET == AArch64_AM::SXTW) &&
 929            (getShiftExtendAmount() == Log2_32(Width / 8) ||
 930             getShiftExtendAmount() == 0);
 931   }
 932
 933   template <unsigned width>
 934   bool isArithmeticShifter() const {
 935     if (!isShifter())
 936       return false;
 937
 938     // An arithmetic shifter is LSL, LSR, or ASR.
 939     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
 940     return (ST == AArch64_AM::LSL || ST == AArch64_AM::LSR ||
 941             ST == AArch64_AM::ASR) && getShiftExtendAmount() < width;
 942   }
 943
 944   template <unsigned width>
 945   bool isLogicalShifter() const {
 946     if (!isShifter())
 947       return false;
 948
 949     // A logical shifter is LSL, LSR, ASR or ROR.
 950     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
 951     return (ST == AArch64_AM::LSL || ST == AArch64_AM::LSR ||
 952             ST == AArch64_AM::ASR || ST == AArch64_AM::ROR) &&
 953            getShiftExtendAmount() < width;
 954   }
 955
 956   bool isMovImm32Shifter() const {
 957     if (!isShifter())
 958       return false;
 959
 960     // A MOVi shifter is LSL of 0, 16, 32, or 48.
 961     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
 962     if (ST != AArch64_AM::LSL)
 963       return false;
 964     uint64_t Val = getShiftExtendAmount();
 965     return (Val == 0 || Val == 16);
 966   }
 967
 968   bool isMovImm64Shifter() const {
 969     if (!isShifter())
 970       return false;
 971
 972     // A MOVi shifter is LSL of 0 or 16.
 973     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
 974     if (ST != AArch64_AM::LSL)
 975       return false;
 976     uint64_t Val = getShiftExtendAmount();
 977     return (Val == 0 || Val == 16 || Val == 32 || Val == 48);
 978   }
 979
 980   bool isLogicalVecShifter() const {
 981     if (!isShifter())
 982       return false;
 983
 984     // A logical vector shifter is a left shift by 0, 8, 16, or 24.
 985     unsigned Shift = getShiftExtendAmount();
 986     return getShiftExtendType() == AArch64_AM::LSL &&
 987            (Shift == 0 || Shift == 8 || Shift == 16 || Shift == 24);
 988   }
 989
 990   bool isLogicalVecHalfWordShifter() const {
 991     if (!isLogicalVecShifter())
 992       return false;
 993
 994     // A logical vector shifter is a left shift by 0 or 8.
 995     unsigned Shift = getShiftExtendAmount();
 996     return getShiftExtendType() == AArch64_AM::LSL &&
 997            (Shift == 0 || Shift == 8);
 998   }
 999
1000   bool isMoveVecShifter() const {
1001     if (!isShiftExtend())
1002       return false;
1003
1004     // A logical vector shifter is a left shift by 8 or 16.
1005     unsigned Shift = getShiftExtendAmount();
1006     return getShiftExtendType() == AArch64_AM::MSL &&
1007            (Shift == 8 || Shift == 16);
1008   }
1009
1010   // Fallback unscaled operands are for aliases of LDR/STR that fall back
1011   // to LDUR/STUR when the offset is not legal for the former but is for
1012   // the latter. As such, in addition to checking for being a legal unscaled
1013   // address, also check that it is not a legal scaled address. This avoids
1014   // ambiguity in the matcher.
1015   template<int Width>
1016   bool isSImm9OffsetFB() const {
1017     return isSImm9() && !isUImm12Offset<Width / 8>();
1018   }
1019
1020   bool isAdrpLabel() const {
1021     // Validation was handled during parsing, so we just sanity check that
1022     // something didn't go haywire.
1023     if (!isImm())
1024         return false;
1025
1026     if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Imm.Val)) {
1027       int64_t Val = CE->getValue();
1028       int64_t Min = - (4096 * (1LL << (21 - 1)));
1029       int64_t Max = 4096 * ((1LL << (21 - 1)) - 1);
1030       return (Val % 4096) == 0 && Val >= Min && Val <= Max;
1031     }
1032
1033     return true;
1034   }
1035
1036   bool isAdrLabel() const {
1037     // Validation was handled during parsing, so we just sanity check that
1038     // something didn't go haywire.
1039     if (!isImm())
1040         return false;
1041
1042     if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Imm.Val)) {
1043       int64_t Val = CE->getValue();
1044       int64_t Min = - (1LL << (21 - 1));
1045       int64_t Max = ((1LL << (21 - 1)) - 1);
1046       return Val >= Min && Val <= Max;
1047     }
1048
1049     return true;
1050   }
1051
1052   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
1053     // Add as immediates when possible.  Null MCExpr = 0.
1054     if (!Expr)
1055       Inst.addOperand(MCOperand::createImm(0));
1056     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
1057       Inst.addOperand(MCOperand::createImm(CE->getValue()));
1058     else
1059       Inst.addOperand(MCOperand::createExpr(Expr));
1060   }
1061
1062   void addRegOperands(MCInst &Inst, unsigned N) const {
1063     assert(N == 1 && "Invalid number of operands!");
1064     Inst.addOperand(MCOperand::createReg(getReg()));
1065   }
1066
1067   void addGPR32as64Operands(MCInst &Inst, unsigned N) const {
1068     assert(N == 1 && "Invalid number of operands!");
1069     assert(
1070         AArch64MCRegisterClasses[AArch64::GPR64RegClassID].contains(getReg()));
1071
1072     const MCRegisterInfo *RI = Ctx.getRegisterInfo();
1073     uint32_t Reg = RI->getRegClass(AArch64::GPR32RegClassID).getRegister(
1074         RI->getEncodingValue(getReg()));
1075
1076     Inst.addOperand(MCOperand::createReg(Reg));
1077   }
1078
1079   void addVectorReg64Operands(MCInst &Inst, unsigned N) const {
1080     assert(N == 1 && "Invalid number of operands!");
1081     assert(
1082         AArch64MCRegisterClasses[AArch64::FPR128RegClassID].contains(getReg()));
1083     Inst.addOperand(MCOperand::createReg(AArch64::D0 + getReg() - AArch64::Q0));
1084   }
1085
1086   void addVectorReg128Operands(MCInst &Inst, unsigned N) const {
1087     assert(N == 1 && "Invalid number of operands!");
1088     assert(
1089         AArch64MCRegisterClasses[AArch64::FPR128RegClassID].contains(getReg()));
1090     Inst.addOperand(MCOperand::createReg(getReg()));
1091   }
1092
1093   void addVectorRegLoOperands(MCInst &Inst, unsigned N) const {
1094     assert(N == 1 && "Invalid number of operands!");
1095     Inst.addOperand(MCOperand::createReg(getReg()));
1096   }
1097
1098   template <unsigned NumRegs>
1099   void addVectorList64Operands(MCInst &Inst, unsigned N) const {
1100     assert(N == 1 && "Invalid number of operands!");
1101     static const unsigned FirstRegs[] = { AArch64::D0,
1102                                           AArch64::D0_D1,
1103                                           AArch64::D0_D1_D2,
1104                                           AArch64::D0_D1_D2_D3 };
1105     unsigned FirstReg = FirstRegs[NumRegs - 1];
1106
1107     Inst.addOperand(
1108         MCOperand::createReg(FirstReg + getVectorListStart() - AArch64::Q0));
1109   }
1110
1111   template <unsigned NumRegs>
1112   void addVectorList128Operands(MCInst &Inst, unsigned N) const {
1113     assert(N == 1 && "Invalid number of operands!");
1114     static const unsigned FirstRegs[] = { AArch64::Q0,
1115                                           AArch64::Q0_Q1,
1116                                           AArch64::Q0_Q1_Q2,
1117                                           AArch64::Q0_Q1_Q2_Q3 };
1118     unsigned FirstReg = FirstRegs[NumRegs - 1];
1119
1120     Inst.addOperand(
1121         MCOperand::createReg(FirstReg + getVectorListStart() - AArch64::Q0));
1122   }
1123
1124   void addVectorIndex1Operands(MCInst &Inst, unsigned N) const {
1125     assert(N == 1 && "Invalid number of operands!");
1126     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
1127   }
1128
1129   void addVectorIndexBOperands(MCInst &Inst, unsigned N) const {
1130     assert(N == 1 && "Invalid number of operands!");
1131     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
1132   }
1133
1134   void addVectorIndexHOperands(MCInst &Inst, unsigned N) const {
1135     assert(N == 1 && "Invalid number of operands!");
1136     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
1137   }
1138
1139   void addVectorIndexSOperands(MCInst &Inst, unsigned N) const {
1140     assert(N == 1 && "Invalid number of operands!");
1141     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
1142   }
1143
1144   void addVectorIndexDOperands(MCInst &Inst, unsigned N) const {
1145     assert(N == 1 && "Invalid number of operands!");
1146     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
1147   }
1148
1149   void addImmOperands(MCInst &Inst, unsigned N) const {
1150     assert(N == 1 && "Invalid number of operands!");
1151     // If this is a pageoff symrefexpr with an addend, adjust the addend
1152     // to be only the page-offset portion. Otherwise, just add the expr
1153     // as-is.
1154     addExpr(Inst, getImm());
1155   }
1156
1157   void addAddSubImmOperands(MCInst &Inst, unsigned N) const {
1158     assert(N == 2 && "Invalid number of operands!");
1159     if (isShiftedImm()) {
1160       addExpr(Inst, getShiftedImmVal());
1161       Inst.addOperand(MCOperand::createImm(getShiftedImmShift()));
1162     } else {
1163       addExpr(Inst, getImm());
1164       Inst.addOperand(MCOperand::createImm(0));
1165     }
1166   }
1167
1168   void addAddSubImmNegOperands(MCInst &Inst, unsigned N) const {
1169     assert(N == 2 && "Invalid number of operands!");
1170
1171     const MCExpr *MCE = isShiftedImm() ? getShiftedImmVal() : getImm();
1172     const MCConstantExpr *CE = cast<MCConstantExpr>(MCE);
1173     int64_t Val = -CE->getValue();
1174     unsigned ShiftAmt = isShiftedImm() ? ShiftedImm.ShiftAmount : 0;
1175
1176     Inst.addOperand(MCOperand::createImm(Val));
1177     Inst.addOperand(MCOperand::createImm(ShiftAmt));
1178   }
1179
1180   void addCondCodeOperands(MCInst &Inst, unsigned N) const {
1181     assert(N == 1 && "Invalid number of operands!");
1182     Inst.addOperand(MCOperand::createImm(getCondCode()));
1183   }
1184
1185   void addAdrpLabelOperands(MCInst &Inst, unsigned N) const {
1186     assert(N == 1 && "Invalid number of operands!");
1187     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
1188     if (!MCE)
1189       addExpr(Inst, getImm());
1190     else
1191       Inst.addOperand(MCOperand::createImm(MCE->getValue() >> 12));
1192   }
1193
1194   void addAdrLabelOperands(MCInst &Inst, unsigned N) const {
1195     addImmOperands(Inst, N);
1196   }
1197
1198   template<int Scale>
1199   void addUImm12OffsetOperands(MCInst &Inst, unsigned N) const {
1200     assert(N == 1 && "Invalid number of operands!");
1201     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
1202
1203     if (!MCE) {
1204       Inst.addOperand(MCOperand::createExpr(getImm()));
1205       return;
1206     }
1207     Inst.addOperand(MCOperand::createImm(MCE->getValue() / Scale));
1208   }
1209
1210   void addSImm9Operands(MCInst &Inst, unsigned N) const {
1211     assert(N == 1 && "Invalid number of operands!");
1212     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1213     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1214   }
1215
1216   void addSImm7s4Operands(MCInst &Inst, unsigned N) const {
1217     assert(N == 1 && "Invalid number of operands!");
1218     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1219     Inst.addOperand(MCOperand::createImm(MCE->getValue() / 4));
1220   }
1221
1222   void addSImm7s8Operands(MCInst &Inst, unsigned N) const {
1223     assert(N == 1 && "Invalid number of operands!");
1224     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1225     Inst.addOperand(MCOperand::createImm(MCE->getValue() / 8));
1226   }
1227
1228   void addSImm7s16Operands(MCInst &Inst, unsigned N) const {
1229     assert(N == 1 && "Invalid number of operands!");
1230     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1231     Inst.addOperand(MCOperand::createImm(MCE->getValue() / 16));
1232   }
1233
1234   void addImm0_1Operands(MCInst &Inst, unsigned N) const {
1235     assert(N == 1 && "Invalid number of operands!");
1236     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1237     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1238   }
1239
1240   void addImm0_7Operands(MCInst &Inst, unsigned N) const {
1241     assert(N == 1 && "Invalid number of operands!");
1242     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1243     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1244   }
1245
1246   void addImm1_8Operands(MCInst &Inst, unsigned N) const {
1247     assert(N == 1 && "Invalid number of operands!");
1248     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1249     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1250   }
1251
1252   void addImm0_15Operands(MCInst &Inst, unsigned N) const {
1253     assert(N == 1 && "Invalid number of operands!");
1254     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1255     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1256   }
1257
1258   void addImm1_16Operands(MCInst &Inst, unsigned N) const {
1259     assert(N == 1 && "Invalid number of operands!");
1260     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1261     assert(MCE && "Invalid constant immediate operand!");
1262     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1263   }
1264
1265   void addImm0_31Operands(MCInst &Inst, unsigned N) const {
1266     assert(N == 1 && "Invalid number of operands!");
1267     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1268     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1269   }
1270
1271   void addImm1_31Operands(MCInst &Inst, unsigned N) const {
1272     assert(N == 1 && "Invalid number of operands!");
1273     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1274     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1275   }
1276
1277   void addImm1_32Operands(MCInst &Inst, unsigned N) const {
1278     assert(N == 1 && "Invalid number of operands!");
1279     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1280     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1281   }
1282
1283   void addImm0_63Operands(MCInst &Inst, unsigned N) const {
1284     assert(N == 1 && "Invalid number of operands!");
1285     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1286     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1287   }
1288
1289   void addImm1_63Operands(MCInst &Inst, unsigned N) const {
1290     assert(N == 1 && "Invalid number of operands!");
1291     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1292     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1293   }
1294
1295   void addImm1_64Operands(MCInst &Inst, unsigned N) const {
1296     assert(N == 1 && "Invalid number of operands!");
1297     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1298     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1299   }
1300
1301   void addImm0_127Operands(MCInst &Inst, unsigned N) const {
1302     assert(N == 1 && "Invalid number of operands!");
1303     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1304     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1305   }
1306
1307   void addImm0_255Operands(MCInst &Inst, unsigned N) const {
1308     assert(N == 1 && "Invalid number of operands!");
1309     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1310     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1311   }
1312
1313   void addImm0_65535Operands(MCInst &Inst, unsigned N) const {
1314     assert(N == 1 && "Invalid number of operands!");
1315     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1316     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1317   }
1318
1319   void addImm32_63Operands(MCInst &Inst, unsigned N) const {
1320     assert(N == 1 && "Invalid number of operands!");
1321     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1322     Inst.addOperand(MCOperand::createImm(MCE->getValue()));
1323   }
1324
1325   void addLogicalImm32Operands(MCInst &Inst, unsigned N) const {
1326     assert(N == 1 && "Invalid number of operands!");
1327     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1328     uint64_t encoding =
1329         AArch64_AM::encodeLogicalImmediate(MCE->getValue() & 0xFFFFFFFF, 32);
1330     Inst.addOperand(MCOperand::createImm(encoding));
1331   }
1332
1333   void addLogicalImm64Operands(MCInst &Inst, unsigned N) const {
1334     assert(N == 1 && "Invalid number of operands!");
1335     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1336     uint64_t encoding = AArch64_AM::encodeLogicalImmediate(MCE->getValue(), 64);
1337     Inst.addOperand(MCOperand::createImm(encoding));
1338   }
1339
1340   void addLogicalImm32NotOperands(MCInst &Inst, unsigned N) const {
1341     assert(N == 1 && "Invalid number of operands!");
1342     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1343     int64_t Val = ~MCE->getValue() & 0xFFFFFFFF;
1344     uint64_t encoding = AArch64_AM::encodeLogicalImmediate(Val, 32);
1345     Inst.addOperand(MCOperand::createImm(encoding));
1346   }
1347
1348   void addLogicalImm64NotOperands(MCInst &Inst, unsigned N) const {
1349     assert(N == 1 && "Invalid number of operands!");
1350     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1351     uint64_t encoding =
1352         AArch64_AM::encodeLogicalImmediate(~MCE->getValue(), 64);
1353     Inst.addOperand(MCOperand::createImm(encoding));
1354   }
1355
1356   void addSIMDImmType10Operands(MCInst &Inst, unsigned N) const {
1357     assert(N == 1 && "Invalid number of operands!");
1358     const MCConstantExpr *MCE = cast<MCConstantExpr>(getImm());
1359     uint64_t encoding = AArch64_AM::encodeAdvSIMDModImmType10(MCE->getValue());
1360     Inst.addOperand(MCOperand::createImm(encoding));
1361   }
1362
1363   void addBranchTarget26Operands(MCInst &Inst, unsigned N) const {
1364     // Branch operands don't encode the low bits, so shift them off
1365     // here. If it's a label, however, just put it on directly as there's
1366     // not enough information now to do anything.
1367     assert(N == 1 && "Invalid number of operands!");
1368     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
1369     if (!MCE) {
1370       addExpr(Inst, getImm());
1371       return;
1372     }
1373     assert(MCE && "Invalid constant immediate operand!");
1374     Inst.addOperand(MCOperand::createImm(MCE->getValue() >> 2));
1375   }
1376
1377   void addPCRelLabel19Operands(MCInst &Inst, unsigned N) const {
1378     // Branch operands don't encode the low bits, so shift them off
1379     // here. If it's a label, however, just put it on directly as there's
1380     // not enough information now to do anything.
1381     assert(N == 1 && "Invalid number of operands!");
1382     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
1383     if (!MCE) {
1384       addExpr(Inst, getImm());
1385       return;
1386     }
1387     assert(MCE && "Invalid constant immediate operand!");
1388     Inst.addOperand(MCOperand::createImm(MCE->getValue() >> 2));
1389   }
1390
1391   void addBranchTarget14Operands(MCInst &Inst, unsigned N) const {
1392     // Branch operands don't encode the low bits, so shift them off
1393     // here. If it's a label, however, just put it on directly as there's
1394     // not enough information now to do anything.
1395     assert(N == 1 && "Invalid number of operands!");
1396     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(getImm());
1397     if (!MCE) {
1398       addExpr(Inst, getImm());
1399       return;
1400     }
1401     assert(MCE && "Invalid constant immediate operand!");
1402     Inst.addOperand(MCOperand::createImm(MCE->getValue() >> 2));
1403   }
1404
1405   void addFPImmOperands(MCInst &Inst, unsigned N) const {
1406     assert(N == 1 && "Invalid number of operands!");
1407     Inst.addOperand(MCOperand::createImm(getFPImm()));
1408   }
1409
1410   void addBarrierOperands(MCInst &Inst, unsigned N) const {
1411     assert(N == 1 && "Invalid number of operands!");
1412     Inst.addOperand(MCOperand::createImm(getBarrier()));
1413   }
1414
1415   void addMRSSystemRegisterOperands(MCInst &Inst, unsigned N) const {
1416     assert(N == 1 && "Invalid number of operands!");
1417
1418     Inst.addOperand(MCOperand::createImm(SysReg.MRSReg));
1419   }
1420
1421   void addMSRSystemRegisterOperands(MCInst &Inst, unsigned N) const {
1422     assert(N == 1 && "Invalid number of operands!");
1423
1424     Inst.addOperand(MCOperand::createImm(SysReg.MSRReg));
1425   }
1426
1427   void addSystemPStateFieldWithImm0_1Operands(MCInst &Inst, unsigned N) const {
1428     assert(N == 1 && "Invalid number of operands!");
1429
1430     Inst.addOperand(MCOperand::createImm(SysReg.PStateField));
1431   }
1432
1433   void addSystemPStateFieldWithImm0_15Operands(MCInst &Inst, unsigned N) const {
1434     assert(N == 1 && "Invalid number of operands!");
1435
1436     Inst.addOperand(MCOperand::createImm(SysReg.PStateField));
1437   }
1438
1439   void addSysCROperands(MCInst &Inst, unsigned N) const {
1440     assert(N == 1 && "Invalid number of operands!");
1441     Inst.addOperand(MCOperand::createImm(getSysCR()));
1442   }
1443
1444   void addPrefetchOperands(MCInst &Inst, unsigned N) const {
1445     assert(N == 1 && "Invalid number of operands!");
1446     Inst.addOperand(MCOperand::createImm(getPrefetch()));
1447   }
1448
1449   void addPSBHintOperands(MCInst &Inst, unsigned N) const {
1450     assert(N == 1 && "Invalid number of operands!");
1451     Inst.addOperand(MCOperand::createImm(getPSBHint()));
1452   }
1453
1454   void addShifterOperands(MCInst &Inst, unsigned N) const {
1455     assert(N == 1 && "Invalid number of operands!");
1456     unsigned Imm =
1457         AArch64_AM::getShifterImm(getShiftExtendType(), getShiftExtendAmount());
1458     Inst.addOperand(MCOperand::createImm(Imm));
1459   }
1460
1461   void addExtendOperands(MCInst &Inst, unsigned N) const {
1462     assert(N == 1 && "Invalid number of operands!");
1463     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
1464     if (ET == AArch64_AM::LSL) ET = AArch64_AM::UXTW;
1465     unsigned Imm = AArch64_AM::getArithExtendImm(ET, getShiftExtendAmount());
1466     Inst.addOperand(MCOperand::createImm(Imm));
1467   }
1468
1469   void addExtend64Operands(MCInst &Inst, unsigned N) const {
1470     assert(N == 1 && "Invalid number of operands!");
1471     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
1472     if (ET == AArch64_AM::LSL) ET = AArch64_AM::UXTX;
1473     unsigned Imm = AArch64_AM::getArithExtendImm(ET, getShiftExtendAmount());
1474     Inst.addOperand(MCOperand::createImm(Imm));
1475   }
1476
1477   void addMemExtendOperands(MCInst &Inst, unsigned N) const {
1478     assert(N == 2 && "Invalid number of operands!");
1479     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
1480     bool IsSigned = ET == AArch64_AM::SXTW || ET == AArch64_AM::SXTX;
1481     Inst.addOperand(MCOperand::createImm(IsSigned));
1482     Inst.addOperand(MCOperand::createImm(getShiftExtendAmount() != 0));
1483   }
1484
1485   // For 8-bit load/store instructions with a register offset, both the
1486   // "DoShift" and "NoShift" variants have a shift of 0. Because of this,
1487   // they're disambiguated by whether the shift was explicit or implicit rather
1488   // than its size.
1489   void addMemExtend8Operands(MCInst &Inst, unsigned N) const {
1490     assert(N == 2 && "Invalid number of operands!");
1491     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
1492     bool IsSigned = ET == AArch64_AM::SXTW || ET == AArch64_AM::SXTX;
1493     Inst.addOperand(MCOperand::createImm(IsSigned));
1494     Inst.addOperand(MCOperand::createImm(hasShiftExtendAmount()));
1495   }
1496
1497   template<int Shift>
1498   void addMOVZMovAliasOperands(MCInst &Inst, unsigned N) const {
1499     assert(N == 1 && "Invalid number of operands!");
1500
1501     const MCConstantExpr *CE = cast<MCConstantExpr>(getImm());
1502     uint64_t Value = CE->getValue();
1503     Inst.addOperand(MCOperand::createImm((Value >> Shift) & 0xffff));
1504   }
1505
1506   template<int Shift>
1507   void addMOVNMovAliasOperands(MCInst &Inst, unsigned N) const {
1508     assert(N == 1 && "Invalid number of operands!");
1509
1510     const MCConstantExpr *CE = cast<MCConstantExpr>(getImm());
1511     uint64_t Value = CE->getValue();
1512     Inst.addOperand(MCOperand::createImm((~Value >> Shift) & 0xffff));
1513   }
1514
1515   void print(raw_ostream &OS) const override;
1516
1517   static std::unique_ptr<AArch64Operand>
1518   CreateToken(StringRef Str, bool IsSuffix, SMLoc S, MCContext &Ctx) {
1519     auto Op = make_unique<AArch64Operand>(k_Token, Ctx);
1520     Op->Tok.Data = Str.data();
1521     Op->Tok.Length = Str.size();
1522     Op->Tok.IsSuffix = IsSuffix;
1523     Op->StartLoc = S;
1524     Op->EndLoc = S;
1525     return Op;
1526   }
1527
1528   static std::unique_ptr<AArch64Operand>
1529   CreateReg(unsigned RegNum, bool isVector, SMLoc S, SMLoc E, MCContext &Ctx) {
1530     auto Op = make_unique<AArch64Operand>(k_Register, Ctx);
1531     Op->Reg.RegNum = RegNum;
1532     Op->Reg.isVector = isVector;
1533     Op->StartLoc = S;
1534     Op->EndLoc = E;
1535     return Op;
1536   }
1537
1538   static std::unique_ptr<AArch64Operand>
1539   CreateVectorList(unsigned RegNum, unsigned Count, unsigned NumElements,
1540                    char ElementKind, SMLoc S, SMLoc E, MCContext &Ctx) {
1541     auto Op = make_unique<AArch64Operand>(k_VectorList, Ctx);
1542     Op->VectorList.RegNum = RegNum;
1543     Op->VectorList.Count = Count;
1544     Op->VectorList.NumElements = NumElements;
1545     Op->VectorList.ElementKind = ElementKind;
1546     Op->StartLoc = S;
1547     Op->EndLoc = E;
1548     return Op;
1549   }
1550
1551   static std::unique_ptr<AArch64Operand>
1552   CreateVectorIndex(unsigned Idx, SMLoc S, SMLoc E, MCContext &Ctx) {
1553     auto Op = make_unique<AArch64Operand>(k_VectorIndex, Ctx);
1554     Op->VectorIndex.Val = Idx;
1555     Op->StartLoc = S;
1556     Op->EndLoc = E;
1557     return Op;
1558   }
1559
1560   static std::unique_ptr<AArch64Operand> CreateImm(const MCExpr *Val, SMLoc S,
1561                                                    SMLoc E, MCContext &Ctx) {
1562     auto Op = make_unique<AArch64Operand>(k_Immediate, Ctx);
1563     Op->Imm.Val = Val;
1564     Op->StartLoc = S;
1565     Op->EndLoc = E;
1566     return Op;
1567   }
1568
1569   static std::unique_ptr<AArch64Operand> CreateShiftedImm(const MCExpr *Val,
1570                                                           unsigned ShiftAmount,
1571                                                           SMLoc S, SMLoc E,
1572                                                           MCContext &Ctx) {
1573     auto Op = make_unique<AArch64Operand>(k_ShiftedImm, Ctx);
1574     Op->ShiftedImm .Val = Val;
1575     Op->ShiftedImm.ShiftAmount = ShiftAmount;
1576     Op->StartLoc = S;
1577     Op->EndLoc = E;
1578     return Op;
1579   }
1580
1581   static std::unique_ptr<AArch64Operand>
1582   CreateCondCode(AArch64CC::CondCode Code, SMLoc S, SMLoc E, MCContext &Ctx) {
1583     auto Op = make_unique<AArch64Operand>(k_CondCode, Ctx);
1584     Op->CondCode.Code = Code;
1585     Op->StartLoc = S;
1586     Op->EndLoc = E;
1587     return Op;
1588   }
1589
1590   static std::unique_ptr<AArch64Operand> CreateFPImm(unsigned Val, SMLoc S,
1591                                                      MCContext &Ctx) {
1592     auto Op = make_unique<AArch64Operand>(k_FPImm, Ctx);
1593     Op->FPImm.Val = Val;
1594     Op->StartLoc = S;
1595     Op->EndLoc = S;
1596     return Op;
1597   }
1598
1599   static std::unique_ptr<AArch64Operand> CreateBarrier(unsigned Val,
1600                                                        StringRef Str,
1601                                                        SMLoc S,
1602                                                        MCContext &Ctx) {
1603     auto Op = make_unique<AArch64Operand>(k_Barrier, Ctx);
1604     Op->Barrier.Val = Val;
1605     Op->Barrier.Data = Str.data();
1606     Op->Barrier.Length = Str.size();
1607     Op->StartLoc = S;
1608     Op->EndLoc = S;
1609     return Op;
1610   }
1611
1612   static std::unique_ptr<AArch64Operand> CreateSysReg(StringRef Str, SMLoc S,
1613                                                       uint32_t MRSReg,
1614                                                       uint32_t MSRReg,
1615                                                       uint32_t PStateField,
1616                                                       MCContext &Ctx) {
1617     auto Op = make_unique<AArch64Operand>(k_SysReg, Ctx);
1618     Op->SysReg.Data = Str.data();
1619     Op->SysReg.Length = Str.size();
1620     Op->SysReg.MRSReg = MRSReg;
1621     Op->SysReg.MSRReg = MSRReg;
1622     Op->SysReg.PStateField = PStateField;
1623     Op->StartLoc = S;
1624     Op->EndLoc = S;
1625     return Op;
1626   }
1627
1628   static std::unique_ptr<AArch64Operand> CreateSysCR(unsigned Val, SMLoc S,
1629                                                      SMLoc E, MCContext &Ctx) {
1630     auto Op = make_unique<AArch64Operand>(k_SysCR, Ctx);
1631     Op->SysCRImm.Val = Val;
1632     Op->StartLoc = S;
1633     Op->EndLoc = E;
1634     return Op;
1635   }
1636
1637   static std::unique_ptr<AArch64Operand> CreatePrefetch(unsigned Val,
1638                                                         StringRef Str,
1639                                                         SMLoc S,
1640                                                         MCContext &Ctx) {
1641     auto Op = make_unique<AArch64Operand>(k_Prefetch, Ctx);
1642     Op->Prefetch.Val = Val;
1643     Op->Barrier.Data = Str.data();
1644     Op->Barrier.Length = Str.size();
1645     Op->StartLoc = S;
1646     Op->EndLoc = S;
1647     return Op;
1648   }
1649
1650   static std::unique_ptr<AArch64Operand> CreatePSBHint(unsigned Val,
1651                                                        StringRef Str,
1652                                                        SMLoc S,
1653                                                        MCContext &Ctx) {
1654     auto Op = make_unique<AArch64Operand>(k_PSBHint, Ctx);
1655     Op->PSBHint.Val = Val;
1656     Op->PSBHint.Data = Str.data();
1657     Op->PSBHint.Length = Str.size();
1658     Op->StartLoc = S;
1659     Op->EndLoc = S;
1660     return Op;
1661   }
1662
1663   static std::unique_ptr<AArch64Operand>
1664   CreateShiftExtend(AArch64_AM::ShiftExtendType ShOp, unsigned Val,
1665                     bool HasExplicitAmount, SMLoc S, SMLoc E, MCContext &Ctx) {
1666     auto Op = make_unique<AArch64Operand>(k_ShiftExtend, Ctx);
1667     Op->ShiftExtend.Type = ShOp;
1668     Op->ShiftExtend.Amount = Val;
1669     Op->ShiftExtend.HasExplicitAmount = HasExplicitAmount;
1670     Op->StartLoc = S;
1671     Op->EndLoc = E;
1672     return Op;
1673   }
1674 };
1675
1676 } // end anonymous namespace.
1677
1678 void AArch64Operand::print(raw_ostream &OS) const {
1679   switch (Kind) {
1680   case k_FPImm:
1681     OS << "<fpimm " << getFPImm() << "("
1682        << AArch64_AM::getFPImmFloat(getFPImm()) << ") >";
1683     break;
1684   case k_Barrier: {
1685     StringRef Name = getBarrierName();
1686     if (!Name.empty())
1687       OS << "<barrier " << Name << ">";
1688     else
1689       OS << "<barrier invalid #" << getBarrier() << ">";
1690     break;
1691   }
1692   case k_Immediate:
1693     OS << *getImm();
1694     break;
1695   case k_ShiftedImm: {
1696     unsigned Shift = getShiftedImmShift();
1697     OS << "<shiftedimm ";
1698     OS << *getShiftedImmVal();
1699     OS << ", lsl #" << AArch64_AM::getShiftValue(Shift) << ">";
1700     break;
1701   }
1702   case k_CondCode:
1703     OS << "<condcode " << getCondCode() << ">";
1704     break;
1705   case k_Register:
1706     OS << "<register " << getReg() << ">";
1707     break;
1708   case k_VectorList: {
1709     OS << "<vectorlist ";
1710     unsigned Reg = getVectorListStart();
1711     for (unsigned i = 0, e = getVectorListCount(); i != e; ++i)
1712       OS << Reg + i << " ";
1713     OS << ">";
1714     break;
1715   }
1716   case k_VectorIndex:
1717     OS << "<vectorindex " << getVectorIndex() << ">";
1718     break;
1719   case k_SysReg:
1720     OS << "<sysreg: " << getSysReg() << '>';
1721     break;
1722   case k_Token:
1723     OS << "'" << getToken() << "'";
1724     break;
1725   case k_SysCR:
1726     OS << "c" << getSysCR();
1727     break;
1728   case k_Prefetch: {
1729     StringRef Name = getPrefetchName();
1730     if (!Name.empty())
1731       OS << "<prfop " << Name << ">";
1732     else
1733       OS << "<prfop invalid #" << getPrefetch() << ">";
1734     break;
1735   }
1736   case k_PSBHint:
1737     OS << getPSBHintName();
1738     break;
1739   case k_ShiftExtend:
1740     OS << "<" << AArch64_AM::getShiftExtendName(getShiftExtendType()) << " #"
1741        << getShiftExtendAmount();
1742     if (!hasShiftExtendAmount())
1743       OS << "<imp>";
1744     OS << '>';
1745     break;
1746   }
1747 }
1748
1749 /// @name Auto-generated Match Functions
1750 /// {
1751
1752 static unsigned MatchRegisterName(StringRef Name);
1753
1754 /// }
1755
1756 static unsigned matchVectorRegName(StringRef Name) {
1757   return StringSwitch<unsigned>(Name.lower())
1758       .Case("v0", AArch64::Q0)
1759       .Case("v1", AArch64::Q1)
1760       .Case("v2", AArch64::Q2)
1761       .Case("v3", AArch64::Q3)
1762       .Case("v4", AArch64::Q4)
1763       .Case("v5", AArch64::Q5)
1764       .Case("v6", AArch64::Q6)
1765       .Case("v7", AArch64::Q7)
1766       .Case("v8", AArch64::Q8)
1767       .Case("v9", AArch64::Q9)
1768       .Case("v10", AArch64::Q10)
1769       .Case("v11", AArch64::Q11)
1770       .Case("v12", AArch64::Q12)
1771       .Case("v13", AArch64::Q13)
1772       .Case("v14", AArch64::Q14)
1773       .Case("v15", AArch64::Q15)
1774       .Case("v16", AArch64::Q16)
1775       .Case("v17", AArch64::Q17)
1776       .Case("v18", AArch64::Q18)
1777       .Case("v19", AArch64::Q19)
1778       .Case("v20", AArch64::Q20)
1779       .Case("v21", AArch64::Q21)
1780       .Case("v22", AArch64::Q22)
1781       .Case("v23", AArch64::Q23)
1782       .Case("v24", AArch64::Q24)
1783       .Case("v25", AArch64::Q25)
1784       .Case("v26", AArch64::Q26)
1785       .Case("v27", AArch64::Q27)
1786       .Case("v28", AArch64::Q28)
1787       .Case("v29", AArch64::Q29)
1788       .Case("v30", AArch64::Q30)
1789       .Case("v31", AArch64::Q31)
1790       .Default(0);
1791 }
1792
1793 static bool isValidVectorKind(StringRef Name) {
1794   return StringSwitch<bool>(Name.lower())
1795       .Case(".8b", true)
1796       .Case(".16b", true)
1797       .Case(".4h", true)
1798       .Case(".8h", true)
1799       .Case(".2s", true)
1800       .Case(".4s", true)
1801       .Case(".1d", true)
1802       .Case(".2d", true)
1803       .Case(".1q", true)
1804       // Accept the width neutral ones, too, for verbose syntax. If those
1805       // aren't used in the right places, the token operand won't match so
1806       // all will work out.
1807       .Case(".b", true)
1808       .Case(".h", true)
1809       .Case(".s", true)
1810       .Case(".d", true)
1811       // Needed for fp16 scalar pairwise reductions
1812       .Case(".2h", true)
1813       .Default(false);
1814 }
1815
1816 static void parseValidVectorKind(StringRef Name, unsigned &NumElements,
1817                                  char &ElementKind) {
1818   assert(isValidVectorKind(Name));
1819
1820   ElementKind = Name.lower()[Name.size() - 1];
1821   NumElements = 0;
1822
1823   if (Name.size() == 2)
1824     return;
1825
1826   // Parse the lane count
1827   Name = Name.drop_front();
1828   while (isdigit(Name.front())) {
1829     NumElements = 10 * NumElements + (Name.front() - '0');
1830     Name = Name.drop_front();
1831   }
1832 }
1833
1834 bool AArch64AsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
1835                                      SMLoc &EndLoc) {
1836   StartLoc = getLoc();
1837   RegNo = tryParseRegister();
1838   EndLoc = SMLoc::getFromPointer(getLoc().getPointer() - 1);
1839   return (RegNo == (unsigned)-1);
1840 }
1841
1842 // Matches a register name or register alias previously defined by '.req'
1843 unsigned AArch64AsmParser::matchRegisterNameAlias(StringRef Name,
1844                                                   bool isVector) {
1845   unsigned RegNum = isVector ? matchVectorRegName(Name)
1846                              : MatchRegisterName(Name);
1847
1848   if (RegNum == 0) {
1849     // Check for aliases registered via .req. Canonicalize to lower case.
1850     // That's more consistent since register names are case insensitive, and
1851     // it's how the original entry was passed in from MC/MCParser/AsmParser.
1852     auto Entry = RegisterReqs.find(Name.lower());
1853     if (Entry == RegisterReqs.end())
1854       return 0;
1855     // set RegNum if the match is the right kind of register
1856     if (isVector == Entry->getValue().first)
1857       RegNum = Entry->getValue().second;
1858   }
1859   return RegNum;
1860 }
1861
1862 /// tryParseRegister - Try to parse a register name. The token must be an
1863 /// Identifier when called, and if it is a register name the token is eaten and
1864 /// the register is added to the operand list.
1865 int AArch64AsmParser::tryParseRegister() {
1866   MCAsmParser &Parser = getParser();
1867   const AsmToken &Tok = Parser.getTok();
1868   if (Tok.isNot(AsmToken::Identifier))
1869     return -1;
1870
1871   std::string lowerCase = Tok.getString().lower();
1872   unsigned RegNum = matchRegisterNameAlias(lowerCase, false);
1873   // Also handle a few aliases of registers.
1874   if (RegNum == 0)
1875     RegNum = StringSwitch<unsigned>(lowerCase)
1876                  .Case("fp",  AArch64::FP)
1877                  .Case("lr",  AArch64::LR)
1878                  .Case("x31", AArch64::XZR)
1879                  .Case("w31", AArch64::WZR)
1880                  .Default(0);
1881
1882   if (RegNum == 0)
1883     return -1;
1884
1885   Parser.Lex(); // Eat identifier token.
1886   return RegNum;
1887 }
1888
1889 /// tryMatchVectorRegister - Try to parse a vector register name with optional
1890 /// kind specifier. If it is a register specifier, eat the token and return it.
1891 int AArch64AsmParser::tryMatchVectorRegister(StringRef &Kind, bool expected) {
1892   MCAsmParser &Parser = getParser();
1893   if (Parser.getTok().isNot(AsmToken::Identifier)) {
1894     TokError("vector register expected");
1895     return -1;
1896   }
1897
1898   StringRef Name = Parser.getTok().getString();
1899   // If there is a kind specifier, it's separated from the register name by
1900   // a '.'.
1901   size_t Start = 0, Next = Name.find('.');
1902   StringRef Head = Name.slice(Start, Next);
1903   unsigned RegNum = matchRegisterNameAlias(Head, true);
1904
1905   if (RegNum) {
1906     if (Next != StringRef::npos) {
1907       Kind = Name.slice(Next, StringRef::npos);
1908       if (!isValidVectorKind(Kind)) {
1909         TokError("invalid vector kind qualifier");
1910         return -1;
1911       }
1912     }
1913     Parser.Lex(); // Eat the register token.
1914     return RegNum;
1915   }
1916
1917   if (expected)
1918     TokError("vector register expected");
1919   return -1;
1920 }
1921
1922 /// tryParseSysCROperand - Try to parse a system instruction CR operand name.
1923 OperandMatchResultTy
1924 AArch64AsmParser::tryParseSysCROperand(OperandVector &Operands) {
1925   MCAsmParser &Parser = getParser();
1926   SMLoc S = getLoc();
1927
1928   if (Parser.getTok().isNot(AsmToken::Identifier)) {
1929     Error(S, "Expected cN operand where 0 <= N <= 15");
1930     return MatchOperand_ParseFail;
1931   }
1932
1933   StringRef Tok = Parser.getTok().getIdentifier();
1934   if (Tok[0] != 'c' && Tok[0] != 'C') {
1935     Error(S, "Expected cN operand where 0 <= N <= 15");
1936     return MatchOperand_ParseFail;
1937   }
1938
1939   uint32_t CRNum;
1940   bool BadNum = Tok.drop_front().getAsInteger(10, CRNum);
1941   if (BadNum || CRNum > 15) {
1942     Error(S, "Expected cN operand where 0 <= N <= 15");
1943     return MatchOperand_ParseFail;
1944   }
1945
1946   Parser.Lex(); // Eat identifier token.
1947   Operands.push_back(
1948       AArch64Operand::CreateSysCR(CRNum, S, getLoc(), getContext()));
1949   return MatchOperand_Success;
1950 }
1951
1952 /// tryParsePrefetch - Try to parse a prefetch operand.
1953 OperandMatchResultTy
1954 AArch64AsmParser::tryParsePrefetch(OperandVector &Operands) {
1955   MCAsmParser &Parser = getParser();
1956   SMLoc S = getLoc();
1957   const AsmToken &Tok = Parser.getTok();
1958   // Either an identifier for named values or a 5-bit immediate.
1959   // Eat optional hash.
1960   if (parseOptionalToken(AsmToken::Hash) ||
1961       Tok.is(AsmToken::Integer)) {
1962     const MCExpr *ImmVal;
1963     if (getParser().parseExpression(ImmVal))
1964       return MatchOperand_ParseFail;
1965
1966     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
1967     if (!MCE) {
1968       TokError("immediate value expected for prefetch operand");
1969       return MatchOperand_ParseFail;
1970     }
1971     unsigned prfop = MCE->getValue();
1972     if (prfop > 31) {
1973       TokError("prefetch operand out of range, [0,31] expected");
1974       return MatchOperand_ParseFail;
1975     }
1976
1977     auto PRFM = AArch64PRFM::lookupPRFMByEncoding(MCE->getValue());
1978     Operands.push_back(AArch64Operand::CreatePrefetch(
1979         prfop, PRFM ? PRFM->Name : "", S, getContext()));
1980     return MatchOperand_Success;
1981   }
1982
1983   if (Tok.isNot(AsmToken::Identifier)) {
1984     TokError("pre-fetch hint expected");
1985     return MatchOperand_ParseFail;
1986   }
1987
1988   auto PRFM = AArch64PRFM::lookupPRFMByName(Tok.getString());
1989   if (!PRFM) {
1990     TokError("pre-fetch hint expected");
1991     return MatchOperand_ParseFail;
1992   }
1993
1994   Parser.Lex(); // Eat identifier token.
1995   Operands.push_back(AArch64Operand::CreatePrefetch(
1996       PRFM->Encoding, Tok.getString(), S, getContext()));
1997   return MatchOperand_Success;
1998 }
1999
2000 /// tryParsePSBHint - Try to parse a PSB operand, mapped to Hint command
2001 OperandMatchResultTy
2002 AArch64AsmParser::tryParsePSBHint(OperandVector &Operands) {
2003   MCAsmParser &Parser = getParser();
2004   SMLoc S = getLoc();
2005   const AsmToken &Tok = Parser.getTok();
2006   if (Tok.isNot(AsmToken::Identifier)) {
2007     TokError("invalid operand for instruction");
2008     return MatchOperand_ParseFail;
2009   }
2010
2011   auto PSB = AArch64PSBHint::lookupPSBByName(Tok.getString());
2012   if (!PSB) {
2013     TokError("invalid operand for instruction");
2014     return MatchOperand_ParseFail;
2015   }
2016
2017   Parser.Lex(); // Eat identifier token.
2018   Operands.push_back(AArch64Operand::CreatePSBHint(
2019       PSB->Encoding, Tok.getString(), S, getContext()));
2020   return MatchOperand_Success;
2021 }
2022
2023 /// tryParseAdrpLabel - Parse and validate a source label for the ADRP
2024 /// instruction.
2025 OperandMatchResultTy
2026 AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
2027   MCAsmParser &Parser = getParser();
2028   SMLoc S = getLoc();
2029   const MCExpr *Expr;
2030
2031   if (Parser.getTok().is(AsmToken::Hash)) {
2032     Parser.Lex(); // Eat hash token.
2033   }
2034
2035   if (parseSymbolicImmVal(Expr))
2036     return MatchOperand_ParseFail;
2037
2038   AArch64MCExpr::VariantKind ELFRefKind;
2039   MCSymbolRefExpr::VariantKind DarwinRefKind;
2040   int64_t Addend;
2041   if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
2042     if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
2043         ELFRefKind == AArch64MCExpr::VK_INVALID) {
2044       // No modifier was specified at all; this is the syntax for an ELF basic
2045       // ADRP relocation (unfortunately).
2046       Expr =
2047           AArch64MCExpr::create(Expr, AArch64MCExpr::VK_ABS_PAGE, getContext());
2048     } else if ((DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGE ||
2049                 DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGE) &&
2050                Addend != 0) {
2051       Error(S, "gotpage label reference not allowed an addend");
2052       return MatchOperand_ParseFail;
2053     } else if (DarwinRefKind != MCSymbolRefExpr::VK_PAGE &&
2054                DarwinRefKind != MCSymbolRefExpr::VK_GOTPAGE &&
2055                DarwinRefKind != MCSymbolRefExpr::VK_TLVPPAGE &&
2056                ELFRefKind != AArch64MCExpr::VK_GOT_PAGE &&
2057                ELFRefKind != AArch64MCExpr::VK_GOTTPREL_PAGE &&
2058                ELFRefKind != AArch64MCExpr::VK_TLSDESC_PAGE) {
2059       // The operand must be an @page or @gotpage qualified symbolref.
2060       Error(S, "page or gotpage label reference expected");
2061       return MatchOperand_ParseFail;
2062     }
2063   }
2064
2065   // We have either a label reference possibly with addend or an immediate. The
2066   // addend is a raw value here. The linker will adjust it to only reference the
2067   // page.
2068   SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2069   Operands.push_back(AArch64Operand::CreateImm(Expr, S, E, getContext()));
2070
2071   return MatchOperand_Success;
2072 }
2073
2074 /// tryParseAdrLabel - Parse and validate a source label for the ADR
2075 /// instruction.
2076 OperandMatchResultTy
2077 AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) {
2078   SMLoc S = getLoc();
2079   const MCExpr *Expr;
2080
2081   parseOptionalToken(AsmToken::Hash);
2082   if (getParser().parseExpression(Expr))
2083     return MatchOperand_ParseFail;
2084
2085   SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2086   Operands.push_back(AArch64Operand::CreateImm(Expr, S, E, getContext()));
2087
2088   return MatchOperand_Success;
2089 }
2090
2091 /// tryParseFPImm - A floating point immediate expression operand.
2092 OperandMatchResultTy
2093 AArch64AsmParser::tryParseFPImm(OperandVector &Operands) {
2094   MCAsmParser &Parser = getParser();
2095   SMLoc S = getLoc();
2096
2097   bool Hash = parseOptionalToken(AsmToken::Hash);
2098
2099   // Handle negation, as that still comes through as a separate token.
2100   bool isNegative = parseOptionalToken(AsmToken::Minus);
2101
2102   const AsmToken &Tok = Parser.getTok();
2103   if (Tok.is(AsmToken::Real) || Tok.is(AsmToken::Integer)) {
2104     int64_t Val;
2105     if (Tok.is(AsmToken::Integer) && !isNegative && Tok.getString().startswith("0x")) {
2106       Val = Tok.getIntVal();
2107       if (Val > 255 || Val < 0) {
2108         TokError("encoded floating point value out of range");
2109         return MatchOperand_ParseFail;
2110       }
2111     } else {
2112       APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
2113       if (isNegative)
2114         RealVal.changeSign();
2115
2116       uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
2117       Val = AArch64_AM::getFP64Imm(APInt(64, IntVal));
2118
2119       // Check for out of range values. As an exception we let Zero through,
2120       // but as tokens instead of an FPImm so that it can be matched by the
2121       // appropriate alias if one exists.
2122       if (RealVal.isPosZero()) {
2123         Parser.Lex(); // Eat the token.
2124         Operands.push_back(AArch64Operand::CreateToken("#0", false, S, getContext()));
2125         Operands.push_back(AArch64Operand::CreateToken(".0", false, S, getContext()));
2126         return MatchOperand_Success;
2127       } else if (Val == -1) {
2128         TokError("expected compatible register or floating-point constant");
2129         return MatchOperand_ParseFail;
2130       }
2131     }
2132     Parser.Lex(); // Eat the token.
2133     Operands.push_back(AArch64Operand::CreateFPImm(Val, S, getContext()));
2134     return MatchOperand_Success;
2135   }
2136
2137   if (!Hash)
2138     return MatchOperand_NoMatch;
2139
2140   TokError("invalid floating point immediate");
2141   return MatchOperand_ParseFail;
2142 }
2143
2144 /// tryParseAddSubImm - Parse ADD/SUB shifted immediate operand
2145 OperandMatchResultTy
2146 AArch64AsmParser::tryParseAddSubImm(OperandVector &Operands) {
2147   MCAsmParser &Parser = getParser();
2148   SMLoc S = getLoc();
2149
2150   if (Parser.getTok().is(AsmToken::Hash))
2151     Parser.Lex(); // Eat '#'
2152   else if (Parser.getTok().isNot(AsmToken::Integer))
2153     // Operand should start from # or should be integer, emit error otherwise.
2154     return MatchOperand_NoMatch;
2155
2156   const MCExpr *Imm;
2157   if (parseSymbolicImmVal(Imm))
2158     return MatchOperand_ParseFail;
2159   else if (Parser.getTok().isNot(AsmToken::Comma)) {
2160     uint64_t ShiftAmount = 0;
2161     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Imm);
2162     if (MCE) {
2163       int64_t Val = MCE->getValue();
2164       if (Val > 0xfff && (Val & 0xfff) == 0) {
2165         Imm = MCConstantExpr::create(Val >> 12, getContext());
2166         ShiftAmount = 12;
2167       }
2168     }
2169     SMLoc E = Parser.getTok().getLoc();
2170     Operands.push_back(AArch64Operand::CreateShiftedImm(Imm, ShiftAmount, S, E,
2171                                                         getContext()));
2172     return MatchOperand_Success;
2173   }
2174
2175   // Eat ','
2176   Parser.Lex();
2177
2178   // The optional operand must be "lsl #N" where N is non-negative.
2179   if (!Parser.getTok().is(AsmToken::Identifier) ||
2180       !Parser.getTok().getIdentifier().equals_lower("lsl")) {
2181     Error(Parser.getTok().getLoc(), "only 'lsl #+N' valid after immediate");
2182     return MatchOperand_ParseFail;
2183   }
2184
2185   // Eat 'lsl'
2186   Parser.Lex();
2187
2188   parseOptionalToken(AsmToken::Hash);
2189
2190   if (Parser.getTok().isNot(AsmToken::Integer)) {
2191     Error(Parser.getTok().getLoc(), "only 'lsl #+N' valid after immediate");
2192     return MatchOperand_ParseFail;
2193   }
2194
2195   int64_t ShiftAmount = Parser.getTok().getIntVal();
2196
2197   if (ShiftAmount < 0) {
2198     Error(Parser.getTok().getLoc(), "positive shift amount required");
2199     return MatchOperand_ParseFail;
2200   }
2201   Parser.Lex(); // Eat the number
2202
2203   SMLoc E = Parser.getTok().getLoc();
2204   Operands.push_back(AArch64Operand::CreateShiftedImm(Imm, ShiftAmount,
2205                                                       S, E, getContext()));
2206   return MatchOperand_Success;
2207 }
2208
2209 /// parseCondCodeString - Parse a Condition Code string.
2210 AArch64CC::CondCode AArch64AsmParser::parseCondCodeString(StringRef Cond) {
2211   AArch64CC::CondCode CC = StringSwitch<AArch64CC::CondCode>(Cond.lower())
2212                     .Case("eq", AArch64CC::EQ)
2213                     .Case("ne", AArch64CC::NE)
2214                     .Case("cs", AArch64CC::HS)
2215                     .Case("hs", AArch64CC::HS)
2216                     .Case("cc", AArch64CC::LO)
2217                     .Case("lo", AArch64CC::LO)
2218                     .Case("mi", AArch64CC::MI)
2219                     .Case("pl", AArch64CC::PL)
2220                     .Case("vs", AArch64CC::VS)
2221                     .Case("vc", AArch64CC::VC)
2222                     .Case("hi", AArch64CC::HI)
2223                     .Case("ls", AArch64CC::LS)
2224                     .Case("ge", AArch64CC::GE)
2225                     .Case("lt", AArch64CC::LT)
2226                     .Case("gt", AArch64CC::GT)
2227                     .Case("le", AArch64CC::LE)
2228                     .Case("al", AArch64CC::AL)
2229                     .Case("nv", AArch64CC::NV)
2230                     .Default(AArch64CC::Invalid);
2231   return CC;
2232 }
2233
2234 /// parseCondCode - Parse a Condition Code operand.
2235 bool AArch64AsmParser::parseCondCode(OperandVector &Operands,
2236                                      bool invertCondCode) {
2237   MCAsmParser &Parser = getParser();
2238   SMLoc S = getLoc();
2239   const AsmToken &Tok = Parser.getTok();
2240   assert(Tok.is(AsmToken::Identifier) && "Token is not an Identifier");
2241
2242   StringRef Cond = Tok.getString();
2243   AArch64CC::CondCode CC = parseCondCodeString(Cond);
2244   if (CC == AArch64CC::Invalid)
2245     return TokError("invalid condition code");
2246   Parser.Lex(); // Eat identifier token.
2247
2248   if (invertCondCode) {
2249     if (CC == AArch64CC::AL || CC == AArch64CC::NV)
2250       return TokError("condition codes AL and NV are invalid for this instruction");
2251     CC = AArch64CC::getInvertedCondCode(AArch64CC::CondCode(CC));
2252   }
2253
2254   Operands.push_back(
2255       AArch64Operand::CreateCondCode(CC, S, getLoc(), getContext()));
2256   return false;
2257 }
2258
2259 /// tryParseOptionalShift - Some operands take an optional shift argument. Parse
2260 /// them if present.
2261 OperandMatchResultTy
2262 AArch64AsmParser::tryParseOptionalShiftExtend(OperandVector &Operands) {
2263   MCAsmParser &Parser = getParser();
2264   const AsmToken &Tok = Parser.getTok();
2265   std::string LowerID = Tok.getString().lower();
2266   AArch64_AM::ShiftExtendType ShOp =
2267       StringSwitch<AArch64_AM::ShiftExtendType>(LowerID)
2268           .Case("lsl", AArch64_AM::LSL)
2269           .Case("lsr", AArch64_AM::LSR)
2270           .Case("asr", AArch64_AM::ASR)
2271           .Case("ror", AArch64_AM::ROR)
2272           .Case("msl", AArch64_AM::MSL)
2273           .Case("uxtb", AArch64_AM::UXTB)
2274           .Case("uxth", AArch64_AM::UXTH)
2275           .Case("uxtw", AArch64_AM::UXTW)
2276           .Case("uxtx", AArch64_AM::UXTX)
2277           .Case("sxtb", AArch64_AM::SXTB)
2278           .Case("sxth", AArch64_AM::SXTH)
2279           .Case("sxtw", AArch64_AM::SXTW)
2280           .Case("sxtx", AArch64_AM::SXTX)
2281           .Default(AArch64_AM::InvalidShiftExtend);
2282
2283   if (ShOp == AArch64_AM::InvalidShiftExtend)
2284     return MatchOperand_NoMatch;
2285
2286   SMLoc S = Tok.getLoc();
2287   Parser.Lex();
2288
2289   bool Hash = parseOptionalToken(AsmToken::Hash);
2290
2291   if (!Hash && getLexer().isNot(AsmToken::Integer)) {
2292     if (ShOp == AArch64_AM::LSL || ShOp == AArch64_AM::LSR ||
2293         ShOp == AArch64_AM::ASR || ShOp == AArch64_AM::ROR ||
2294         ShOp == AArch64_AM::MSL) {
2295       // We expect a number here.
2296       TokError("expected #imm after shift specifier");
2297       return MatchOperand_ParseFail;
2298     }
2299
2300     // "extend" type operations don't need an immediate, #0 is implicit.
2301     SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2302     Operands.push_back(
2303         AArch64Operand::CreateShiftExtend(ShOp, 0, false, S, E, getContext()));
2304     return MatchOperand_Success;
2305   }
2306
2307   // Make sure we do actually have a number, identifier or a parenthesized
2308   // expression.
2309   SMLoc E = Parser.getTok().getLoc();
2310   if (!Parser.getTok().is(AsmToken::Integer) &&
2311       !Parser.getTok().is(AsmToken::LParen) &&
2312       !Parser.getTok().is(AsmToken::Identifier)) {
2313     Error(E, "expected integer shift amount");
2314     return MatchOperand_ParseFail;
2315   }
2316
2317   const MCExpr *ImmVal;
2318   if (getParser().parseExpression(ImmVal))
2319     return MatchOperand_ParseFail;
2320
2321   const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2322   if (!MCE) {
2323     Error(E, "expected constant '#imm' after shift specifier");
2324     return MatchOperand_ParseFail;
2325   }
2326
2327   E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2328   Operands.push_back(AArch64Operand::CreateShiftExtend(
2329       ShOp, MCE->getValue(), true, S, E, getContext()));
2330   return MatchOperand_Success;
2331 }
2332
2333 static void setRequiredFeatureString(FeatureBitset FBS, std::string &Str) {
2334   if (FBS[AArch64::HasV8_1aOps])
2335     Str += "ARMv8.1a";
2336   else if (FBS[AArch64::HasV8_2aOps])
2337     Str += "ARMv8.2a";
2338   else
2339     Str += "(unknown)";
2340 }
2341
2342 void AArch64AsmParser::createSysAlias(uint16_t Encoding, OperandVector &Operands,
2343                                       SMLoc S) {
2344   const uint16_t Op2 = Encoding & 7;
2345   const uint16_t Cm = (Encoding & 0x78) >> 3;
2346   const uint16_t Cn = (Encoding & 0x780) >> 7;
2347   const uint16_t Op1 = (Encoding & 0x3800) >> 11;
2348
2349   const MCExpr *Expr = MCConstantExpr::create(Op1, getContext());
2350
2351   Operands.push_back(
2352       AArch64Operand::CreateImm(Expr, S, getLoc(), getContext()));
2353   Operands.push_back(
2354       AArch64Operand::CreateSysCR(Cn, S, getLoc(), getContext()));
2355   Operands.push_back(
2356       AArch64Operand::CreateSysCR(Cm, S, getLoc(), getContext()));
2357   Expr = MCConstantExpr::create(Op2, getContext());
2358   Operands.push_back(
2359       AArch64Operand::CreateImm(Expr, S, getLoc(), getContext()));
2360 }
2361
2362 /// parseSysAlias - The IC, DC, AT, and TLBI instructions are simple aliases for
2363 /// the SYS instruction. Parse them specially so that we create a SYS MCInst.
2364 bool AArch64AsmParser::parseSysAlias(StringRef Name, SMLoc NameLoc,
2365                                    OperandVector &Operands) {
2366   if (Name.find('.') != StringRef::npos)
2367     return TokError("invalid operand");
2368
2369   Mnemonic = Name;
2370   Operands.push_back(
2371       AArch64Operand::CreateToken("sys", false, NameLoc, getContext()));
2372
2373   MCAsmParser &Parser = getParser();
2374   const AsmToken &Tok = Parser.getTok();
2375   StringRef Op = Tok.getString();
2376   SMLoc S = Tok.getLoc();
2377
2378   if (Mnemonic == "ic") {
2379     const AArch64IC::IC *IC = AArch64IC::lookupICByName(Op);
2380     if (!IC)
2381       return TokError("invalid operand for IC instruction");
2382     else if (!IC->haveFeatures(getSTI().getFeatureBits())) {
2383       std::string Str("IC " + std::string(IC->Name) + " requires ");
2384       setRequiredFeatureString(IC->getRequiredFeatures(), Str);
2385       return TokError(Str.c_str());
2386     }
2387     createSysAlias(IC->Encoding, Operands, S);
2388   } else if (Mnemonic == "dc") {
2389     const AArch64DC::DC *DC = AArch64DC::lookupDCByName(Op);
2390     if (!DC)
2391       return TokError("invalid operand for DC instruction");
2392     else if (!DC->haveFeatures(getSTI().getFeatureBits())) {
2393       std::string Str("DC " + std::string(DC->Name) + " requires ");
2394       setRequiredFeatureString(DC->getRequiredFeatures(), Str);
2395       return TokError(Str.c_str());
2396     }
2397     createSysAlias(DC->Encoding, Operands, S);
2398   } else if (Mnemonic == "at") {
2399     const AArch64AT::AT *AT = AArch64AT::lookupATByName(Op);
2400     if (!AT)
2401       return TokError("invalid operand for AT instruction");
2402     else if (!AT->haveFeatures(getSTI().getFeatureBits())) {
2403       std::string Str("AT " + std::string(AT->Name) + " requires ");
2404       setRequiredFeatureString(AT->getRequiredFeatures(), Str);
2405       return TokError(Str.c_str());
2406     }
2407     createSysAlias(AT->Encoding, Operands, S);
2408   } else if (Mnemonic == "tlbi") {
2409     const AArch64TLBI::TLBI *TLBI = AArch64TLBI::lookupTLBIByName(Op);
2410     if (!TLBI)
2411       return TokError("invalid operand for TLBI instruction");
2412     else if (!TLBI->haveFeatures(getSTI().getFeatureBits())) {
2413       std::string Str("TLBI " + std::string(TLBI->Name) + " requires ");
2414       setRequiredFeatureString(TLBI->getRequiredFeatures(), Str);
2415       return TokError(Str.c_str());
2416     }
2417     createSysAlias(TLBI->Encoding, Operands, S);
2418   }
2419
2420   Parser.Lex(); // Eat operand.
2421
2422   bool ExpectRegister = (Op.lower().find("all") == StringRef::npos);
2423   bool HasRegister = false;
2424
2425   // Check for the optional register operand.
2426   if (parseOptionalToken(AsmToken::Comma)) {
2427     if (Tok.isNot(AsmToken::Identifier) || parseRegister(Operands))
2428       return TokError("expected register operand");
2429     HasRegister = true;
2430   }
2431
2432   if (ExpectRegister && !HasRegister)
2433     return TokError("specified " + Mnemonic + " op requires a register");
2434   else if (!ExpectRegister && HasRegister)
2435     return TokError("specified " + Mnemonic + " op does not use a register");
2436
2437   if (parseToken(AsmToken::EndOfStatement, "unexpected token in argument list"))
2438     return true;
2439
2440   return false;
2441 }
2442
2443 OperandMatchResultTy
2444 AArch64AsmParser::tryParseBarrierOperand(OperandVector &Operands) {
2445   MCAsmParser &Parser = getParser();
2446   const AsmToken &Tok = Parser.getTok();
2447
2448   // Can be either a #imm style literal or an option name
2449   if (parseOptionalToken(AsmToken::Hash) ||
2450       Tok.is(AsmToken::Integer)) {
2451     // Immediate operand.
2452     const MCExpr *ImmVal;
2453     SMLoc ExprLoc = getLoc();
2454     if (getParser().parseExpression(ImmVal))
2455       return MatchOperand_ParseFail;
2456     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2457     if (!MCE) {
2458       Error(ExprLoc, "immediate value expected for barrier operand");
2459       return MatchOperand_ParseFail;
2460     }
2461     if (MCE->getValue() < 0 || MCE->getValue() > 15) {
2462       Error(ExprLoc, "barrier operand out of range");
2463       return MatchOperand_ParseFail;
2464     }
2465     auto DB = AArch64DB::lookupDBByEncoding(MCE->getValue());
2466     Operands.push_back(AArch64Operand::CreateBarrier(
2467         MCE->getValue(), DB ? DB->Name : "", ExprLoc, getContext()));
2468     return MatchOperand_Success;
2469   }
2470
2471   if (Tok.isNot(AsmToken::Identifier)) {
2472     TokError("invalid operand for instruction");
2473     return MatchOperand_ParseFail;
2474   }
2475
2476   auto DB = AArch64DB::lookupDBByName(Tok.getString());
2477   if (!DB) {
2478     TokError("invalid barrier option name");
2479     return MatchOperand_ParseFail;
2480   }
2481
2482   // The only valid named option for ISB is 'sy'
2483   if (Mnemonic == "isb" && DB->Encoding != AArch64DB::sy) {
2484     TokError("'sy' or #imm operand expected");
2485     return MatchOperand_ParseFail;
2486   }
2487
2488   Operands.push_back(AArch64Operand::CreateBarrier(
2489       DB->Encoding, Tok.getString(), getLoc(), getContext()));
2490   Parser.Lex(); // Consume the option
2491
2492   return MatchOperand_Success;
2493 }
2494
2495 OperandMatchResultTy
2496 AArch64AsmParser::tryParseSysReg(OperandVector &Operands) {
2497   MCAsmParser &Parser = getParser();
2498   const AsmToken &Tok = Parser.getTok();
2499
2500   if (Tok.isNot(AsmToken::Identifier))
2501     return MatchOperand_NoMatch;
2502
2503   int MRSReg, MSRReg;
2504   auto SysReg = AArch64SysReg::lookupSysRegByName(Tok.getString());
2505   if (SysReg && SysReg->haveFeatures(getSTI().getFeatureBits())) {
2506     MRSReg = SysReg->Readable ? SysReg->Encoding : -1;
2507     MSRReg = SysReg->Writeable ? SysReg->Encoding : -1;
2508   } else
2509     MRSReg = MSRReg = AArch64SysReg::parseGenericRegister(Tok.getString());
2510
2511   auto PState = AArch64PState::lookupPStateByName(Tok.getString());
2512   unsigned PStateImm = -1;
2513   if (PState && PState->haveFeatures(getSTI().getFeatureBits()))
2514     PStateImm = PState->Encoding;
2515
2516   Operands.push_back(
2517       AArch64Operand::CreateSysReg(Tok.getString(), getLoc(), MRSReg, MSRReg,
2518                                    PStateImm, getContext()));
2519   Parser.Lex(); // Eat identifier
2520
2521   return MatchOperand_Success;
2522 }
2523
2524 /// tryParseVectorRegister - Parse a vector register operand.
2525 bool AArch64AsmParser::tryParseVectorRegister(OperandVector &Operands) {
2526   MCAsmParser &Parser = getParser();
2527   if (Parser.getTok().isNot(AsmToken::Identifier))
2528     return true;
2529
2530   SMLoc S = getLoc();
2531   // Check for a vector register specifier first.
2532   StringRef Kind;
2533   int64_t Reg = tryMatchVectorRegister(Kind, false);
2534   if (Reg == -1)
2535     return true;
2536   Operands.push_back(
2537       AArch64Operand::CreateReg(Reg, true, S, getLoc(), getContext()));
2538   // If there was an explicit qualifier, that goes on as a literal text
2539   // operand.
2540   if (!Kind.empty())
2541     Operands.push_back(
2542         AArch64Operand::CreateToken(Kind, false, S, getContext()));
2543
2544   // If there is an index specifier following the register, parse that too.
2545   SMLoc SIdx = getLoc();
2546   if (parseOptionalToken(AsmToken::LBrac)) {
2547     const MCExpr *ImmVal;
2548     if (getParser().parseExpression(ImmVal))
2549       return false;
2550     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2551     if (!MCE) {
2552       TokError("immediate value expected for vector index");
2553       return false;
2554     }
2555
2556     SMLoc E = getLoc();
2557
2558     if (parseToken(AsmToken::RBrac, "']' expected"))
2559       return false;
2560
2561     Operands.push_back(AArch64Operand::CreateVectorIndex(MCE->getValue(), SIdx,
2562                                                          E, getContext()));
2563   }
2564
2565   return false;
2566 }
2567
2568 /// parseRegister - Parse a non-vector register operand.
2569 bool AArch64AsmParser::parseRegister(OperandVector &Operands) {
2570   SMLoc S = getLoc();
2571   // Try for a vector register.
2572   if (!tryParseVectorRegister(Operands))
2573     return false;
2574
2575   // Try for a scalar register.
2576   int64_t Reg = tryParseRegister();
2577   if (Reg == -1)
2578     return true;
2579   Operands.push_back(
2580       AArch64Operand::CreateReg(Reg, false, S, getLoc(), getContext()));
2581
2582   return false;
2583 }
2584
2585 bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
2586   MCAsmParser &Parser = getParser();
2587   bool HasELFModifier = false;
2588   AArch64MCExpr::VariantKind RefKind;
2589
2590   if (parseOptionalToken(AsmToken::Colon)) {
2591     HasELFModifier = true;
2592
2593     if (Parser.getTok().isNot(AsmToken::Identifier))
2594       return TokError("expect relocation specifier in operand after ':'");
2595
2596     std::string LowerCase = Parser.getTok().getIdentifier().lower();
2597     RefKind = StringSwitch<AArch64MCExpr::VariantKind>(LowerCase)
2598                   .Case("lo12", AArch64MCExpr::VK_LO12)
2599                   .Case("abs_g3", AArch64MCExpr::VK_ABS_G3)
2600                   .Case("abs_g2", AArch64MCExpr::VK_ABS_G2)
2601                   .Case("abs_g2_s", AArch64MCExpr::VK_ABS_G2_S)
2602                   .Case("abs_g2_nc", AArch64MCExpr::VK_ABS_G2_NC)
2603                   .Case("abs_g1", AArch64MCExpr::VK_ABS_G1)
2604                   .Case("abs_g1_s", AArch64MCExpr::VK_ABS_G1_S)
2605                   .Case("abs_g1_nc", AArch64MCExpr::VK_ABS_G1_NC)
2606                   .Case("abs_g0", AArch64MCExpr::VK_ABS_G0)
2607                   .Case("abs_g0_s", AArch64MCExpr::VK_ABS_G0_S)
2608                   .Case("abs_g0_nc", AArch64MCExpr::VK_ABS_G0_NC)
2609                   .Case("dtprel_g2", AArch64MCExpr::VK_DTPREL_G2)
2610                   .Case("dtprel_g1", AArch64MCExpr::VK_DTPREL_G1)
2611                   .Case("dtprel_g1_nc", AArch64MCExpr::VK_DTPREL_G1_NC)
2612                   .Case("dtprel_g0", AArch64MCExpr::VK_DTPREL_G0)
2613                   .Case("dtprel_g0_nc", AArch64MCExpr::VK_DTPREL_G0_NC)
2614                   .Case("dtprel_hi12", AArch64MCExpr::VK_DTPREL_HI12)
2615                   .Case("dtprel_lo12", AArch64MCExpr::VK_DTPREL_LO12)
2616                   .Case("dtprel_lo12_nc", AArch64MCExpr::VK_DTPREL_LO12_NC)
2617                   .Case("tprel_g2", AArch64MCExpr::VK_TPREL_G2)
2618                   .Case("tprel_g1", AArch64MCExpr::VK_TPREL_G1)
2619                   .Case("tprel_g1_nc", AArch64MCExpr::VK_TPREL_G1_NC)
2620                   .Case("tprel_g0", AArch64MCExpr::VK_TPREL_G0)
2621                   .Case("tprel_g0_nc", AArch64MCExpr::VK_TPREL_G0_NC)
2622                   .Case("tprel_hi12", AArch64MCExpr::VK_TPREL_HI12)
2623                   .Case("tprel_lo12", AArch64MCExpr::VK_TPREL_LO12)
2624                   .Case("tprel_lo12_nc", AArch64MCExpr::VK_TPREL_LO12_NC)
2625                   .Case("tlsdesc_lo12", AArch64MCExpr::VK_TLSDESC_LO12)
2626                   .Case("got", AArch64MCExpr::VK_GOT_PAGE)
2627                   .Case("got_lo12", AArch64MCExpr::VK_GOT_LO12)
2628                   .Case("gottprel", AArch64MCExpr::VK_GOTTPREL_PAGE)
2629                   .Case("gottprel_lo12", AArch64MCExpr::VK_GOTTPREL_LO12_NC)
2630                   .Case("gottprel_g1", AArch64MCExpr::VK_GOTTPREL_G1)
2631                   .Case("gottprel_g0_nc", AArch64MCExpr::VK_GOTTPREL_G0_NC)
2632                   .Case("tlsdesc", AArch64MCExpr::VK_TLSDESC_PAGE)
2633                   .Default(AArch64MCExpr::VK_INVALID);
2634
2635     if (RefKind == AArch64MCExpr::VK_INVALID)
2636       return TokError("expect relocation specifier in operand after ':'");
2637
2638     Parser.Lex(); // Eat identifier
2639
2640     if (parseToken(AsmToken::Colon, "expect ':' after relocation specifier"))
2641       return true;
2642   }
2643
2644   if (getParser().parseExpression(ImmVal))
2645     return true;
2646
2647   if (HasELFModifier)
2648     ImmVal = AArch64MCExpr::create(ImmVal, RefKind, getContext());
2649
2650   return false;
2651 }
2652
2653 /// parseVectorList - Parse a vector list operand for AdvSIMD instructions.
2654 bool AArch64AsmParser::parseVectorList(OperandVector &Operands) {
2655   MCAsmParser &Parser = getParser();
2656   assert(Parser.getTok().is(AsmToken::LCurly) && "Token is not a Left Bracket");
2657   SMLoc S = getLoc();
2658   Parser.Lex(); // Eat left bracket token.
2659   StringRef Kind;
2660   int64_t FirstReg = tryMatchVectorRegister(Kind, true);
2661   if (FirstReg == -1)
2662     return true;
2663   int64_t PrevReg = FirstReg;
2664   unsigned Count = 1;
2665
2666   if (parseOptionalToken(AsmToken::Minus)) {
2667     SMLoc Loc = getLoc();
2668     StringRef NextKind;
2669     int64_t Reg = tryMatchVectorRegister(NextKind, true);
2670     if (Reg == -1)
2671       return true;
2672     // Any Kind suffices must match on all regs in the list.
2673     if (Kind != NextKind)
2674       return Error(Loc, "mismatched register size suffix");
2675
2676     unsigned Space = (PrevReg < Reg) ? (Reg - PrevReg) : (Reg + 32 - PrevReg);
2677
2678     if (Space == 0 || Space > 3) {
2679       return Error(Loc, "invalid number of vectors");
2680     }
2681
2682     Count += Space;
2683   }
2684   else {
2685     while (parseOptionalToken(AsmToken::Comma)) {
2686       SMLoc Loc = getLoc();
2687       StringRef NextKind;
2688       int64_t Reg = tryMatchVectorRegister(NextKind, true);
2689       if (Reg == -1)
2690         return true;
2691       // Any Kind suffices must match on all regs in the list.
2692       if (Kind != NextKind)
2693         return Error(Loc, "mismatched register size suffix");
2694
2695       // Registers must be incremental (with wraparound at 31)
2696       if (getContext().getRegisterInfo()->getEncodingValue(Reg) !=
2697           (getContext().getRegisterInfo()->getEncodingValue(PrevReg) + 1) % 32)
2698        return Error(Loc, "registers must be sequential");
2699
2700       PrevReg = Reg;
2701       ++Count;
2702     }
2703   }
2704
2705   if (parseToken(AsmToken::RCurly, "'}' expected"))
2706     return true;
2707
2708   if (Count > 4)
2709     return Error(S, "invalid number of vectors");
2710
2711   unsigned NumElements = 0;
2712   char ElementKind = 0;
2713   if (!Kind.empty())
2714     parseValidVectorKind(Kind, NumElements, ElementKind);
2715
2716   Operands.push_back(AArch64Operand::CreateVectorList(
2717       FirstReg, Count, NumElements, ElementKind, S, getLoc(), getContext()));
2718
2719   // If there is an index specifier following the list, parse that too.
2720   SMLoc SIdx = getLoc();
2721   if (parseOptionalToken(AsmToken::LBrac)) { // Eat left bracket token.
2722     const MCExpr *ImmVal;
2723     if (getParser().parseExpression(ImmVal))
2724       return false;
2725     const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(ImmVal);
2726     if (!MCE) {
2727       TokError("immediate value expected for vector index");
2728       return false;
2729     }
2730
2731     SMLoc E = getLoc();
2732     if (parseToken(AsmToken::RBrac, "']' expected"))
2733       return false;
2734
2735     Operands.push_back(AArch64Operand::CreateVectorIndex(MCE->getValue(), SIdx,
2736                                                          E, getContext()));
2737   }
2738   return false;
2739 }
2740
2741 OperandMatchResultTy
2742 AArch64AsmParser::tryParseGPR64sp0Operand(OperandVector &Operands) {
2743   MCAsmParser &Parser = getParser();
2744   const AsmToken &Tok = Parser.getTok();
2745   if (!Tok.is(AsmToken::Identifier))
2746     return MatchOperand_NoMatch;
2747
2748   unsigned RegNum = matchRegisterNameAlias(Tok.getString().lower(), false);
2749
2750   MCContext &Ctx = getContext();
2751   const MCRegisterInfo *RI = Ctx.getRegisterInfo();
2752   if (!RI->getRegClass(AArch64::GPR64spRegClassID).contains(RegNum))
2753     return MatchOperand_NoMatch;
2754
2755   SMLoc S = getLoc();
2756   Parser.Lex(); // Eat register
2757
2758   if (!parseOptionalToken(AsmToken::Comma)) {
2759     Operands.push_back(
2760         AArch64Operand::CreateReg(RegNum, false, S, getLoc(), Ctx));
2761     return MatchOperand_Success;
2762   }
2763
2764   parseOptionalToken(AsmToken::Hash);
2765
2766   if (Parser.getTok().isNot(AsmToken::Integer)) {
2767     Error(getLoc(), "index must be absent or #0");
2768     return MatchOperand_ParseFail;
2769   }
2770
2771   const MCExpr *ImmVal;
2772   if (Parser.parseExpression(ImmVal) || !isa<MCConstantExpr>(ImmVal) ||
2773       cast<MCConstantExpr>(ImmVal)->getValue() != 0) {
2774     Error(getLoc(), "index must be absent or #0");
2775     return MatchOperand_ParseFail;
2776   }
2777
2778   Operands.push_back(
2779       AArch64Operand::CreateReg(RegNum, false, S, getLoc(), Ctx));
2780   return MatchOperand_Success;
2781 }
2782
2783 /// parseOperand - Parse a arm instruction operand.  For now this parses the
2784 /// operand regardless of the mnemonic.
2785 bool AArch64AsmParser::parseOperand(OperandVector &Operands, bool isCondCode,
2786                                   bool invertCondCode) {
2787   MCAsmParser &Parser = getParser();
2788   // Check if the current operand has a custom associated parser, if so, try to
2789   // custom parse the operand, or fallback to the general approach.
2790   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
2791   if (ResTy == MatchOperand_Success)
2792     return false;
2793   // If there wasn't a custom match, try the generic matcher below. Otherwise,
2794   // there was a match, but an error occurred, in which case, just return that
2795   // the operand parsing failed.
2796   if (ResTy == MatchOperand_ParseFail)
2797     return true;
2798
2799   // Nothing custom, so do general case parsing.
2800   SMLoc S, E;
2801   switch (getLexer().getKind()) {
2802   default: {
2803     SMLoc S = getLoc();
2804     const MCExpr *Expr;
2805     if (parseSymbolicImmVal(Expr))
2806       return Error(S, "invalid operand");
2807
2808     SMLoc E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2809     Operands.push_back(AArch64Operand::CreateImm(Expr, S, E, getContext()));
2810     return false;
2811   }
2812   case AsmToken::LBrac: {
2813     SMLoc Loc = Parser.getTok().getLoc();
2814     Operands.push_back(AArch64Operand::CreateToken("[", false, Loc,
2815                                                    getContext()));
2816     Parser.Lex(); // Eat '['
2817
2818     // There's no comma after a '[', so we can parse the next operand
2819     // immediately.
2820     return parseOperand(Operands, false, false);
2821   }
2822   case AsmToken::LCurly:
2823     return parseVectorList(Operands);
2824   case AsmToken::Identifier: {
2825     // If we're expecting a Condition Code operand, then just parse that.
2826     if (isCondCode)
2827       return parseCondCode(Operands, invertCondCode);
2828
2829     // If it's a register name, parse it.
2830     if (!parseRegister(Operands))
2831       return false;
2832
2833     // This could be an optional "shift" or "extend" operand.
2834     OperandMatchResultTy GotShift = tryParseOptionalShiftExtend(Operands);
2835     // We can only continue if no tokens were eaten.
2836     if (GotShift != MatchOperand_NoMatch)
2837       return GotShift;
2838
2839     // This was not a register so parse other operands that start with an
2840     // identifier (like labels) as expressions and create them as immediates.
2841     const MCExpr *IdVal;
2842     S = getLoc();
2843     if (getParser().parseExpression(IdVal))
2844       return true;
2845     E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2846     Operands.push_back(AArch64Operand::CreateImm(IdVal, S, E, getContext()));
2847     return false;
2848   }
2849   case AsmToken::Integer:
2850   case AsmToken::Real:
2851   case AsmToken::Hash: {
2852     // #42 -> immediate.
2853     S = getLoc();
2854
2855     parseOptionalToken(AsmToken::Hash);
2856
2857     // Parse a negative sign
2858     bool isNegative = false;
2859     if (Parser.getTok().is(AsmToken::Minus)) {
2860       isNegative = true;
2861       // We need to consume this token only when we have a Real, otherwise
2862       // we let parseSymbolicImmVal take care of it
2863       if (Parser.getLexer().peekTok().is(AsmToken::Real))
2864         Parser.Lex();
2865     }
2866
2867     // The only Real that should come through here is a literal #0.0 for
2868     // the fcmp[e] r, #0.0 instructions. They expect raw token operands,
2869     // so convert the value.
2870     const AsmToken &Tok = Parser.getTok();
2871     if (Tok.is(AsmToken::Real)) {
2872       APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
2873       uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
2874       if (Mnemonic != "fcmp" && Mnemonic != "fcmpe" && Mnemonic != "fcmeq" &&
2875           Mnemonic != "fcmge" && Mnemonic != "fcmgt" && Mnemonic != "fcmle" &&
2876           Mnemonic != "fcmlt")
2877         return TokError("unexpected floating point literal");
2878       else if (IntVal != 0 || isNegative)
2879         return TokError("expected floating-point constant #0.0");
2880       Parser.Lex(); // Eat the token.
2881
2882       Operands.push_back(
2883           AArch64Operand::CreateToken("#0", false, S, getContext()));
2884       Operands.push_back(
2885           AArch64Operand::CreateToken(".0", false, S, getContext()));
2886       return false;
2887     }
2888
2889     const MCExpr *ImmVal;
2890     if (parseSymbolicImmVal(ImmVal))
2891       return true;
2892
2893     E = SMLoc::getFromPointer(getLoc().getPointer() - 1);
2894     Operands.push_back(AArch64Operand::CreateImm(ImmVal, S, E, getContext()));
2895     return false;
2896   }
2897   case AsmToken::Equal: {
2898     SMLoc Loc = getLoc();
2899     if (Mnemonic != "ldr") // only parse for ldr pseudo (e.g. ldr r0, =val)
2900       return TokError("unexpected token in operand");
2901     Parser.Lex(); // Eat '='
2902     const MCExpr *SubExprVal;
2903     if (getParser().parseExpression(SubExprVal))
2904       return true;
2905
2906     if (Operands.size() < 2 ||
2907         !static_cast<AArch64Operand &>(*Operands[1]).isReg())
2908       return Error(Loc, "Only valid when first operand is register");
2909
2910     bool IsXReg =
2911         AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
2912             Operands[1]->getReg());
2913
2914     MCContext& Ctx = getContext();
2915     E = SMLoc::getFromPointer(Loc.getPointer() - 1);
2916     // If the op is an imm and can be fit into a mov, then replace ldr with mov.
2917     if (isa<MCConstantExpr>(SubExprVal)) {
2918       uint64_t Imm = (cast<MCConstantExpr>(SubExprVal))->getValue();
2919       uint32_t ShiftAmt = 0, MaxShiftAmt = IsXReg ? 48 : 16;
2920       while(Imm > 0xFFFF && countTrailingZeros(Imm) >= 16) {
2921         ShiftAmt += 16;
2922         Imm >>= 16;
2923       }
2924       if (ShiftAmt <= MaxShiftAmt && Imm <= 0xFFFF) {
2925           Operands[0] = AArch64Operand::CreateToken("movz", false, Loc, Ctx);
2926           Operands.push_back(AArch64Operand::CreateImm(
2927                      MCConstantExpr::create(Imm, Ctx), S, E, Ctx));
2928         if (ShiftAmt)
2929           Operands.push_back(AArch64Operand::CreateShiftExtend(AArch64_AM::LSL,
2930                      ShiftAmt, true, S, E, Ctx));
2931         return false;
2932       }
2933       APInt Simm = APInt(64, Imm << ShiftAmt);
2934       // check if the immediate is an unsigned or signed 32-bit int for W regs
2935       if (!IsXReg && !(Simm.isIntN(32) || Simm.isSignedIntN(32)))
2936         return Error(Loc, "Immediate too large for register");
2937     }
2938     // If it is a label or an imm that cannot fit in a movz, put it into CP.
2939     const MCExpr *CPLoc =
2940         getTargetStreamer().addConstantPoolEntry(SubExprVal, IsXReg ? 8 : 4, Loc);
2941     Operands.push_back(AArch64Operand::CreateImm(CPLoc, S, E, Ctx));
2942     return false;
2943   }
2944   }
2945 }
2946
2947 /// ParseInstruction - Parse an AArch64 instruction mnemonic followed by its
2948 /// operands.
2949 bool AArch64AsmParser::ParseInstruction(ParseInstructionInfo &Info,
2950                                         StringRef Name, SMLoc NameLoc,
2951                                         OperandVector &Operands) {
2952   MCAsmParser &Parser = getParser();
2953   Name = StringSwitch<StringRef>(Name.lower())
2954              .Case("beq", "b.eq")
2955              .Case("bne", "b.ne")
2956              .Case("bhs", "b.hs")
2957              .Case("bcs", "b.cs")
2958              .Case("blo", "b.lo")
2959              .Case("bcc", "b.cc")
2960              .Case("bmi", "b.mi")
2961              .Case("bpl", "b.pl")
2962              .Case("bvs", "b.vs")
2963              .Case("bvc", "b.vc")
2964              .Case("bhi", "b.hi")
2965              .Case("bls", "b.ls")
2966              .Case("bge", "b.ge")
2967              .Case("blt", "b.lt")
2968              .Case("bgt", "b.gt")
2969              .Case("ble", "b.le")
2970              .Case("bal", "b.al")
2971              .Case("bnv", "b.nv")
2972              .Default(Name);
2973
2974   // First check for the AArch64-specific .req directive.
2975   if (Parser.getTok().is(AsmToken::Identifier) &&
2976       Parser.getTok().getIdentifier() == ".req") {
2977     parseDirectiveReq(Name, NameLoc);
2978     // We always return 'error' for this, as we're done with this
2979     // statement and don't need to match the 'instruction."
2980     return true;
2981   }
2982
2983   // Create the leading tokens for the mnemonic, split by '.' characters.
2984   size_t Start = 0, Next = Name.find('.');
2985   StringRef Head = Name.slice(Start, Next);
2986
2987   // IC, DC, AT, and TLBI instructions are aliases for the SYS instruction.
2988   if (Head == "ic" || Head == "dc" || Head == "at" || Head == "tlbi")
2989     return parseSysAlias(Head, NameLoc, Operands);
2990
2991   Operands.push_back(
2992       AArch64Operand::CreateToken(Head, false, NameLoc, getContext()));
2993   Mnemonic = Head;
2994
2995   // Handle condition codes for a branch mnemonic
2996   if (Head == "b" && Next != StringRef::npos) {
2997     Start = Next;
2998     Next = Name.find('.', Start + 1);
2999     Head = Name.slice(Start + 1, Next);
3000
3001     SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3002                                             (Head.data() - Name.data()));
3003     AArch64CC::CondCode CC = parseCondCodeString(Head);
3004     if (CC == AArch64CC::Invalid)
3005       return Error(SuffixLoc, "invalid condition code");
3006     Operands.push_back(
3007         AArch64Operand::CreateToken(".", true, SuffixLoc, getContext()));
3008     Operands.push_back(
3009         AArch64Operand::CreateCondCode(CC, NameLoc, NameLoc, getContext()));
3010   }
3011
3012   // Add the remaining tokens in the mnemonic.
3013   while (Next != StringRef::npos) {
3014     Start = Next;
3015     Next = Name.find('.', Start + 1);
3016     Head = Name.slice(Start, Next);
3017     SMLoc SuffixLoc = SMLoc::getFromPointer(NameLoc.getPointer() +
3018                                             (Head.data() - Name.data()) + 1);
3019     Operands.push_back(
3020         AArch64Operand::CreateToken(Head, true, SuffixLoc, getContext()));
3021   }
3022
3023   // Conditional compare instructions have a Condition Code operand, which needs
3024   // to be parsed and an immediate operand created.
3025   bool condCodeFourthOperand =
3026       (Head == "ccmp" || Head == "ccmn" || Head == "fccmp" ||
3027        Head == "fccmpe" || Head == "fcsel" || Head == "csel" ||
3028        Head == "csinc" || Head == "csinv" || Head == "csneg");
3029
3030   // These instructions are aliases to some of the conditional select
3031   // instructions. However, the condition code is inverted in the aliased
3032   // instruction.
3033   //
3034   // FIXME: Is this the correct way to handle these? Or should the parser
3035   //        generate the aliased instructions directly?
3036   bool condCodeSecondOperand = (Head == "cset" || Head == "csetm");
3037   bool condCodeThirdOperand =
3038       (Head == "cinc" || Head == "cinv" || Head == "cneg");
3039
3040   // Read the remaining operands.
3041   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3042     // Read the first operand.
3043     if (parseOperand(Operands, false, false)) {
3044       return true;
3045     }
3046
3047     unsigned N = 2;
3048     while (parseOptionalToken(AsmToken::Comma)) {
3049       // Parse and remember the operand.
3050       if (parseOperand(Operands, (N == 4 && condCodeFourthOperand) ||
3051                                      (N == 3 && condCodeThirdOperand) ||
3052                                      (N == 2 && condCodeSecondOperand),
3053                        condCodeSecondOperand || condCodeThirdOperand)) {
3054         return true;
3055       }
3056
3057       // After successfully parsing some operands there are two special cases to
3058       // consider (i.e. notional operands not separated by commas). Both are due
3059       // to memory specifiers:
3060       //  + An RBrac will end an address for load/store/prefetch
3061       //  + An '!' will indicate a pre-indexed operation.
3062       //
3063       // It's someone else's responsibility to make sure these tokens are sane
3064       // in the given context!
3065
3066       SMLoc RLoc = Parser.getTok().getLoc();
3067       if (parseOptionalToken(AsmToken::RBrac))
3068         Operands.push_back(
3069             AArch64Operand::CreateToken("]", false, RLoc, getContext()));
3070       SMLoc ELoc = Parser.getTok().getLoc();
3071       if (parseOptionalToken(AsmToken::Exclaim))
3072         Operands.push_back(
3073             AArch64Operand::CreateToken("!", false, ELoc, getContext()));
3074
3075       ++N;
3076     }
3077   }
3078
3079   if (parseToken(AsmToken::EndOfStatement, "unexpected token in argument list"))
3080     return true;
3081
3082   return false;
3083 }
3084
3085 // FIXME: This entire function is a giant hack to provide us with decent
3086 // operand range validation/diagnostics until TableGen/MC can be extended
3087 // to support autogeneration of this kind of validation.
3088 bool AArch64AsmParser::validateInstruction(MCInst &Inst,
3089                                          SmallVectorImpl<SMLoc> &Loc) {
3090   const MCRegisterInfo *RI = getContext().getRegisterInfo();
3091   // Check for indexed addressing modes w/ the base register being the
3092   // same as a destination/source register or pair load where
3093   // the Rt == Rt2. All of those are undefined behaviour.
3094   switch (Inst.getOpcode()) {
3095   case AArch64::LDPSWpre:
3096   case AArch64::LDPWpost:
3097   case AArch64::LDPWpre:
3098   case AArch64::LDPXpost:
3099   case AArch64::LDPXpre: {
3100     unsigned Rt = Inst.getOperand(1).getReg();
3101     unsigned Rt2 = Inst.getOperand(2).getReg();
3102     unsigned Rn = Inst.getOperand(3).getReg();
3103     if (RI->isSubRegisterEq(Rn, Rt))
3104       return Error(Loc[0], "unpredictable LDP instruction, writeback base "
3105                            "is also a destination");
3106     if (RI->isSubRegisterEq(Rn, Rt2))
3107       return Error(Loc[1], "unpredictable LDP instruction, writeback base "
3108                            "is also a destination");
3109     LLVM_FALLTHROUGH;
3110   }
3111   case AArch64::LDPDi:
3112   case AArch64::LDPQi:
3113   case AArch64::LDPSi:
3114   case AArch64::LDPSWi:
3115   case AArch64::LDPWi:
3116   case AArch64::LDPXi: {
3117     unsigned Rt = Inst.getOperand(0).getReg();
3118     unsigned Rt2 = Inst.getOperand(1).getReg();
3119     if (Rt == Rt2)
3120       return Error(Loc[1], "unpredictable LDP instruction, Rt2==Rt");
3121     break;
3122   }
3123   case AArch64::LDPDpost:
3124   case AArch64::LDPDpre:
3125   case AArch64::LDPQpost:
3126   case AArch64::LDPQpre:
3127   case AArch64::LDPSpost:
3128   case AArch64::LDPSpre:
3129   case AArch64::LDPSWpost: {
3130     unsigned Rt = Inst.getOperand(1).getReg();
3131     unsigned Rt2 = Inst.getOperand(2).getReg();
3132     if (Rt == Rt2)
3133       return Error(Loc[1], "unpredictable LDP instruction, Rt2==Rt");
3134     break;
3135   }
3136   case AArch64::STPDpost:
3137   case AArch64::STPDpre:
3138   case AArch64::STPQpost:
3139   case AArch64::STPQpre:
3140   case AArch64::STPSpost:
3141   case AArch64::STPSpre:
3142   case AArch64::STPWpost:
3143   case AArch64::STPWpre:
3144   case AArch64::STPXpost:
3145   case AArch64::STPXpre: {
3146     unsigned Rt = Inst.getOperand(1).getReg();
3147     unsigned Rt2 = Inst.getOperand(2).getReg();
3148     unsigned Rn = Inst.getOperand(3).getReg();
3149     if (RI->isSubRegisterEq(Rn, Rt))
3150       return Error(Loc[0], "unpredictable STP instruction, writeback base "
3151                            "is also a source");
3152     if (RI->isSubRegisterEq(Rn, Rt2))
3153       return Error(Loc[1], "unpredictable STP instruction, writeback base "
3154                            "is also a source");
3155     break;
3156   }
3157   case AArch64::LDRBBpre:
3158   case AArch64::LDRBpre:
3159   case AArch64::LDRHHpre:
3160   case AArch64::LDRHpre:
3161   case AArch64::LDRSBWpre:
3162   case AArch64::LDRSBXpre:
3163   case AArch64::LDRSHWpre:
3164   case AArch64::LDRSHXpre:
3165   case AArch64::LDRSWpre:
3166   case AArch64::LDRWpre:
3167   case AArch64::LDRXpre:
3168   case AArch64::LDRBBpost:
3169   case AArch64::LDRBpost:
3170   case AArch64::LDRHHpost:
3171   case AArch64::LDRHpost:
3172   case AArch64::LDRSBWpost:
3173   case AArch64::LDRSBXpost:
3174   case AArch64::LDRSHWpost:
3175   case AArch64::LDRSHXpost:
3176   case AArch64::LDRSWpost:
3177   case AArch64::LDRWpost:
3178   case AArch64::LDRXpost: {
3179     unsigned Rt = Inst.getOperand(1).getReg();
3180     unsigned Rn = Inst.getOperand(2).getReg();
3181     if (RI->isSubRegisterEq(Rn, Rt))
3182       return Error(Loc[0], "unpredictable LDR instruction, writeback base "
3183                            "is also a source");
3184     break;
3185   }
3186   case AArch64::STRBBpost:
3187   case AArch64::STRBpost:
3188   case AArch64::STRHHpost:
3189   case AArch64::STRHpost:
3190   case AArch64::STRWpost:
3191   case AArch64::STRXpost:
3192   case AArch64::STRBBpre:
3193   case AArch64::STRBpre:
3194   case AArch64::STRHHpre:
3195   case AArch64::STRHpre:
3196   case AArch64::STRWpre:
3197   case AArch64::STRXpre: {
3198     unsigned Rt = Inst.getOperand(1).getReg();
3199     unsigned Rn = Inst.getOperand(2).getReg();
3200     if (RI->isSubRegisterEq(Rn, Rt))
3201       return Error(Loc[0], "unpredictable STR instruction, writeback base "
3202                            "is also a source");
3203     break;
3204   }
3205   }
3206
3207   // Now check immediate ranges. Separate from the above as there is overlap
3208   // in the instructions being checked and this keeps the nested conditionals
3209   // to a minimum.
3210   switch (Inst.getOpcode()) {
3211   case AArch64::ADDSWri:
3212   case AArch64::ADDSXri:
3213   case AArch64::ADDWri:
3214   case AArch64::ADDXri:
3215   case AArch64::SUBSWri:
3216   case AArch64::SUBSXri:
3217   case AArch64::SUBWri:
3218   case AArch64::SUBXri: {
3219     // Annoyingly we can't do this in the isAddSubImm predicate, so there is
3220     // some slight duplication here.
3221     if (Inst.getOperand(2).isExpr()) {
3222       const MCExpr *Expr = Inst.getOperand(2).getExpr();
3223       AArch64MCExpr::VariantKind ELFRefKind;
3224       MCSymbolRefExpr::VariantKind DarwinRefKind;
3225       int64_t Addend;
3226       if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
3227
3228         // Only allow these with ADDXri.
3229         if ((DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
3230              DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF) &&
3231             Inst.getOpcode() == AArch64::ADDXri)
3232           return false;
3233
3234         // Only allow these with ADDXri/ADDWri
3235         if ((ELFRefKind == AArch64MCExpr::VK_LO12 ||
3236              ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
3237              ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
3238              ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
3239              ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
3240              ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
3241              ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
3242              ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12) &&
3243             (Inst.getOpcode() == AArch64::ADDXri ||
3244              Inst.getOpcode() == AArch64::ADDWri))
3245           return false;
3246
3247         // Don't allow symbol refs in the immediate field otherwise
3248         // Note: Loc.back() may be Loc[1] or Loc[2] depending on the number of
3249         // operands of the original instruction (i.e. 'add w0, w1, borked' vs
3250         // 'cmp w0, 'borked')
3251         return Error(Loc.back(), "invalid immediate expression");
3252       }
3253       // We don't validate more complex expressions here
3254     }
3255     return false;
3256   }
3257   default:
3258     return false;
3259   }
3260 }
3261
3262 bool AArch64AsmParser::showMatchError(SMLoc Loc, unsigned ErrCode) {
3263   switch (ErrCode) {
3264   case Match_MissingFeature:
3265     return Error(Loc,
3266                  "instruction requires a CPU feature not currently enabled");
3267   case Match_InvalidOperand:
3268     return Error(Loc, "invalid operand for instruction");
3269   case Match_InvalidSuffix:
3270     return Error(Loc, "invalid type suffix for instruction");
3271   case Match_InvalidCondCode:
3272     return Error(Loc, "expected AArch64 condition code");
3273   case Match_AddSubRegExtendSmall:
3274     return Error(Loc,
3275       "expected '[su]xt[bhw]' or 'lsl' with optional integer in range [0, 4]");
3276   case Match_AddSubRegExtendLarge:
3277     return Error(Loc,
3278       "expected 'sxtx' 'uxtx' or 'lsl' with optional integer in range [0, 4]");
3279   case Match_AddSubSecondSource:
3280     return Error(Loc,
3281       "expected compatible register, symbol or integer in range [0, 4095]");
3282   case Match_LogicalSecondSource:
3283     return Error(Loc, "expected compatible register or logical immediate");
3284   case Match_InvalidMovImm32Shift:
3285     return Error(Loc, "expected 'lsl' with optional integer 0 or 16");
3286   case Match_InvalidMovImm64Shift:
3287     return Error(Loc, "expected 'lsl' with optional integer 0, 16, 32 or 48");
3288   case Match_AddSubRegShift32:
3289     return Error(Loc,
3290        "expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 31]");
3291   case Match_AddSubRegShift64:
3292     return Error(Loc,
3293        "expected 'lsl', 'lsr' or 'asr' with optional integer in range [0, 63]");
3294   case Match_InvalidFPImm:
3295     return Error(Loc,
3296                  "expected compatible register or floating-point constant");
3297   case Match_InvalidMemoryIndexedSImm9:
3298     return Error(Loc, "index must be an integer in range [-256, 255].");
3299   case Match_InvalidMemoryIndexed4SImm7:
3300     return Error(Loc, "index must be a multiple of 4 in range [-256, 252].");
3301   case Match_InvalidMemoryIndexed8SImm7:
3302     return Error(Loc, "index must be a multiple of 8 in range [-512, 504].");
3303   case Match_InvalidMemoryIndexed16SImm7:
3304     return Error(Loc, "index must be a multiple of 16 in range [-1024, 1008].");
3305   case Match_InvalidMemoryWExtend8:
3306     return Error(Loc,
3307                  "expected 'uxtw' or 'sxtw' with optional shift of #0");
3308   case Match_InvalidMemoryWExtend16:
3309     return Error(Loc,
3310                  "expected 'uxtw' or 'sxtw' with optional shift of #0 or #1");
3311   case Match_InvalidMemoryWExtend32:
3312     return Error(Loc,
3313                  "expected 'uxtw' or 'sxtw' with optional shift of #0 or #2");
3314   case Match_InvalidMemoryWExtend64:
3315     return Error(Loc,
3316                  "expected 'uxtw' or 'sxtw' with optional shift of #0 or #3");
3317   case Match_InvalidMemoryWExtend128:
3318     return Error(Loc,
3319                  "expected 'uxtw' or 'sxtw' with optional shift of #0 or #4");
3320   case Match_InvalidMemoryXExtend8:
3321     return Error(Loc,
3322                  "expected 'lsl' or 'sxtx' with optional shift of #0");
3323   case Match_InvalidMemoryXExtend16:
3324     return Error(Loc,
3325                  "expected 'lsl' or 'sxtx' with optional shift of #0 or #1");
3326   case Match_InvalidMemoryXExtend32:
3327     return Error(Loc,
3328                  "expected 'lsl' or 'sxtx' with optional shift of #0 or #2");
3329   case Match_InvalidMemoryXExtend64:
3330     return Error(Loc,
3331                  "expected 'lsl' or 'sxtx' with optional shift of #0 or #3");
3332   case Match_InvalidMemoryXExtend128:
3333     return Error(Loc,
3334                  "expected 'lsl' or 'sxtx' with optional shift of #0 or #4");
3335   case Match_InvalidMemoryIndexed1:
3336     return Error(Loc, "index must be an integer in range [0, 4095].");
3337   case Match_InvalidMemoryIndexed2:
3338     return Error(Loc, "index must be a multiple of 2 in range [0, 8190].");
3339   case Match_InvalidMemoryIndexed4:
3340     return Error(Loc, "index must be a multiple of 4 in range [0, 16380].");
3341   case Match_InvalidMemoryIndexed8:
3342     return Error(Loc, "index must be a multiple of 8 in range [0, 32760].");
3343   case Match_InvalidMemoryIndexed16:
3344     return Error(Loc, "index must be a multiple of 16 in range [0, 65520].");
3345   case Match_InvalidImm0_1:
3346     return Error(Loc, "immediate must be an integer in range [0, 1].");
3347   case Match_InvalidImm0_7:
3348     return Error(Loc, "immediate must be an integer in range [0, 7].");
3349   case Match_InvalidImm0_15:
3350     return Error(Loc, "immediate must be an integer in range [0, 15].");
3351   case Match_InvalidImm0_31:
3352     return Error(Loc, "immediate must be an integer in range [0, 31].");
3353   case Match_InvalidImm0_63:
3354     return Error(Loc, "immediate must be an integer in range [0, 63].");
3355   case Match_InvalidImm0_127:
3356     return Error(Loc, "immediate must be an integer in range [0, 127].");
3357   case Match_InvalidImm0_255:
3358     return Error(Loc, "immediate must be an integer in range [0, 255].");
3359   case Match_InvalidImm0_65535:
3360     return Error(Loc, "immediate must be an integer in range [0, 65535].");
3361   case Match_InvalidImm1_8:
3362     return Error(Loc, "immediate must be an integer in range [1, 8].");
3363   case Match_InvalidImm1_16:
3364     return Error(Loc, "immediate must be an integer in range [1, 16].");
3365   case Match_InvalidImm1_32:
3366     return Error(Loc, "immediate must be an integer in range [1, 32].");
3367   case Match_InvalidImm1_64:
3368     return Error(Loc, "immediate must be an integer in range [1, 64].");
3369   case Match_InvalidIndex1:
3370     return Error(Loc, "expected lane specifier '[1]'");
3371   case Match_InvalidIndexB:
3372     return Error(Loc, "vector lane must be an integer in range [0, 15].");
3373   case Match_InvalidIndexH:
3374     return Error(Loc, "vector lane must be an integer in range [0, 7].");
3375   case Match_InvalidIndexS:
3376     return Error(Loc, "vector lane must be an integer in range [0, 3].");
3377   case Match_InvalidIndexD:
3378     return Error(Loc, "vector lane must be an integer in range [0, 1].");
3379   case Match_InvalidLabel:
3380     return Error(Loc, "expected label or encodable integer pc offset");
3381   case Match_MRS:
3382     return Error(Loc, "expected readable system register");
3383   case Match_MSR:
3384     return Error(Loc, "expected writable system register or pstate");
3385   case Match_MnemonicFail:
3386     return Error(Loc, "unrecognized instruction mnemonic");
3387   default:
3388     llvm_unreachable("unexpected error code!");
3389   }
3390 }
3391
3392 static const char *getSubtargetFeatureName(uint64_t Val);
3393
3394 bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
3395                                                OperandVector &Operands,
3396                                                MCStreamer &Out,
3397                                                uint64_t &ErrorInfo,
3398                                                bool MatchingInlineAsm) {
3399   assert(!Operands.empty() && "Unexpect empty operand list!");
3400   AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[0]);
3401   assert(Op.isToken() && "Leading operand should always be a mnemonic!");
3402
3403   StringRef Tok = Op.getToken();
3404   unsigned NumOperands = Operands.size();
3405
3406   if (NumOperands == 4 && Tok == "lsl") {
3407     AArch64Operand &Op2 = static_cast<AArch64Operand &>(*Operands[2]);
3408     AArch64Operand &Op3 = static_cast<AArch64Operand &>(*Operands[3]);
3409     if (Op2.isReg() && Op3.isImm()) {
3410       const MCConstantExpr *Op3CE = dyn_cast<MCConstantExpr>(Op3.getImm());
3411       if (Op3CE) {
3412         uint64_t Op3Val = Op3CE->getValue();
3413         uint64_t NewOp3Val = 0;
3414         uint64_t NewOp4Val = 0;
3415         if (AArch64MCRegisterClasses[AArch64::GPR32allRegClassID].contains(
3416                 Op2.getReg())) {
3417           NewOp3Val = (32 - Op3Val) & 0x1f;
3418           NewOp4Val = 31 - Op3Val;
3419         } else {
3420           NewOp3Val = (64 - Op3Val) & 0x3f;
3421           NewOp4Val = 63 - Op3Val;
3422         }
3423
3424         const MCExpr *NewOp3 = MCConstantExpr::create(NewOp3Val, getContext());
3425         const MCExpr *NewOp4 = MCConstantExpr::create(NewOp4Val, getContext());
3426
3427         Operands[0] = AArch64Operand::CreateToken(
3428             "ubfm", false, Op.getStartLoc(), getContext());
3429         Operands.push_back(AArch64Operand::CreateImm(
3430             NewOp4, Op3.getStartLoc(), Op3.getEndLoc(), getContext()));
3431         Operands[3] = AArch64Operand::CreateImm(NewOp3, Op3.getStartLoc(),
3432                                                 Op3.getEndLoc(), getContext());
3433       }
3434     }
3435   } else if (NumOperands == 4 && Tok == "bfc") {
3436     // FIXME: Horrible hack to handle BFC->BFM alias.
3437     AArch64Operand &Op1 = static_cast<AArch64Operand &>(*Operands[1]);
3438     AArch64Operand LSBOp = static_cast<AArch64Operand &>(*Operands[2]);
3439     AArch64Operand WidthOp = static_cast<AArch64Operand &>(*Operands[3]);
3440
3441     if (Op1.isReg() && LSBOp.isImm() && WidthOp.isImm()) {
3442       const MCConstantExpr *LSBCE = dyn_cast<MCConstantExpr>(LSBOp.getImm());
3443       const MCConstantExpr *WidthCE = dyn_cast<MCConstantExpr>(WidthOp.getImm());
3444
3445       if (LSBCE && WidthCE) {
3446         uint64_t LSB = LSBCE->getValue();
3447         uint64_t Width = WidthCE->getValue();
3448
3449         uint64_t RegWidth = 0;
3450         if (AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
3451                 Op1.getReg()))
3452           RegWidth = 64;
3453         else
3454           RegWidth = 32;
3455
3456         if (LSB >= RegWidth)
3457           return Error(LSBOp.getStartLoc(),
3458                        "expected integer in range [0, 31]");
3459         if (Width < 1 || Width > RegWidth)
3460           return Error(WidthOp.getStartLoc(),
3461                        "expected integer in range [1, 32]");
3462
3463         uint64_t ImmR = 0;
3464         if (RegWidth == 32)
3465           ImmR = (32 - LSB) & 0x1f;
3466         else
3467           ImmR = (64 - LSB) & 0x3f;
3468
3469         uint64_t ImmS = Width - 1;
3470
3471         if (ImmR != 0 && ImmS >= ImmR)
3472           return Error(WidthOp.getStartLoc(),
3473                        "requested insert overflows register");
3474
3475         const MCExpr *ImmRExpr = MCConstantExpr::create(ImmR, getContext());
3476         const MCExpr *ImmSExpr = MCConstantExpr::create(ImmS, getContext());
3477         Operands[0] = AArch64Operand::CreateToken(
3478               "bfm", false, Op.getStartLoc(), getContext());
3479         Operands[2] = AArch64Operand::CreateReg(
3480             RegWidth == 32 ? AArch64::WZR : AArch64::XZR, false, SMLoc(),
3481             SMLoc(), getContext());
3482         Operands[3] = AArch64Operand::CreateImm(
3483             ImmRExpr, LSBOp.getStartLoc(), LSBOp.getEndLoc(), getContext());
3484         Operands.emplace_back(
3485             AArch64Operand::CreateImm(ImmSExpr, WidthOp.getStartLoc(),
3486                                       WidthOp.getEndLoc(), getContext()));
3487       }
3488     }
3489   } else if (NumOperands == 5) {
3490     // FIXME: Horrible hack to handle the BFI -> BFM, SBFIZ->SBFM, and
3491     // UBFIZ -> UBFM aliases.
3492     if (Tok == "bfi" || Tok == "sbfiz" || Tok == "ubfiz") {
3493       AArch64Operand &Op1 = static_cast<AArch64Operand &>(*Operands[1]);
3494       AArch64Operand &Op3 = static_cast<AArch64Operand &>(*Operands[3]);
3495       AArch64Operand &Op4 = static_cast<AArch64Operand &>(*Operands[4]);
3496
3497       if (Op1.isReg() && Op3.isImm() && Op4.isImm()) {
3498         const MCConstantExpr *Op3CE = dyn_cast<MCConstantExpr>(Op3.getImm());
3499         const MCConstantExpr *Op4CE = dyn_cast<MCConstantExpr>(Op4.getImm());
3500
3501         if (Op3CE && Op4CE) {
3502           uint64_t Op3Val = Op3CE->getValue();
3503           uint64_t Op4Val = Op4CE->getValue();
3504
3505           uint64_t RegWidth = 0;
3506           if (AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
3507                   Op1.getReg()))
3508             RegWidth = 64;
3509           else
3510             RegWidth = 32;
3511
3512           if (Op3Val >= RegWidth)
3513             return Error(Op3.getStartLoc(),
3514                          "expected integer in range [0, 31]");
3515           if (Op4Val < 1 || Op4Val > RegWidth)
3516             return Error(Op4.getStartLoc(),
3517                          "expected integer in range [1, 32]");
3518
3519           uint64_t NewOp3Val = 0;
3520           if (RegWidth == 32)
3521             NewOp3Val = (32 - Op3Val) & 0x1f;
3522           else
3523             NewOp3Val = (64 - Op3Val) & 0x3f;
3524
3525           uint64_t NewOp4Val = Op4Val - 1;
3526
3527           if (NewOp3Val != 0 && NewOp4Val >= NewOp3Val)
3528             return Error(Op4.getStartLoc(),
3529                          "requested insert overflows register");
3530
3531           const MCExpr *NewOp3 =
3532               MCConstantExpr::create(NewOp3Val, getContext());
3533           const MCExpr *NewOp4 =
3534               MCConstantExpr::create(NewOp4Val, getContext());
3535           Operands[3] = AArch64Operand::CreateImm(
3536               NewOp3, Op3.getStartLoc(), Op3.getEndLoc(), getContext());
3537           Operands[4] = AArch64Operand::CreateImm(
3538               NewOp4, Op4.getStartLoc(), Op4.getEndLoc(), getContext());
3539           if (Tok == "bfi")
3540             Operands[0] = AArch64Operand::CreateToken(
3541                 "bfm", false, Op.getStartLoc(), getContext());
3542           else if (Tok == "sbfiz")
3543             Operands[0] = AArch64Operand::CreateToken(
3544                 "sbfm", false, Op.getStartLoc(), getContext());
3545           else if (Tok == "ubfiz")
3546             Operands[0] = AArch64Operand::CreateToken(
3547                 "ubfm", false, Op.getStartLoc(), getContext());
3548           else
3549             llvm_unreachable("No valid mnemonic for alias?");
3550         }
3551       }
3552
3553       // FIXME: Horrible hack to handle the BFXIL->BFM, SBFX->SBFM, and
3554       // UBFX -> UBFM aliases.
3555     } else if (NumOperands == 5 &&
3556                (Tok == "bfxil" || Tok == "sbfx" || Tok == "ubfx")) {
3557       AArch64Operand &Op1 = static_cast<AArch64Operand &>(*Operands[1]);
3558       AArch64Operand &Op3 = static_cast<AArch64Operand &>(*Operands[3]);
3559       AArch64Operand &Op4 = static_cast<AArch64Operand &>(*Operands[4]);
3560
3561       if (Op1.isReg() && Op3.isImm() && Op4.isImm()) {
3562         const MCConstantExpr *Op3CE = dyn_cast<MCConstantExpr>(Op3.getImm());
3563         const MCConstantExpr *Op4CE = dyn_cast<MCConstantExpr>(Op4.getImm());
3564
3565         if (Op3CE && Op4CE) {
3566           uint64_t Op3Val = Op3CE->getValue();
3567           uint64_t Op4Val = Op4CE->getValue();
3568
3569           uint64_t RegWidth = 0;
3570           if (AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
3571                   Op1.getReg()))
3572             RegWidth = 64;
3573           else
3574             RegWidth = 32;
3575
3576           if (Op3Val >= RegWidth)
3577             return Error(Op3.getStartLoc(),
3578                          "expected integer in range [0, 31]");
3579           if (Op4Val < 1 || Op4Val > RegWidth)
3580             return Error(Op4.getStartLoc(),
3581                          "expected integer in range [1, 32]");
3582
3583           uint64_t NewOp4Val = Op3Val + Op4Val - 1;
3584
3585           if (NewOp4Val >= RegWidth || NewOp4Val < Op3Val)
3586             return Error(Op4.getStartLoc(),
3587                          "requested extract overflows register");
3588
3589           const MCExpr *NewOp4 =
3590               MCConstantExpr::create(NewOp4Val, getContext());
3591           Operands[4] = AArch64Operand::CreateImm(
3592               NewOp4, Op4.getStartLoc(), Op4.getEndLoc(), getContext());
3593           if (Tok == "bfxil")
3594             Operands[0] = AArch64Operand::CreateToken(
3595                 "bfm", false, Op.getStartLoc(), getContext());
3596           else if (Tok == "sbfx")
3597             Operands[0] = AArch64Operand::CreateToken(
3598                 "sbfm", false, Op.getStartLoc(), getContext());
3599           else if (Tok == "ubfx")
3600             Operands[0] = AArch64Operand::CreateToken(
3601                 "ubfm", false, Op.getStartLoc(), getContext());
3602           else
3603             llvm_unreachable("No valid mnemonic for alias?");
3604         }
3605       }
3606     }
3607   }
3608   // FIXME: Horrible hack for sxtw and uxtw with Wn src and Xd dst operands.
3609   //        InstAlias can't quite handle this since the reg classes aren't
3610   //        subclasses.
3611   if (NumOperands == 3 && (Tok == "sxtw" || Tok == "uxtw")) {
3612     // The source register can be Wn here, but the matcher expects a
3613     // GPR64. Twiddle it here if necessary.
3614     AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[2]);
3615     if (Op.isReg()) {
3616       unsigned Reg = getXRegFromWReg(Op.getReg());
3617       Operands[2] = AArch64Operand::CreateReg(Reg, false, Op.getStartLoc(),
3618                                               Op.getEndLoc(), getContext());
3619     }
3620   }
3621   // FIXME: Likewise for sxt[bh] with a Xd dst operand
3622   else if (NumOperands == 3 && (Tok == "sxtb" || Tok == "sxth")) {
3623     AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[1]);
3624     if (Op.isReg() &&
3625         AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
3626             Op.getReg())) {
3627       // The source register can be Wn here, but the matcher expects a
3628       // GPR64. Twiddle it here if necessary.
3629       AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[2]);
3630       if (Op.isReg()) {
3631         unsigned Reg = getXRegFromWReg(Op.getReg());
3632         Operands[2] = AArch64Operand::CreateReg(Reg, false, Op.getStartLoc(),
3633                                                 Op.getEndLoc(), getContext());
3634       }
3635     }
3636   }
3637   // FIXME: Likewise for uxt[bh] with a Xd dst operand
3638   else if (NumOperands == 3 && (Tok == "uxtb" || Tok == "uxth")) {
3639     AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[1]);
3640     if (Op.isReg() &&
3641         AArch64MCRegisterClasses[AArch64::GPR64allRegClassID].contains(
3642             Op.getReg())) {
3643       // The source register can be Wn here, but the matcher expects a
3644       // GPR32. Twiddle it here if necessary.
3645       AArch64Operand &Op = static_cast<AArch64Operand &>(*Operands[1]);
3646       if (Op.isReg()) {
3647         unsigned Reg = getWRegFromXReg(Op.getReg());
3648         Operands[1] = AArch64Operand::CreateReg(Reg, false, Op.getStartLoc(),
3649                                                 Op.getEndLoc(), getContext());
3650       }
3651     }
3652   }
3653
3654   MCInst Inst;
3655   // First try to match against the secondary set of tables containing the
3656   // short-form NEON instructions (e.g. "fadd.2s v0, v1, v2").
3657   unsigned MatchResult =
3658       MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm, 1);
3659
3660   // If that fails, try against the alternate table containing long-form NEON:
3661   // "fadd v0.2s, v1.2s, v2.2s"
3662   if (MatchResult != Match_Success) {
3663     // But first, save the short-form match result: we can use it in case the
3664     // long-form match also fails.
3665     auto ShortFormNEONErrorInfo = ErrorInfo;
3666     auto ShortFormNEONMatchResult = MatchResult;
3667
3668     MatchResult =
3669         MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm, 0);
3670
3671     // Now, both matches failed, and the long-form match failed on the mnemonic
3672     // suffix token operand.  The short-form match failure is probably more
3673     // relevant: use it instead.
3674     if (MatchResult == Match_InvalidOperand && ErrorInfo == 1 &&
3675         Operands.size() > 1 && ((AArch64Operand &)*Operands[1]).isToken() &&
3676         ((AArch64Operand &)*Operands[1]).isTokenSuffix()) {
3677       MatchResult = ShortFormNEONMatchResult;
3678       ErrorInfo = ShortFormNEONErrorInfo;
3679     }
3680   }
3681
3682   switch (MatchResult) {
3683   case Match_Success: {
3684     // Perform range checking and other semantic validations
3685     SmallVector<SMLoc, 8> OperandLocs;
3686     NumOperands = Operands.size();
3687     for (unsigned i = 1; i < NumOperands; ++i)
3688       OperandLocs.push_back(Operands[i]->getStartLoc());
3689     if (validateInstruction(Inst, OperandLocs))
3690       return true;
3691
3692     Inst.setLoc(IDLoc);
3693     Out.EmitInstruction(Inst, getSTI());
3694     return false;
3695   }
3696   case Match_MissingFeature: {
3697     assert(ErrorInfo && "Unknown missing feature!");
3698     // Special case the error message for the very common case where only
3699     // a single subtarget feature is missing (neon, e.g.).
3700     std::string Msg = "instruction requires:";
3701     uint64_t Mask = 1;
3702     for (unsigned i = 0; i < (sizeof(ErrorInfo)*8-1); ++i) {
3703       if (ErrorInfo & Mask) {
3704         Msg += " ";
3705         Msg += getSubtargetFeatureName(ErrorInfo & Mask);
3706       }
3707       Mask <<= 1;
3708     }
3709     return Error(IDLoc, Msg);
3710   }
3711   case Match_MnemonicFail:
3712     return showMatchError(IDLoc, MatchResult);
3713   case Match_InvalidOperand: {
3714     SMLoc ErrorLoc = IDLoc;
3715
3716     if (ErrorInfo != ~0ULL) {
3717       if (ErrorInfo >= Operands.size())
3718         return Error(IDLoc, "too few operands for instruction",
3719                      SMRange(IDLoc, getTok().getLoc()));
3720
3721       ErrorLoc = ((AArch64Operand &)*Operands[ErrorInfo]).getStartLoc();
3722       if (ErrorLoc == SMLoc())
3723         ErrorLoc = IDLoc;
3724     }
3725     // If the match failed on a suffix token operand, tweak the diagnostic
3726     // accordingly.
3727     if (((AArch64Operand &)*Operands[ErrorInfo]).isToken() &&
3728         ((AArch64Operand &)*Operands[ErrorInfo]).isTokenSuffix())
3729       MatchResult = Match_InvalidSuffix;
3730
3731     return showMatchError(ErrorLoc, MatchResult);
3732   }
3733   case Match_InvalidMemoryIndexed1:
3734   case Match_InvalidMemoryIndexed2:
3735   case Match_InvalidMemoryIndexed4:
3736   case Match_InvalidMemoryIndexed8:
3737   case Match_InvalidMemoryIndexed16:
3738   case Match_InvalidCondCode:
3739   case Match_AddSubRegExtendSmall:
3740   case Match_AddSubRegExtendLarge:
3741   case Match_AddSubSecondSource:
3742   case Match_LogicalSecondSource:
3743   case Match_AddSubRegShift32:
3744   case Match_AddSubRegShift64:
3745   case Match_InvalidMovImm32Shift:
3746   case Match_InvalidMovImm64Shift:
3747   case Match_InvalidFPImm:
3748   case Match_InvalidMemoryWExtend8:
3749   case Match_InvalidMemoryWExtend16:
3750   case Match_InvalidMemoryWExtend32:
3751   case Match_InvalidMemoryWExtend64:
3752   case Match_InvalidMemoryWExtend128:
3753   case Match_InvalidMemoryXExtend8:
3754   case Match_InvalidMemoryXExtend16:
3755   case Match_InvalidMemoryXExtend32:
3756   case Match_InvalidMemoryXExtend64:
3757   case Match_InvalidMemoryXExtend128:
3758   case Match_InvalidMemoryIndexed4SImm7:
3759   case Match_InvalidMemoryIndexed8SImm7:
3760   case Match_InvalidMemoryIndexed16SImm7:
3761   case Match_InvalidMemoryIndexedSImm9:
3762   case Match_InvalidImm0_1:
3763   case Match_InvalidImm0_7:
3764   case Match_InvalidImm0_15:
3765   case Match_InvalidImm0_31:
3766   case Match_InvalidImm0_63:
3767   case Match_InvalidImm0_127:
3768   case Match_InvalidImm0_255:
3769   case Match_InvalidImm0_65535:
3770   case Match_InvalidImm1_8:
3771   case Match_InvalidImm1_16:
3772   case Match_InvalidImm1_32:
3773   case Match_InvalidImm1_64:
3774   case Match_InvalidIndex1:
3775   case Match_InvalidIndexB:
3776   case Match_InvalidIndexH:
3777   case Match_InvalidIndexS:
3778   case Match_InvalidIndexD:
3779   case Match_InvalidLabel:
3780   case Match_MSR:
3781   case Match_MRS: {
3782     if (ErrorInfo >= Operands.size())
3783       return Error(IDLoc, "too few operands for instruction", SMRange(IDLoc, (*Operands.back()).getEndLoc()));
3784     // Any time we get here, there's nothing fancy to do. Just get the
3785     // operand SMLoc and display the diagnostic.
3786     SMLoc ErrorLoc = ((AArch64Operand &)*Operands[ErrorInfo]).getStartLoc();
3787     if (ErrorLoc == SMLoc())
3788       ErrorLoc = IDLoc;
3789     return showMatchError(ErrorLoc, MatchResult);
3790   }
3791   }
3792
3793   llvm_unreachable("Implement any new match types added!");
3794 }
3795
3796 /// ParseDirective parses the arm specific directives
3797 bool AArch64AsmParser::ParseDirective(AsmToken DirectiveID) {
3798   const MCObjectFileInfo::Environment Format =
3799     getContext().getObjectFileInfo()->getObjectFileType();
3800   bool IsMachO = Format == MCObjectFileInfo::IsMachO;
3801   bool IsCOFF = Format == MCObjectFileInfo::IsCOFF;
3802
3803   StringRef IDVal = DirectiveID.getIdentifier();
3804   SMLoc Loc = DirectiveID.getLoc();
3805   if (IDVal == ".arch")
3806     parseDirectiveArch(Loc);
3807   else if (IDVal == ".cpu")
3808     parseDirectiveCPU(Loc);
3809   else if (IDVal == ".hword")
3810     parseDirectiveWord(2, Loc);
3811   else if (IDVal == ".word")
3812     parseDirectiveWord(4, Loc);
3813   else if (IDVal == ".xword")
3814     parseDirectiveWord(8, Loc);
3815   else if (IDVal == ".tlsdesccall")
3816     parseDirectiveTLSDescCall(Loc);
3817   else if (IDVal == ".ltorg" || IDVal == ".pool")
3818     parseDirectiveLtorg(Loc);
3819   else if (IDVal == ".unreq")
3820     parseDirectiveUnreq(Loc);
3821   else if (!IsMachO && !IsCOFF) {
3822     if (IDVal == ".inst")
3823       parseDirectiveInst(Loc);
3824     else
3825       return true;
3826   } else if (IDVal == MCLOHDirectiveName())
3827     parseDirectiveLOH(IDVal, Loc);
3828   else
3829     return true;
3830   return false;
3831 }
3832
3833 static const struct {
3834   const char *Name;
3835   const FeatureBitset Features;
3836 } ExtensionMap[] = {
3837   { "crc", {AArch64::FeatureCRC} },
3838   { "crypto", {AArch64::FeatureCrypto} },
3839   { "fp", {AArch64::FeatureFPARMv8} },
3840   { "simd", {AArch64::FeatureNEON} },
3841   { "ras", {AArch64::FeatureRAS} },
3842   { "lse", {AArch64::FeatureLSE} },
3843
3844   // FIXME: Unsupported extensions
3845   { "pan", {} },
3846   { "lor", {} },
3847   { "rdma", {} },
3848   { "profile", {} },
3849 };
3850
3851 /// parseDirectiveArch
3852 ///   ::= .arch token
3853 bool AArch64AsmParser::parseDirectiveArch(SMLoc L) {
3854   SMLoc ArchLoc = getLoc();
3855
3856   StringRef Arch, ExtensionString;
3857   std::tie(Arch, ExtensionString) =
3858       getParser().parseStringToEndOfStatement().trim().split('+');
3859
3860   unsigned ID = AArch64::parseArch(Arch);
3861   if (ID == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID))
3862     return Error(ArchLoc, "unknown arch name");
3863
3864   if (parseToken(AsmToken::EndOfStatement))
3865     return true;
3866
3867   // Get the architecture and extension features.
3868   std::vector<StringRef> AArch64Features;
3869   AArch64::getArchFeatures(ID, AArch64Features);
3870   AArch64::getExtensionFeatures(AArch64::getDefaultExtensions("generic", ID),
3871                                 AArch64Features);
3872
3873   MCSubtargetInfo &STI = copySTI();
3874   std::vector<std::string> ArchFeatures(AArch64Features.begin(), AArch64Features.end());
3875   STI.setDefaultFeatures("generic", join(ArchFeatures.begin(), ArchFeatures.end(), ","));
3876
3877   SmallVector<StringRef, 4> RequestedExtensions;
3878   if (!ExtensionString.empty())
3879     ExtensionString.split(RequestedExtensions, '+');
3880
3881   FeatureBitset Features = STI.getFeatureBits();
3882   for (auto Name : RequestedExtensions) {
3883     bool EnableFeature = true;
3884
3885     if (Name.startswith_lower("no")) {
3886       EnableFeature = false;
3887       Name = Name.substr(2);
3888     }
3889
3890     for (const auto &Extension : ExtensionMap) {
3891       if (Extension.Name != Name)
3892         continue;
3893
3894       if (Extension.Features.none())
3895         report_fatal_error("unsupported architectural extension: " + Name);
3896
3897       FeatureBitset ToggleFeatures = EnableFeature
3898                                          ? (~Features & Extension.Features)
3899                                          : ( Features & Extension.Features);
3900       uint64_t Features =
3901           ComputeAvailableFeatures(STI.ToggleFeature(ToggleFeatures));
3902       setAvailableFeatures(Features);
3903       break;
3904     }
3905   }
3906   return false;
3907 }
3908
3909 /// parseDirectiveCPU
3910 ///   ::= .cpu id
3911 bool AArch64AsmParser::parseDirectiveCPU(SMLoc L) {
3912   SMLoc CPULoc = getLoc();
3913
3914   StringRef CPU, ExtensionString;
3915   std::tie(CPU, ExtensionString) =
3916       getParser().parseStringToEndOfStatement().trim().split('+');
3917
3918   if (parseToken(AsmToken::EndOfStatement))
3919     return true;
3920
3921   SmallVector<StringRef, 4> RequestedExtensions;
3922   if (!ExtensionString.empty())
3923     ExtensionString.split(RequestedExtensions, '+');
3924
3925   // FIXME This is using tablegen data, but should be moved to ARMTargetParser
3926   // once that is tablegen'ed
3927   if (!getSTI().isCPUStringValid(CPU)) {
3928     Error(CPULoc, "unknown CPU name");
3929     return false;
3930   }
3931
3932   MCSubtargetInfo &STI = copySTI();
3933   STI.setDefaultFeatures(CPU, "");
3934
3935   FeatureBitset Features = STI.getFeatureBits();
3936   for (auto Name : RequestedExtensions) {
3937     bool EnableFeature = true;
3938
3939     if (Name.startswith_lower("no")) {
3940       EnableFeature = false;
3941       Name = Name.substr(2);
3942     }
3943
3944     for (const auto &Extension : ExtensionMap) {
3945       if (Extension.Name != Name)
3946         continue;
3947
3948       if (Extension.Features.none())
3949         report_fatal_error("unsupported architectural extension: " + Name);
3950
3951       FeatureBitset ToggleFeatures = EnableFeature
3952                                          ? (~Features & Extension.Features)
3953                                          : ( Features & Extension.Features);
3954       uint64_t Features =
3955           ComputeAvailableFeatures(STI.ToggleFeature(ToggleFeatures));
3956       setAvailableFeatures(Features);
3957
3958       break;
3959     }
3960   }
3961   return false;
3962 }
3963
3964 /// parseDirectiveWord
3965 ///  ::= .word [ expression (, expression)* ]
3966 bool AArch64AsmParser::parseDirectiveWord(unsigned Size, SMLoc L) {
3967   auto parseOp = [&]() -> bool {
3968     const MCExpr *Value;
3969     if (getParser().parseExpression(Value))
3970       return true;
3971     getParser().getStreamer().EmitValue(Value, Size, L);
3972     return false;
3973   };
3974
3975   if (parseMany(parseOp))
3976     return true;
3977   return false;
3978 }
3979
3980 /// parseDirectiveInst
3981 ///  ::= .inst opcode [, ...]
3982 bool AArch64AsmParser::parseDirectiveInst(SMLoc Loc) {
3983   if (getLexer().is(AsmToken::EndOfStatement))
3984     return Error(Loc, "expected expression following '.inst' directive");
3985
3986   auto parseOp = [&]() -> bool {
3987     SMLoc L = getLoc();
3988     const MCExpr *Expr;
3989     if (check(getParser().parseExpression(Expr), L, "expected expression"))
3990       return true;
3991     const MCConstantExpr *Value = dyn_cast_or_null<MCConstantExpr>(Expr);
3992     if (check(!Value, L, "expected constant expression"))
3993       return true;
3994     getTargetStreamer().emitInst(Value->getValue());
3995     return false;
3996   };
3997
3998   if (parseMany(parseOp))
3999     return addErrorSuffix(" in '.inst' directive");
4000   return false;
4001 }
4002
4003 // parseDirectiveTLSDescCall:
4004 //   ::= .tlsdesccall symbol
4005 bool AArch64AsmParser::parseDirectiveTLSDescCall(SMLoc L) {
4006   StringRef Name;
4007   if (check(getParser().parseIdentifier(Name), L,
4008             "expected symbol after directive") ||
4009       parseToken(AsmToken::EndOfStatement))
4010     return true;
4011
4012   MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
4013   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, getContext());
4014   Expr = AArch64MCExpr::create(Expr, AArch64MCExpr::VK_TLSDESC, getContext());
4015
4016   MCInst Inst;
4017   Inst.setOpcode(AArch64::TLSDESCCALL);
4018   Inst.addOperand(MCOperand::createExpr(Expr));
4019
4020   getParser().getStreamer().EmitInstruction(Inst, getSTI());
4021   return false;
4022 }
4023
4024 /// ::= .loh <lohName | lohId> label1, ..., labelN
4025 /// The number of arguments depends on the loh identifier.
4026 bool AArch64AsmParser::parseDirectiveLOH(StringRef IDVal, SMLoc Loc) {
4027   MCLOHType Kind;
4028   if (getParser().getTok().isNot(AsmToken::Identifier)) {
4029     if (getParser().getTok().isNot(AsmToken::Integer))
4030       return TokError("expected an identifier or a number in directive");
4031     // We successfully get a numeric value for the identifier.
4032     // Check if it is valid.
4033     int64_t Id = getParser().getTok().getIntVal();
4034     if (Id <= -1U && !isValidMCLOHType(Id))
4035       return TokError("invalid numeric identifier in directive");
4036     Kind = (MCLOHType)Id;
4037   } else {
4038     StringRef Name = getTok().getIdentifier();
4039     // We successfully parse an identifier.
4040     // Check if it is a recognized one.
4041     int Id = MCLOHNameToId(Name);
4042
4043     if (Id == -1)
4044       return TokError("invalid identifier in directive");
4045     Kind = (MCLOHType)Id;
4046   }
4047   // Consume the identifier.
4048   Lex();
4049   // Get the number of arguments of this LOH.
4050   int NbArgs = MCLOHIdToNbArgs(Kind);
4051
4052   assert(NbArgs != -1 && "Invalid number of arguments");
4053
4054   SmallVector<MCSymbol *, 3> Args;
4055   for (int Idx = 0; Idx < NbArgs; ++Idx) {
4056     StringRef Name;
4057     if (getParser().parseIdentifier(Name))
4058       return TokError("expected identifier in directive");
4059     Args.push_back(getContext().getOrCreateSymbol(Name));
4060
4061     if (Idx + 1 == NbArgs)
4062       break;
4063     if (parseToken(AsmToken::Comma,
4064                    "unexpected token in '" + Twine(IDVal) + "' directive"))
4065       return true;
4066   }
4067   if (parseToken(AsmToken::EndOfStatement,
4068                  "unexpected token in '" + Twine(IDVal) + "' directive"))
4069     return true;
4070
4071   getStreamer().EmitLOHDirective((MCLOHType)Kind, Args);
4072   return false;
4073 }
4074
4075 /// parseDirectiveLtorg
4076 ///  ::= .ltorg | .pool
4077 bool AArch64AsmParser::parseDirectiveLtorg(SMLoc L) {
4078   if (parseToken(AsmToken::EndOfStatement, "unexpected token in directive"))
4079     return true;
4080   getTargetStreamer().emitCurrentConstantPool();
4081   return false;
4082 }
4083
4084 /// parseDirectiveReq
4085 ///  ::= name .req registername
4086 bool AArch64AsmParser::parseDirectiveReq(StringRef Name, SMLoc L) {
4087   MCAsmParser &Parser = getParser();
4088   Parser.Lex(); // Eat the '.req' token.
4089   SMLoc SRegLoc = getLoc();
4090   unsigned RegNum = tryParseRegister();
4091   bool IsVector = false;
4092
4093   if (RegNum == static_cast<unsigned>(-1)) {
4094     StringRef Kind;
4095     RegNum = tryMatchVectorRegister(Kind, false);
4096     if (!Kind.empty())
4097       return Error(SRegLoc, "vector register without type specifier expected");
4098     IsVector = true;
4099   }
4100
4101   if (RegNum == static_cast<unsigned>(-1))
4102     return Error(SRegLoc, "register name or alias expected");
4103
4104   // Shouldn't be anything else.
4105   if (parseToken(AsmToken::EndOfStatement,
4106                  "unexpected input in .req directive"))
4107     return true;
4108
4109   auto pair = std::make_pair(IsVector, RegNum);
4110   if (RegisterReqs.insert(std::make_pair(Name, pair)).first->second != pair)
4111     Warning(L, "ignoring redefinition of register alias '" + Name + "'");
4112
4113   return false;
4114 }
4115
4116 /// parseDirectiveUneq
4117 ///  ::= .unreq registername
4118 bool AArch64AsmParser::parseDirectiveUnreq(SMLoc L) {
4119   MCAsmParser &Parser = getParser();
4120   if (getTok().isNot(AsmToken::Identifier))
4121     return TokError("unexpected input in .unreq directive.");
4122   RegisterReqs.erase(Parser.getTok().getIdentifier().lower());
4123   Parser.Lex(); // Eat the identifier.
4124   if (parseToken(AsmToken::EndOfStatement))
4125     return addErrorSuffix("in '.unreq' directive");
4126   return false;
4127 }
4128
4129 bool
4130 AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
4131                                     AArch64MCExpr::VariantKind &ELFRefKind,
4132                                     MCSymbolRefExpr::VariantKind &DarwinRefKind,
4133                                     int64_t &Addend) {
4134   ELFRefKind = AArch64MCExpr::VK_INVALID;
4135   DarwinRefKind = MCSymbolRefExpr::VK_None;
4136   Addend = 0;
4137
4138   if (const AArch64MCExpr *AE = dyn_cast<AArch64MCExpr>(Expr)) {
4139     ELFRefKind = AE->getKind();
4140     Expr = AE->getSubExpr();
4141   }
4142
4143   const MCSymbolRefExpr *SE = dyn_cast<MCSymbolRefExpr>(Expr);
4144   if (SE) {
4145     // It's a simple symbol reference with no addend.
4146     DarwinRefKind = SE->getKind();
4147     return true;
4148   }
4149
4150   const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr);
4151   if (!BE)
4152     return false;
4153
4154   SE = dyn_cast<MCSymbolRefExpr>(BE->getLHS());
4155   if (!SE)
4156     return false;
4157   DarwinRefKind = SE->getKind();
4158
4159   if (BE->getOpcode() != MCBinaryExpr::Add &&
4160       BE->getOpcode() != MCBinaryExpr::Sub)
4161     return false;
4162
4163   // See if the addend is is a constant, otherwise there's more going
4164   // on here than we can deal with.
4165   auto AddendExpr = dyn_cast<MCConstantExpr>(BE->getRHS());
4166   if (!AddendExpr)
4167     return false;
4168
4169   Addend = AddendExpr->getValue();
4170   if (BE->getOpcode() == MCBinaryExpr::Sub)
4171     Addend = -Addend;
4172
4173   // It's some symbol reference + a constant addend, but really
4174   // shouldn't use both Darwin and ELF syntax.
4175   return ELFRefKind == AArch64MCExpr::VK_INVALID ||
4176          DarwinRefKind == MCSymbolRefExpr::VK_None;
4177 }
4178
4179 /// Force static initialization.
4180 extern "C" void LLVMInitializeAArch64AsmParser() {
4181   RegisterMCAsmParser<AArch64AsmParser> X(getTheAArch64leTarget());
4182   RegisterMCAsmParser<AArch64AsmParser> Y(getTheAArch64beTarget());
4183   RegisterMCAsmParser<AArch64AsmParser> Z(getTheARM64Target());
4184 }
4185
4186 #define GET_REGISTER_MATCHER
4187 #define GET_SUBTARGET_FEATURE_NAME
4188 #define GET_MATCHER_IMPLEMENTATION
4189 #include "AArch64GenAsmMatcher.inc"
4190
4191 // Define this matcher function after the auto-generated include so we
4192 // have the match class enum definitions.
4193 unsigned AArch64AsmParser::validateTargetOperandClass(MCParsedAsmOperand &AsmOp,
4194                                                       unsigned Kind) {
4195   AArch64Operand &Op = static_cast<AArch64Operand &>(AsmOp);
4196   // If the kind is a token for a literal immediate, check if our asm
4197   // operand matches. This is for InstAliases which have a fixed-value
4198   // immediate in the syntax.
4199   int64_t ExpectedVal;
4200   switch (Kind) {
4201   default:
4202     return Match_InvalidOperand;
4203   case MCK__35_0:
4204     ExpectedVal = 0;
4205     break;
4206   case MCK__35_1:
4207     ExpectedVal = 1;
4208     break;
4209   case MCK__35_12:
4210     ExpectedVal = 12;
4211     break;
4212   case MCK__35_16:
4213     ExpectedVal = 16;
4214     break;
4215   case MCK__35_2:
4216     ExpectedVal = 2;
4217     break;
4218   case MCK__35_24:
4219     ExpectedVal = 24;
4220     break;
4221   case MCK__35_3:
4222     ExpectedVal = 3;
4223     break;
4224   case MCK__35_32:
4225     ExpectedVal = 32;
4226     break;
4227   case MCK__35_4:
4228     ExpectedVal = 4;
4229     break;
4230   case MCK__35_48:
4231     ExpectedVal = 48;
4232     break;
4233   case MCK__35_6:
4234     ExpectedVal = 6;
4235     break;
4236   case MCK__35_64:
4237     ExpectedVal = 64;
4238     break;
4239   case MCK__35_8:
4240     ExpectedVal = 8;
4241     break;
4242   }
4243   if (!Op.isImm())
4244     return Match_InvalidOperand;
4245   const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Op.getImm());
4246   if (!CE)
4247     return Match_InvalidOperand;
4248   if (CE->getValue() == ExpectedVal)
4249     return Match_Success;
4250   return Match_InvalidOperand;
4251 }
4252
4253 OperandMatchResultTy
4254 AArch64AsmParser::tryParseGPRSeqPair(OperandVector &Operands) {
4255
4256   SMLoc S = getLoc();
4257
4258   if (getParser().getTok().isNot(AsmToken::Identifier)) {
4259     Error(S, "expected register");
4260     return MatchOperand_ParseFail;
4261   }
4262
4263   int FirstReg = tryParseRegister();
4264   if (FirstReg == -1) {
4265     return MatchOperand_ParseFail;
4266   }
4267   const MCRegisterClass &WRegClass =
4268       AArch64MCRegisterClasses[AArch64::GPR32RegClassID];
4269   const MCRegisterClass &XRegClass =
4270       AArch64MCRegisterClasses[AArch64::GPR64RegClassID];
4271
4272   bool isXReg = XRegClass.contains(FirstReg),
4273        isWReg = WRegClass.contains(FirstReg);
4274   if (!isXReg && !isWReg) {
4275     Error(S, "expected first even register of a "
4276              "consecutive same-size even/odd register pair");
4277     return MatchOperand_ParseFail;
4278   }
4279
4280   const MCRegisterInfo *RI = getContext().getRegisterInfo();
4281   unsigned FirstEncoding = RI->getEncodingValue(FirstReg);
4282
4283   if (FirstEncoding & 0x1) {
4284     Error(S, "expected first even register of a "
4285              "consecutive same-size even/odd register pair");
4286     return MatchOperand_ParseFail;
4287   }
4288
4289   SMLoc M = getLoc();
4290   if (getParser().getTok().isNot(AsmToken::Comma)) {
4291     Error(M, "expected comma");
4292     return MatchOperand_ParseFail;
4293   }
4294   // Eat the comma
4295   getParser().Lex();
4296
4297   SMLoc E = getLoc();
4298   int SecondReg = tryParseRegister();
4299   if (SecondReg ==-1) {
4300     return MatchOperand_ParseFail;
4301   }
4302
4303   if (RI->getEncodingValue(SecondReg) != FirstEncoding + 1 ||
4304       (isXReg && !XRegClass.contains(SecondReg)) ||
4305       (isWReg && !WRegClass.contains(SecondReg))) {
4306     Error(E,"expected second odd register of a "
4307              "consecutive same-size even/odd register pair");
4308     return MatchOperand_ParseFail;
4309   }
4310
4311   unsigned Pair = 0;
4312   if (isXReg) {
4313     Pair = RI->getMatchingSuperReg(FirstReg, AArch64::sube64,
4314            &AArch64MCRegisterClasses[AArch64::XSeqPairsClassRegClassID]);
4315   } else {
4316     Pair = RI->getMatchingSuperReg(FirstReg, AArch64::sube32,
4317            &AArch64MCRegisterClasses[AArch64::WSeqPairsClassRegClassID]);
4318   }
4319
4320   Operands.push_back(AArch64Operand::CreateReg(Pair, false, S, getLoc(),
4321       getContext()));
4322
4323   return MatchOperand_Success;
4324 }