lib/Target/Mips/AsmParser/MipsAsmParser.cpp

   1 //===-- MipsAsmParser.cpp - Parse Mips 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/MipsABIInfo.h"
  11 #include "MCTargetDesc/MipsMCExpr.h"
  12 #include "MCTargetDesc/MipsMCTargetDesc.h"
  13 #include "MipsRegisterInfo.h"
  14 #include "MipsTargetStreamer.h"
  15 #include "llvm/ADT/APInt.h"
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/MC/MCContext.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCInstBuilder.h"
  22 #include "llvm/MC/MCParser/MCAsmLexer.h"
  23 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  24 #include "llvm/MC/MCStreamer.h"
  25 #include "llvm/MC/MCSubtargetInfo.h"
  26 #include "llvm/MC/MCSymbol.h"
  27 #include "llvm/MC/MCTargetAsmParser.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/MathExtras.h"
  30 #include "llvm/Support/SourceMgr.h"
  31 #include "llvm/Support/TargetRegistry.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include <memory>
  34
  35 using namespace llvm;
  36
  37 #define DEBUG_TYPE "mips-asm-parser"
  38
  39 namespace llvm {
  40 class MCInstrInfo;
  41 }
  42
  43 namespace {
  44 class MipsAssemblerOptions {
  45 public:
  46   MipsAssemblerOptions(uint64_t Features_) :
  47     ATReg(1), Reorder(true), Macro(true), Features(Features_) {}
  48
  49   MipsAssemblerOptions(const MipsAssemblerOptions *Opts) {
  50     ATReg = Opts->getATRegIndex();
  51     Reorder = Opts->isReorder();
  52     Macro = Opts->isMacro();
  53     Features = Opts->getFeatures();
  54   }
  55
  56   unsigned getATRegIndex() const { return ATReg; }
  57   bool setATRegIndex(unsigned Reg) {
  58     if (Reg > 31)
  59       return false;
  60
  61     ATReg = Reg;
  62     return true;
  63   }
  64
  65   bool isReorder() const { return Reorder; }
  66   void setReorder() { Reorder = true; }
  67   void setNoReorder() { Reorder = false; }
  68
  69   bool isMacro() const { return Macro; }
  70   void setMacro() { Macro = true; }
  71   void setNoMacro() { Macro = false; }
  72
  73   uint64_t getFeatures() const { return Features; }
  74   void setFeatures(uint64_t Features_) { Features = Features_; }
  75
  76   // Set of features that are either architecture features or referenced
  77   // by them (e.g.: FeatureNaN2008 implied by FeatureMips32r6).
  78   // The full table can be found in MipsGenSubtargetInfo.inc (MipsFeatureKV[]).
  79   // The reason we need this mask is explained in the selectArch function.
  80   // FIXME: Ideally we would like TableGen to generate this information.
  81   static const uint64_t AllArchRelatedMask =
  82       Mips::FeatureMips1 | Mips::FeatureMips2 | Mips::FeatureMips3 |
  83       Mips::FeatureMips3_32 | Mips::FeatureMips3_32r2 | Mips::FeatureMips4 |
  84       Mips::FeatureMips4_32 | Mips::FeatureMips4_32r2 | Mips::FeatureMips5 |
  85       Mips::FeatureMips5_32r2 | Mips::FeatureMips32 | Mips::FeatureMips32r2 |
  86       Mips::FeatureMips32r3 | Mips::FeatureMips32r5 | Mips::FeatureMips32r6 |
  87       Mips::FeatureMips64 | Mips::FeatureMips64r2 | Mips::FeatureMips64r3 |
  88       Mips::FeatureMips64r5 | Mips::FeatureMips64r6 | Mips::FeatureCnMips |
  89       Mips::FeatureFP64Bit | Mips::FeatureGP64Bit | Mips::FeatureNaN2008;
  90
  91 private:
  92   unsigned ATReg;
  93   bool Reorder;
  94   bool Macro;
  95   uint64_t Features;
  96 };
  97 }
  98
  99 namespace {
 100 class MipsAsmParser : public MCTargetAsmParser {
 101   MipsTargetStreamer &getTargetStreamer() {
 102     MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
 103     return static_cast<MipsTargetStreamer &>(TS);
 104   }
 105
 106   MCSubtargetInfo &STI;
 107   MipsABIInfo ABI;
 108   SmallVector<std::unique_ptr<MipsAssemblerOptions>, 2> AssemblerOptions;
 109   MCSymbol *CurrentFn; // Pointer to the function being parsed. It may be a
 110                        // nullptr, which indicates that no function is currently
 111                        // selected. This usually happens after an '.end func'
 112                        // directive.
 113
 114   // Print a warning along with its fix-it message at the given range.
 115   void printWarningWithFixIt(const Twine &Msg, const Twine &FixMsg,
 116                              SMRange Range, bool ShowColors = true);
 117
 118 #define GET_ASSEMBLER_HEADER
 119 #include "MipsGenAsmMatcher.inc"
 120
 121   unsigned checkTargetMatchPredicate(MCInst &Inst) override;
 122
 123   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
 124                                OperandVector &Operands, MCStreamer &Out,
 125                                uint64_t &ErrorInfo,
 126                                bool MatchingInlineAsm) override;
 127
 128   /// Parse a register as used in CFI directives
 129   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
 130
 131   bool parseParenSuffix(StringRef Name, OperandVector &Operands);
 132
 133   bool parseBracketSuffix(StringRef Name, OperandVector &Operands);
 134
 135   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
 136                         SMLoc NameLoc, OperandVector &Operands) override;
 137
 138   bool ParseDirective(AsmToken DirectiveID) override;
 139
 140   MipsAsmParser::OperandMatchResultTy parseMemOperand(OperandVector &Operands);
 141
 142   MipsAsmParser::OperandMatchResultTy
 143   matchAnyRegisterNameWithoutDollar(OperandVector &Operands,
 144                                     StringRef Identifier, SMLoc S);
 145
 146   MipsAsmParser::OperandMatchResultTy
 147   matchAnyRegisterWithoutDollar(OperandVector &Operands, SMLoc S);
 148
 149   MipsAsmParser::OperandMatchResultTy parseAnyRegister(OperandVector &Operands);
 150
 151   MipsAsmParser::OperandMatchResultTy parseImm(OperandVector &Operands);
 152
 153   MipsAsmParser::OperandMatchResultTy parseJumpTarget(OperandVector &Operands);
 154
 155   MipsAsmParser::OperandMatchResultTy parseInvNum(OperandVector &Operands);
 156
 157   MipsAsmParser::OperandMatchResultTy parseLSAImm(OperandVector &Operands);
 158
 159   MipsAsmParser::OperandMatchResultTy
 160   parseRegisterPair (OperandVector &Operands);
 161
 162   MipsAsmParser::OperandMatchResultTy
 163   parseMovePRegPair(OperandVector &Operands);
 164
 165   MipsAsmParser::OperandMatchResultTy
 166   parseRegisterList (OperandVector  &Operands);
 167
 168   bool searchSymbolAlias(OperandVector &Operands);
 169
 170   bool parseOperand(OperandVector &, StringRef Mnemonic);
 171
 172   bool needsExpansion(MCInst &Inst);
 173
 174   // Expands assembly pseudo instructions.
 175   // Returns false on success, true otherwise.
 176   bool expandInstruction(MCInst &Inst, SMLoc IDLoc,
 177                          SmallVectorImpl<MCInst> &Instructions);
 178
 179   bool expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
 180                          SmallVectorImpl<MCInst> &Instructions);
 181
 182   bool expandLoadImm(MCInst &Inst, SMLoc IDLoc,
 183                      SmallVectorImpl<MCInst> &Instructions);
 184
 185   bool expandLoadAddressImm(MCInst &Inst, SMLoc IDLoc,
 186                             SmallVectorImpl<MCInst> &Instructions);
 187
 188   bool expandLoadAddressReg(MCInst &Inst, SMLoc IDLoc,
 189                             SmallVectorImpl<MCInst> &Instructions);
 190   bool expandUncondBranchMMPseudo(MCInst &Inst, SMLoc IDLoc,
 191                                   SmallVectorImpl<MCInst> &Instructions);
 192
 193   void expandLoadAddressSym(MCInst &Inst, SMLoc IDLoc,
 194                             SmallVectorImpl<MCInst> &Instructions);
 195
 196   void expandMemInst(MCInst &Inst, SMLoc IDLoc,
 197                      SmallVectorImpl<MCInst> &Instructions, bool isLoad,
 198                      bool isImmOpnd);
 199
 200   bool expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc,
 201                                SmallVectorImpl<MCInst> &Instructions);
 202
 203   void createNop(bool hasShortDelaySlot, SMLoc IDLoc,
 204                  SmallVectorImpl<MCInst> &Instructions);
 205
 206   bool reportParseError(Twine ErrorMsg);
 207   bool reportParseError(SMLoc Loc, Twine ErrorMsg);
 208
 209   bool parseMemOffset(const MCExpr *&Res, bool isParenExpr);
 210   bool parseRelocOperand(const MCExpr *&Res);
 211
 212   const MCExpr *evaluateRelocExpr(const MCExpr *Expr, StringRef RelocStr);
 213
 214   bool isEvaluated(const MCExpr *Expr);
 215   bool parseSetMips0Directive();
 216   bool parseSetArchDirective();
 217   bool parseSetFeature(uint64_t Feature);
 218   bool parseDirectiveCpLoad(SMLoc Loc);
 219   bool parseDirectiveCPSetup();
 220   bool parseDirectiveNaN();
 221   bool parseDirectiveSet();
 222   bool parseDirectiveOption();
 223   bool parseInsnDirective();
 224
 225   bool parseSetAtDirective();
 226   bool parseSetNoAtDirective();
 227   bool parseSetMacroDirective();
 228   bool parseSetNoMacroDirective();
 229   bool parseSetMsaDirective();
 230   bool parseSetNoMsaDirective();
 231   bool parseSetNoDspDirective();
 232   bool parseSetReorderDirective();
 233   bool parseSetNoReorderDirective();
 234   bool parseSetMips16Directive();
 235   bool parseSetNoMips16Directive();
 236   bool parseSetFpDirective();
 237   bool parseSetPopDirective();
 238   bool parseSetPushDirective();
 239
 240   bool parseSetAssignment();
 241
 242   bool parseDataDirective(unsigned Size, SMLoc L);
 243   bool parseDirectiveGpWord();
 244   bool parseDirectiveGpDWord();
 245   bool parseDirectiveModule();
 246   bool parseDirectiveModuleFP();
 247   bool parseFpABIValue(MipsABIFlagsSection::FpABIKind &FpABI,
 248                        StringRef Directive);
 249
 250   bool parseInternalDirectiveReallowModule();
 251
 252   MCSymbolRefExpr::VariantKind getVariantKind(StringRef Symbol);
 253
 254   bool eatComma(StringRef ErrorStr);
 255
 256   int matchCPURegisterName(StringRef Symbol);
 257
 258   int matchHWRegsRegisterName(StringRef Symbol);
 259
 260   int matchRegisterByNumber(unsigned RegNum, unsigned RegClass);
 261
 262   int matchFPURegisterName(StringRef Name);
 263
 264   int matchFCCRegisterName(StringRef Name);
 265
 266   int matchACRegisterName(StringRef Name);
 267
 268   int matchMSA128RegisterName(StringRef Name);
 269
 270   int matchMSA128CtrlRegisterName(StringRef Name);
 271
 272   unsigned getReg(int RC, int RegNo);
 273
 274   unsigned getGPR(int RegNo);
 275
 276   /// Returns the internal register number for the current AT. Also checks if
 277   /// the current AT is unavailable (set to $0) and gives an error if it is.
 278   /// This should be used in pseudo-instruction expansions which need AT.
 279   unsigned getATReg(SMLoc Loc);
 280
 281   bool processInstruction(MCInst &Inst, SMLoc IDLoc,
 282                           SmallVectorImpl<MCInst> &Instructions);
 283
 284   // Helper function that checks if the value of a vector index is within the
 285   // boundaries of accepted values for each RegisterKind
 286   // Example: INSERT.B $w0[n], $1 => 16 > n >= 0
 287   bool validateMSAIndex(int Val, int RegKind);
 288
 289   // Selects a new architecture by updating the FeatureBits with the necessary
 290   // info including implied dependencies.
 291   // Internally, it clears all the feature bits related to *any* architecture
 292   // and selects the new one using the ToggleFeature functionality of the
 293   // MCSubtargetInfo object that handles implied dependencies. The reason we
 294   // clear all the arch related bits manually is because ToggleFeature only
 295   // clears the features that imply the feature being cleared and not the
 296   // features implied by the feature being cleared. This is easier to see
 297   // with an example:
 298   //  --------------------------------------------------
 299   // | Feature         | Implies                        |
 300   // | -------------------------------------------------|
 301   // | FeatureMips1    | None                           |
 302   // | FeatureMips2    | FeatureMips1                   |
 303   // | FeatureMips3    | FeatureMips2 | FeatureMipsGP64 |
 304   // | FeatureMips4    | FeatureMips3                   |
 305   // | ...             |                                |
 306   //  --------------------------------------------------
 307   //
 308   // Setting Mips3 is equivalent to set: (FeatureMips3 | FeatureMips2 |
 309   // FeatureMipsGP64 | FeatureMips1)
 310   // Clearing Mips3 is equivalent to clear (FeatureMips3 | FeatureMips4).
 311   void selectArch(StringRef ArchFeature) {
 312     uint64_t FeatureBits = STI.getFeatureBits();
 313     FeatureBits &= ~MipsAssemblerOptions::AllArchRelatedMask;
 314     STI.setFeatureBits(FeatureBits);
 315     setAvailableFeatures(
 316         ComputeAvailableFeatures(STI.ToggleFeature(ArchFeature)));
 317     AssemblerOptions.back()->setFeatures(getAvailableFeatures());
 318   }
 319
 320   void setFeatureBits(uint64_t Feature, StringRef FeatureString) {
 321     if (!(STI.getFeatureBits() & Feature)) {
 322       setAvailableFeatures(
 323           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
 324     }
 325     AssemblerOptions.back()->setFeatures(getAvailableFeatures());
 326   }
 327
 328   void clearFeatureBits(uint64_t Feature, StringRef FeatureString) {
 329     if (STI.getFeatureBits() & Feature) {
 330       setAvailableFeatures(
 331           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
 332     }
 333     AssemblerOptions.back()->setFeatures(getAvailableFeatures());
 334   }
 335
 336 public:
 337   enum MipsMatchResultTy {
 338     Match_RequiresDifferentSrcAndDst = FIRST_TARGET_MATCH_RESULT_TY
 339 #define GET_OPERAND_DIAGNOSTIC_TYPES
 340 #include "MipsGenAsmMatcher.inc"
 341 #undef GET_OPERAND_DIAGNOSTIC_TYPES
 342
 343   };
 344
 345   MipsAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
 346                 const MCInstrInfo &MII, const MCTargetOptions &Options)
 347       : MCTargetAsmParser(), STI(sti),
 348         ABI(MipsABIInfo::computeTargetABI(Triple(sti.getTargetTriple()),
 349                                           sti.getCPU(), Options)) {
 350     MCAsmParserExtension::Initialize(parser);
 351
 352     parser.addAliasForDirective(".asciiz", ".asciz");
 353
 354     // Initialize the set of available features.
 355     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 356
 357     // Remember the initial assembler options. The user can not modify these.
 358     AssemblerOptions.push_back(
 359                      make_unique<MipsAssemblerOptions>(getAvailableFeatures()));
 360
 361     // Create an assembler options environment for the user to modify.
 362     AssemblerOptions.push_back(
 363                      make_unique<MipsAssemblerOptions>(getAvailableFeatures()));
 364
 365     getTargetStreamer().updateABIInfo(*this);
 366
 367     if (!isABI_O32() && !useOddSPReg() != 0)
 368       report_fatal_error("-mno-odd-spreg requires the O32 ABI");
 369
 370     CurrentFn = nullptr;
 371   }
 372
 373   /// True if all of $fcc0 - $fcc7 exist for the current ISA.
 374   bool hasEightFccRegisters() const { return hasMips4() || hasMips32(); }
 375
 376   bool isGP64bit() const { return STI.getFeatureBits() & Mips::FeatureGP64Bit; }
 377   bool isFP64bit() const { return STI.getFeatureBits() & Mips::FeatureFP64Bit; }
 378   const MipsABIInfo &getABI() const { return ABI; }
 379   bool isABI_N32() const { return ABI.IsN32(); }
 380   bool isABI_N64() const { return ABI.IsN64(); }
 381   bool isABI_O32() const { return ABI.IsO32(); }
 382   bool isABI_FPXX() const { return STI.getFeatureBits() & Mips::FeatureFPXX; }
 383
 384   bool useOddSPReg() const {
 385     return !(STI.getFeatureBits() & Mips::FeatureNoOddSPReg);
 386   }
 387
 388   bool inMicroMipsMode() const {
 389     return STI.getFeatureBits() & Mips::FeatureMicroMips;
 390   }
 391   bool hasMips1() const { return STI.getFeatureBits() & Mips::FeatureMips1; }
 392   bool hasMips2() const { return STI.getFeatureBits() & Mips::FeatureMips2; }
 393   bool hasMips3() const { return STI.getFeatureBits() & Mips::FeatureMips3; }
 394   bool hasMips4() const { return STI.getFeatureBits() & Mips::FeatureMips4; }
 395   bool hasMips5() const { return STI.getFeatureBits() & Mips::FeatureMips5; }
 396   bool hasMips32() const {
 397     return (STI.getFeatureBits() & Mips::FeatureMips32);
 398   }
 399   bool hasMips64() const {
 400     return (STI.getFeatureBits() & Mips::FeatureMips64);
 401   }
 402   bool hasMips32r2() const {
 403     return (STI.getFeatureBits() & Mips::FeatureMips32r2);
 404   }
 405   bool hasMips64r2() const {
 406     return (STI.getFeatureBits() & Mips::FeatureMips64r2);
 407   }
 408   bool hasMips32r3() const {
 409     return (STI.getFeatureBits() & Mips::FeatureMips32r3);
 410   }
 411   bool hasMips64r3() const {
 412     return (STI.getFeatureBits() & Mips::FeatureMips64r3);
 413   }
 414   bool hasMips32r5() const {
 415     return (STI.getFeatureBits() & Mips::FeatureMips32r5);
 416   }
 417   bool hasMips64r5() const {
 418     return (STI.getFeatureBits() & Mips::FeatureMips64r5);
 419   }
 420   bool hasMips32r6() const {
 421     return (STI.getFeatureBits() & Mips::FeatureMips32r6);
 422   }
 423   bool hasMips64r6() const {
 424     return (STI.getFeatureBits() & Mips::FeatureMips64r6);
 425   }
 426   bool hasCnMips() const {
 427     return (STI.getFeatureBits() & Mips::FeatureCnMips);
 428   }
 429   bool hasDSP() const { return (STI.getFeatureBits() & Mips::FeatureDSP); }
 430   bool hasDSPR2() const { return (STI.getFeatureBits() & Mips::FeatureDSPR2); }
 431   bool hasMSA() const { return (STI.getFeatureBits() & Mips::FeatureMSA); }
 432
 433   bool inMips16Mode() const {
 434     return STI.getFeatureBits() & Mips::FeatureMips16;
 435   }
 436   // TODO: see how can we get this info.
 437   bool abiUsesSoftFloat() const { return false; }
 438
 439   /// Warn if RegIndex is the same as the current AT.
 440   void warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc);
 441 };
 442 }
 443
 444 namespace {
 445
 446 /// MipsOperand - Instances of this class represent a parsed Mips machine
 447 /// instruction.
 448 class MipsOperand : public MCParsedAsmOperand {
 449 public:
 450   /// Broad categories of register classes
 451   /// The exact class is finalized by the render method.
 452   enum RegKind {
 453     RegKind_GPR = 1,      /// GPR32 and GPR64 (depending on isGP64bit())
 454     RegKind_FGR = 2,      /// FGR32, FGR64, AFGR64 (depending on context and
 455                           /// isFP64bit())
 456     RegKind_FCC = 4,      /// FCC
 457     RegKind_MSA128 = 8,   /// MSA128[BHWD] (makes no difference which)
 458     RegKind_MSACtrl = 16, /// MSA control registers
 459     RegKind_COP2 = 32,    /// COP2
 460     RegKind_ACC = 64,     /// HI32DSP, LO32DSP, and ACC64DSP (depending on
 461                           /// context).
 462     RegKind_CCR = 128,    /// CCR
 463     RegKind_HWRegs = 256, /// HWRegs
 464     RegKind_COP3 = 512,   /// COP3
 465
 466     /// Potentially any (e.g. $1)
 467     RegKind_Numeric = RegKind_GPR | RegKind_FGR | RegKind_FCC | RegKind_MSA128 |
 468                       RegKind_MSACtrl | RegKind_COP2 | RegKind_ACC |
 469                       RegKind_CCR | RegKind_HWRegs | RegKind_COP3
 470   };
 471
 472 private:
 473   enum KindTy {
 474     k_Immediate,     /// An immediate (possibly involving symbol references)
 475     k_Memory,        /// Base + Offset Memory Address
 476     k_PhysRegister,  /// A physical register from the Mips namespace
 477     k_RegisterIndex, /// A register index in one or more RegKind.
 478     k_Token,         /// A simple token
 479     k_RegList,       /// A physical register list
 480     k_RegPair        /// A pair of physical register
 481   } Kind;
 482
 483 public:
 484   MipsOperand(KindTy K, MipsAsmParser &Parser)
 485       : MCParsedAsmOperand(), Kind(K), AsmParser(Parser) {}
 486
 487 private:
 488   /// For diagnostics, and checking the assembler temporary
 489   MipsAsmParser &AsmParser;
 490
 491   struct Token {
 492     const char *Data;
 493     unsigned Length;
 494   };
 495
 496   struct PhysRegOp {
 497     unsigned Num; /// Register Number
 498   };
 499
 500   struct RegIdxOp {
 501     unsigned Index; /// Index into the register class
 502     RegKind Kind;   /// Bitfield of the kinds it could possibly be
 503     const MCRegisterInfo *RegInfo;
 504   };
 505
 506   struct ImmOp {
 507     const MCExpr *Val;
 508   };
 509
 510   struct MemOp {
 511     MipsOperand *Base;
 512     const MCExpr *Off;
 513   };
 514
 515   struct RegListOp {
 516     SmallVector<unsigned, 10> *List;
 517   };
 518
 519   union {
 520     struct Token Tok;
 521     struct PhysRegOp PhysReg;
 522     struct RegIdxOp RegIdx;
 523     struct ImmOp Imm;
 524     struct MemOp Mem;
 525     struct RegListOp RegList;
 526   };
 527
 528   SMLoc StartLoc, EndLoc;
 529
 530   /// Internal constructor for register kinds
 531   static std::unique_ptr<MipsOperand> CreateReg(unsigned Index, RegKind RegKind,
 532                                                 const MCRegisterInfo *RegInfo,
 533                                                 SMLoc S, SMLoc E,
 534                                                 MipsAsmParser &Parser) {
 535     auto Op = make_unique<MipsOperand>(k_RegisterIndex, Parser);
 536     Op->RegIdx.Index = Index;
 537     Op->RegIdx.RegInfo = RegInfo;
 538     Op->RegIdx.Kind = RegKind;
 539     Op->StartLoc = S;
 540     Op->EndLoc = E;
 541     return Op;
 542   }
 543
 544 public:
 545   /// Coerce the register to GPR32 and return the real register for the current
 546   /// target.
 547   unsigned getGPR32Reg() const {
 548     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
 549     AsmParser.warnIfRegIndexIsAT(RegIdx.Index, StartLoc);
 550     unsigned ClassID = Mips::GPR32RegClassID;
 551     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 552   }
 553
 554   /// Coerce the register to GPR32 and return the real register for the current
 555   /// target.
 556   unsigned getGPRMM16Reg() const {
 557     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
 558     unsigned ClassID = Mips::GPR32RegClassID;
 559     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 560   }
 561
 562   /// Coerce the register to GPR64 and return the real register for the current
 563   /// target.
 564   unsigned getGPR64Reg() const {
 565     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
 566     unsigned ClassID = Mips::GPR64RegClassID;
 567     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 568   }
 569
 570 private:
 571   /// Coerce the register to AFGR64 and return the real register for the current
 572   /// target.
 573   unsigned getAFGR64Reg() const {
 574     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
 575     if (RegIdx.Index % 2 != 0)
 576       AsmParser.Warning(StartLoc, "Float register should be even.");
 577     return RegIdx.RegInfo->getRegClass(Mips::AFGR64RegClassID)
 578         .getRegister(RegIdx.Index / 2);
 579   }
 580
 581   /// Coerce the register to FGR64 and return the real register for the current
 582   /// target.
 583   unsigned getFGR64Reg() const {
 584     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
 585     return RegIdx.RegInfo->getRegClass(Mips::FGR64RegClassID)
 586         .getRegister(RegIdx.Index);
 587   }
 588
 589   /// Coerce the register to FGR32 and return the real register for the current
 590   /// target.
 591   unsigned getFGR32Reg() const {
 592     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
 593     return RegIdx.RegInfo->getRegClass(Mips::FGR32RegClassID)
 594         .getRegister(RegIdx.Index);
 595   }
 596
 597   /// Coerce the register to FGRH32 and return the real register for the current
 598   /// target.
 599   unsigned getFGRH32Reg() const {
 600     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
 601     return RegIdx.RegInfo->getRegClass(Mips::FGRH32RegClassID)
 602         .getRegister(RegIdx.Index);
 603   }
 604
 605   /// Coerce the register to FCC and return the real register for the current
 606   /// target.
 607   unsigned getFCCReg() const {
 608     assert(isRegIdx() && (RegIdx.Kind & RegKind_FCC) && "Invalid access!");
 609     return RegIdx.RegInfo->getRegClass(Mips::FCCRegClassID)
 610         .getRegister(RegIdx.Index);
 611   }
 612
 613   /// Coerce the register to MSA128 and return the real register for the current
 614   /// target.
 615   unsigned getMSA128Reg() const {
 616     assert(isRegIdx() && (RegIdx.Kind & RegKind_MSA128) && "Invalid access!");
 617     // It doesn't matter which of the MSA128[BHWD] classes we use. They are all
 618     // identical
 619     unsigned ClassID = Mips::MSA128BRegClassID;
 620     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 621   }
 622
 623   /// Coerce the register to MSACtrl and return the real register for the
 624   /// current target.
 625   unsigned getMSACtrlReg() const {
 626     assert(isRegIdx() && (RegIdx.Kind & RegKind_MSACtrl) && "Invalid access!");
 627     unsigned ClassID = Mips::MSACtrlRegClassID;
 628     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 629   }
 630
 631   /// Coerce the register to COP2 and return the real register for the
 632   /// current target.
 633   unsigned getCOP2Reg() const {
 634     assert(isRegIdx() && (RegIdx.Kind & RegKind_COP2) && "Invalid access!");
 635     unsigned ClassID = Mips::COP2RegClassID;
 636     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 637   }
 638
 639   /// Coerce the register to COP3 and return the real register for the
 640   /// current target.
 641   unsigned getCOP3Reg() const {
 642     assert(isRegIdx() && (RegIdx.Kind & RegKind_COP3) && "Invalid access!");
 643     unsigned ClassID = Mips::COP3RegClassID;
 644     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 645   }
 646
 647   /// Coerce the register to ACC64DSP and return the real register for the
 648   /// current target.
 649   unsigned getACC64DSPReg() const {
 650     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
 651     unsigned ClassID = Mips::ACC64DSPRegClassID;
 652     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 653   }
 654
 655   /// Coerce the register to HI32DSP and return the real register for the
 656   /// current target.
 657   unsigned getHI32DSPReg() const {
 658     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
 659     unsigned ClassID = Mips::HI32DSPRegClassID;
 660     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 661   }
 662
 663   /// Coerce the register to LO32DSP and return the real register for the
 664   /// current target.
 665   unsigned getLO32DSPReg() const {
 666     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
 667     unsigned ClassID = Mips::LO32DSPRegClassID;
 668     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 669   }
 670
 671   /// Coerce the register to CCR and return the real register for the
 672   /// current target.
 673   unsigned getCCRReg() const {
 674     assert(isRegIdx() && (RegIdx.Kind & RegKind_CCR) && "Invalid access!");
 675     unsigned ClassID = Mips::CCRRegClassID;
 676     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 677   }
 678
 679   /// Coerce the register to HWRegs and return the real register for the
 680   /// current target.
 681   unsigned getHWRegsReg() const {
 682     assert(isRegIdx() && (RegIdx.Kind & RegKind_HWRegs) && "Invalid access!");
 683     unsigned ClassID = Mips::HWRegsRegClassID;
 684     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
 685   }
 686
 687 public:
 688   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 689     // Add as immediate when possible.  Null MCExpr = 0.
 690     if (!Expr)
 691       Inst.addOperand(MCOperand::CreateImm(0));
 692     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 693       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 694     else
 695       Inst.addOperand(MCOperand::CreateExpr(Expr));
 696   }
 697
 698   void addRegOperands(MCInst &Inst, unsigned N) const {
 699     llvm_unreachable("Use a custom parser instead");
 700   }
 701
 702   /// Render the operand to an MCInst as a GPR32
 703   /// Asserts if the wrong number of operands are requested, or the operand
 704   /// is not a k_RegisterIndex compatible with RegKind_GPR
 705   void addGPR32AsmRegOperands(MCInst &Inst, unsigned N) const {
 706     assert(N == 1 && "Invalid number of operands!");
 707     Inst.addOperand(MCOperand::CreateReg(getGPR32Reg()));
 708   }
 709
 710   void addGPRMM16AsmRegOperands(MCInst &Inst, unsigned N) const {
 711     assert(N == 1 && "Invalid number of operands!");
 712     Inst.addOperand(MCOperand::CreateReg(getGPRMM16Reg()));
 713   }
 714
 715   void addGPRMM16AsmRegZeroOperands(MCInst &Inst, unsigned N) const {
 716     assert(N == 1 && "Invalid number of operands!");
 717     Inst.addOperand(MCOperand::CreateReg(getGPRMM16Reg()));
 718   }
 719
 720   void addGPRMM16AsmRegMovePOperands(MCInst &Inst, unsigned N) const {
 721     assert(N == 1 && "Invalid number of operands!");
 722     Inst.addOperand(MCOperand::CreateReg(getGPRMM16Reg()));
 723   }
 724
 725   /// Render the operand to an MCInst as a GPR64
 726   /// Asserts if the wrong number of operands are requested, or the operand
 727   /// is not a k_RegisterIndex compatible with RegKind_GPR
 728   void addGPR64AsmRegOperands(MCInst &Inst, unsigned N) const {
 729     assert(N == 1 && "Invalid number of operands!");
 730     Inst.addOperand(MCOperand::CreateReg(getGPR64Reg()));
 731   }
 732
 733   void addAFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
 734     assert(N == 1 && "Invalid number of operands!");
 735     Inst.addOperand(MCOperand::CreateReg(getAFGR64Reg()));
 736   }
 737
 738   void addFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
 739     assert(N == 1 && "Invalid number of operands!");
 740     Inst.addOperand(MCOperand::CreateReg(getFGR64Reg()));
 741   }
 742
 743   void addFGR32AsmRegOperands(MCInst &Inst, unsigned N) const {
 744     assert(N == 1 && "Invalid number of operands!");
 745     Inst.addOperand(MCOperand::CreateReg(getFGR32Reg()));
 746     // FIXME: We ought to do this for -integrated-as without -via-file-asm too.
 747     if (!AsmParser.useOddSPReg() && RegIdx.Index & 1)
 748       AsmParser.Error(StartLoc, "-mno-odd-spreg prohibits the use of odd FPU "
 749                                 "registers");
 750   }
 751
 752   void addFGRH32AsmRegOperands(MCInst &Inst, unsigned N) const {
 753     assert(N == 1 && "Invalid number of operands!");
 754     Inst.addOperand(MCOperand::CreateReg(getFGRH32Reg()));
 755   }
 756
 757   void addFCCAsmRegOperands(MCInst &Inst, unsigned N) const {
 758     assert(N == 1 && "Invalid number of operands!");
 759     Inst.addOperand(MCOperand::CreateReg(getFCCReg()));
 760   }
 761
 762   void addMSA128AsmRegOperands(MCInst &Inst, unsigned N) const {
 763     assert(N == 1 && "Invalid number of operands!");
 764     Inst.addOperand(MCOperand::CreateReg(getMSA128Reg()));
 765   }
 766
 767   void addMSACtrlAsmRegOperands(MCInst &Inst, unsigned N) const {
 768     assert(N == 1 && "Invalid number of operands!");
 769     Inst.addOperand(MCOperand::CreateReg(getMSACtrlReg()));
 770   }
 771
 772   void addCOP2AsmRegOperands(MCInst &Inst, unsigned N) const {
 773     assert(N == 1 && "Invalid number of operands!");
 774     Inst.addOperand(MCOperand::CreateReg(getCOP2Reg()));
 775   }
 776
 777   void addCOP3AsmRegOperands(MCInst &Inst, unsigned N) const {
 778     assert(N == 1 && "Invalid number of operands!");
 779     Inst.addOperand(MCOperand::CreateReg(getCOP3Reg()));
 780   }
 781
 782   void addACC64DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
 783     assert(N == 1 && "Invalid number of operands!");
 784     Inst.addOperand(MCOperand::CreateReg(getACC64DSPReg()));
 785   }
 786
 787   void addHI32DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
 788     assert(N == 1 && "Invalid number of operands!");
 789     Inst.addOperand(MCOperand::CreateReg(getHI32DSPReg()));
 790   }
 791
 792   void addLO32DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
 793     assert(N == 1 && "Invalid number of operands!");
 794     Inst.addOperand(MCOperand::CreateReg(getLO32DSPReg()));
 795   }
 796
 797   void addCCRAsmRegOperands(MCInst &Inst, unsigned N) const {
 798     assert(N == 1 && "Invalid number of operands!");
 799     Inst.addOperand(MCOperand::CreateReg(getCCRReg()));
 800   }
 801
 802   void addHWRegsAsmRegOperands(MCInst &Inst, unsigned N) const {
 803     assert(N == 1 && "Invalid number of operands!");
 804     Inst.addOperand(MCOperand::CreateReg(getHWRegsReg()));
 805   }
 806
 807   void addImmOperands(MCInst &Inst, unsigned N) const {
 808     assert(N == 1 && "Invalid number of operands!");
 809     const MCExpr *Expr = getImm();
 810     addExpr(Inst, Expr);
 811   }
 812
 813   void addMemOperands(MCInst &Inst, unsigned N) const {
 814     assert(N == 2 && "Invalid number of operands!");
 815
 816     Inst.addOperand(MCOperand::CreateReg(getMemBase()->getGPR32Reg()));
 817
 818     const MCExpr *Expr = getMemOff();
 819     addExpr(Inst, Expr);
 820   }
 821
 822   void addMicroMipsMemOperands(MCInst &Inst, unsigned N) const {
 823     assert(N == 2 && "Invalid number of operands!");
 824
 825     Inst.addOperand(MCOperand::CreateReg(getMemBase()->getGPRMM16Reg()));
 826
 827     const MCExpr *Expr = getMemOff();
 828     addExpr(Inst, Expr);
 829   }
 830
 831   void addRegListOperands(MCInst &Inst, unsigned N) const {
 832     assert(N == 1 && "Invalid number of operands!");
 833
 834     for (auto RegNo : getRegList())
 835       Inst.addOperand(MCOperand::CreateReg(RegNo));
 836   }
 837
 838   void addRegPairOperands(MCInst &Inst, unsigned N) const {
 839     assert(N == 2 && "Invalid number of operands!");
 840     unsigned RegNo = getRegPair();
 841     Inst.addOperand(MCOperand::CreateReg(RegNo++));
 842     Inst.addOperand(MCOperand::CreateReg(RegNo));
 843   }
 844
 845   void addMovePRegPairOperands(MCInst &Inst, unsigned N) const {
 846     assert(N == 2 && "Invalid number of operands!");
 847     for (auto RegNo : getRegList())
 848       Inst.addOperand(MCOperand::CreateReg(RegNo));
 849   }
 850
 851   bool isReg() const override {
 852     // As a special case until we sort out the definition of div/divu, pretend
 853     // that $0/$zero are k_PhysRegister so that MCK_ZERO works correctly.
 854     if (isGPRAsmReg() && RegIdx.Index == 0)
 855       return true;
 856
 857     return Kind == k_PhysRegister;
 858   }
 859   bool isRegIdx() const { return Kind == k_RegisterIndex; }
 860   bool isImm() const override { return Kind == k_Immediate; }
 861   bool isConstantImm() const {
 862     return isImm() && dyn_cast<MCConstantExpr>(getImm());
 863   }
 864   bool isToken() const override {
 865     // Note: It's not possible to pretend that other operand kinds are tokens.
 866     // The matcher emitter checks tokens first.
 867     return Kind == k_Token;
 868   }
 869   bool isMem() const override { return Kind == k_Memory; }
 870   bool isConstantMemOff() const {
 871     return isMem() && dyn_cast<MCConstantExpr>(getMemOff());
 872   }
 873   template <unsigned Bits> bool isMemWithSimmOffset() const {
 874     return isMem() && isConstantMemOff() && isInt<Bits>(getConstantMemOff());
 875   }
 876   bool isMemWithGRPMM16Base() const {
 877     return isMem() && getMemBase()->isMM16AsmReg();
 878   }
 879   template <unsigned Bits> bool isMemWithUimmOffsetSP() const {
 880     return isMem() && isConstantMemOff() && isUInt<Bits>(getConstantMemOff())
 881       && getMemBase()->isRegIdx() && (getMemBase()->getGPR32Reg() == Mips::SP);
 882   }
 883   template <unsigned Bits> bool isMemWithUimmWordAlignedOffsetSP() const {
 884     return isMem() && isConstantMemOff() && isUInt<Bits>(getConstantMemOff())
 885       && (getConstantMemOff() % 4 == 0) && getMemBase()->isRegIdx()
 886       && (getMemBase()->getGPR32Reg() == Mips::SP);
 887   }
 888   bool isRegList16() const {
 889     if (!isRegList())
 890       return false;
 891
 892     int Size = RegList.List->size();
 893     if (Size < 2 || Size > 5 || *RegList.List->begin() != Mips::S0 ||
 894         RegList.List->back() != Mips::RA)
 895       return false;
 896
 897     int PrevReg = *RegList.List->begin();
 898     for (int i = 1; i < Size - 1; i++) {
 899       int Reg = (*(RegList.List))[i];
 900       if ( Reg != PrevReg + 1)
 901         return false;
 902       PrevReg = Reg;
 903     }
 904
 905     return true;
 906   }
 907   bool isInvNum() const { return Kind == k_Immediate; }
 908   bool isLSAImm() const {
 909     if (!isConstantImm())
 910       return false;
 911     int64_t Val = getConstantImm();
 912     return 1 <= Val && Val <= 4;
 913   }
 914   bool isRegList() const { return Kind == k_RegList; }
 915   bool isMovePRegPair() const {
 916     if (Kind != k_RegList || RegList.List->size() != 2)
 917       return false;
 918
 919     unsigned R0 = RegList.List->front();
 920     unsigned R1 = RegList.List->back();
 921
 922     if ((R0 == Mips::A1 && R1 == Mips::A2) ||
 923         (R0 == Mips::A1 && R1 == Mips::A3) ||
 924         (R0 == Mips::A2 && R1 == Mips::A3) ||
 925         (R0 == Mips::A0 && R1 == Mips::S5) ||
 926         (R0 == Mips::A0 && R1 == Mips::S6) ||
 927         (R0 == Mips::A0 && R1 == Mips::A1) ||
 928         (R0 == Mips::A0 && R1 == Mips::A2) ||
 929         (R0 == Mips::A0 && R1 == Mips::A3))
 930       return true;
 931
 932     return false;
 933   }
 934
 935   StringRef getToken() const {
 936     assert(Kind == k_Token && "Invalid access!");
 937     return StringRef(Tok.Data, Tok.Length);
 938   }
 939   bool isRegPair() const { return Kind == k_RegPair; }
 940
 941   unsigned getReg() const override {
 942     // As a special case until we sort out the definition of div/divu, pretend
 943     // that $0/$zero are k_PhysRegister so that MCK_ZERO works correctly.
 944     if (Kind == k_RegisterIndex && RegIdx.Index == 0 &&
 945         RegIdx.Kind & RegKind_GPR)
 946       return getGPR32Reg(); // FIXME: GPR64 too
 947
 948     assert(Kind == k_PhysRegister && "Invalid access!");
 949     return PhysReg.Num;
 950   }
 951
 952   const MCExpr *getImm() const {
 953     assert((Kind == k_Immediate) && "Invalid access!");
 954     return Imm.Val;
 955   }
 956
 957   int64_t getConstantImm() const {
 958     const MCExpr *Val = getImm();
 959     return static_cast<const MCConstantExpr *>(Val)->getValue();
 960   }
 961
 962   MipsOperand *getMemBase() const {
 963     assert((Kind == k_Memory) && "Invalid access!");
 964     return Mem.Base;
 965   }
 966
 967   const MCExpr *getMemOff() const {
 968     assert((Kind == k_Memory) && "Invalid access!");
 969     return Mem.Off;
 970   }
 971
 972   int64_t getConstantMemOff() const {
 973     return static_cast<const MCConstantExpr *>(getMemOff())->getValue();
 974   }
 975
 976   const SmallVectorImpl<unsigned> &getRegList() const {
 977     assert((Kind == k_RegList) && "Invalid access!");
 978     return *(RegList.List);
 979   }
 980
 981   unsigned getRegPair() const {
 982     assert((Kind == k_RegPair) && "Invalid access!");
 983     return RegIdx.Index;
 984   }
 985
 986   static std::unique_ptr<MipsOperand> CreateToken(StringRef Str, SMLoc S,
 987                                                   MipsAsmParser &Parser) {
 988     auto Op = make_unique<MipsOperand>(k_Token, Parser);
 989     Op->Tok.Data = Str.data();
 990     Op->Tok.Length = Str.size();
 991     Op->StartLoc = S;
 992     Op->EndLoc = S;
 993     return Op;
 994   }
 995
 996   /// Create a numeric register (e.g. $1). The exact register remains
 997   /// unresolved until an instruction successfully matches
 998   static std::unique_ptr<MipsOperand>
 999   createNumericReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1000                    SMLoc E, MipsAsmParser &Parser) {
1001     DEBUG(dbgs() << "createNumericReg(" << Index << ", ...)\n");
1002     return CreateReg(Index, RegKind_Numeric, RegInfo, S, E, Parser);
1003   }
1004
1005   /// Create a register that is definitely a GPR.
1006   /// This is typically only used for named registers such as $gp.
1007   static std::unique_ptr<MipsOperand>
1008   createGPRReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1009                MipsAsmParser &Parser) {
1010     return CreateReg(Index, RegKind_GPR, RegInfo, S, E, Parser);
1011   }
1012
1013   /// Create a register that is definitely a FGR.
1014   /// This is typically only used for named registers such as $f0.
1015   static std::unique_ptr<MipsOperand>
1016   createFGRReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1017                MipsAsmParser &Parser) {
1018     return CreateReg(Index, RegKind_FGR, RegInfo, S, E, Parser);
1019   }
1020
1021   /// Create a register that is definitely a HWReg.
1022   /// This is typically only used for named registers such as $hwr_cpunum.
1023   static std::unique_ptr<MipsOperand>
1024   createHWRegsReg(unsigned Index, const MCRegisterInfo *RegInfo,
1025                   SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1026     return CreateReg(Index, RegKind_HWRegs, RegInfo, S, E, Parser);
1027   }
1028
1029   /// Create a register that is definitely an FCC.
1030   /// This is typically only used for named registers such as $fcc0.
1031   static std::unique_ptr<MipsOperand>
1032   createFCCReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1033                MipsAsmParser &Parser) {
1034     return CreateReg(Index, RegKind_FCC, RegInfo, S, E, Parser);
1035   }
1036
1037   /// Create a register that is definitely an ACC.
1038   /// This is typically only used for named registers such as $ac0.
1039   static std::unique_ptr<MipsOperand>
1040   createACCReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1041                MipsAsmParser &Parser) {
1042     return CreateReg(Index, RegKind_ACC, RegInfo, S, E, Parser);
1043   }
1044
1045   /// Create a register that is definitely an MSA128.
1046   /// This is typically only used for named registers such as $w0.
1047   static std::unique_ptr<MipsOperand>
1048   createMSA128Reg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1049                   SMLoc E, MipsAsmParser &Parser) {
1050     return CreateReg(Index, RegKind_MSA128, RegInfo, S, E, Parser);
1051   }
1052
1053   /// Create a register that is definitely an MSACtrl.
1054   /// This is typically only used for named registers such as $msaaccess.
1055   static std::unique_ptr<MipsOperand>
1056   createMSACtrlReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1057                    SMLoc E, MipsAsmParser &Parser) {
1058     return CreateReg(Index, RegKind_MSACtrl, RegInfo, S, E, Parser);
1059   }
1060
1061   static std::unique_ptr<MipsOperand>
1062   CreateImm(const MCExpr *Val, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1063     auto Op = make_unique<MipsOperand>(k_Immediate, Parser);
1064     Op->Imm.Val = Val;
1065     Op->StartLoc = S;
1066     Op->EndLoc = E;
1067     return Op;
1068   }
1069
1070   static std::unique_ptr<MipsOperand>
1071   CreateMem(std::unique_ptr<MipsOperand> Base, const MCExpr *Off, SMLoc S,
1072             SMLoc E, MipsAsmParser &Parser) {
1073     auto Op = make_unique<MipsOperand>(k_Memory, Parser);
1074     Op->Mem.Base = Base.release();
1075     Op->Mem.Off = Off;
1076     Op->StartLoc = S;
1077     Op->EndLoc = E;
1078     return Op;
1079   }
1080
1081   static std::unique_ptr<MipsOperand>
1082   CreateRegList(SmallVectorImpl<unsigned> &Regs, SMLoc StartLoc, SMLoc EndLoc,
1083                 MipsAsmParser &Parser) {
1084     assert (Regs.size() > 0 && "Empty list not allowed");
1085
1086     auto Op = make_unique<MipsOperand>(k_RegList, Parser);
1087     Op->RegList.List = new SmallVector<unsigned, 10>(Regs.begin(), Regs.end());
1088     Op->StartLoc = StartLoc;
1089     Op->EndLoc = EndLoc;
1090     return Op;
1091   }
1092
1093   static std::unique_ptr<MipsOperand>
1094   CreateRegPair(unsigned RegNo, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1095     auto Op = make_unique<MipsOperand>(k_RegPair, Parser);
1096     Op->RegIdx.Index = RegNo;
1097     Op->StartLoc = S;
1098     Op->EndLoc = E;
1099     return Op;
1100   }
1101
1102   bool isGPRAsmReg() const {
1103     return isRegIdx() && RegIdx.Kind & RegKind_GPR && RegIdx.Index <= 31;
1104   }
1105   bool isMM16AsmReg() const {
1106     if (!(isRegIdx() && RegIdx.Kind))
1107       return false;
1108     return ((RegIdx.Index >= 2 && RegIdx.Index <= 7)
1109             || RegIdx.Index == 16 || RegIdx.Index == 17);
1110   }
1111   bool isMM16AsmRegZero() const {
1112     if (!(isRegIdx() && RegIdx.Kind))
1113       return false;
1114     return (RegIdx.Index == 0 ||
1115             (RegIdx.Index >= 2 && RegIdx.Index <= 7) ||
1116             RegIdx.Index == 17);
1117   }
1118   bool isMM16AsmRegMoveP() const {
1119     if (!(isRegIdx() && RegIdx.Kind))
1120       return false;
1121     return (RegIdx.Index == 0 || (RegIdx.Index >= 2 && RegIdx.Index <= 3) ||
1122       (RegIdx.Index >= 16 && RegIdx.Index <= 20));
1123   }
1124   bool isFGRAsmReg() const {
1125     // AFGR64 is $0-$15 but we handle this in getAFGR64()
1126     return isRegIdx() && RegIdx.Kind & RegKind_FGR && RegIdx.Index <= 31;
1127   }
1128   bool isHWRegsAsmReg() const {
1129     return isRegIdx() && RegIdx.Kind & RegKind_HWRegs && RegIdx.Index <= 31;
1130   }
1131   bool isCCRAsmReg() const {
1132     return isRegIdx() && RegIdx.Kind & RegKind_CCR && RegIdx.Index <= 31;
1133   }
1134   bool isFCCAsmReg() const {
1135     if (!(isRegIdx() && RegIdx.Kind & RegKind_FCC))
1136       return false;
1137     if (!AsmParser.hasEightFccRegisters())
1138       return RegIdx.Index == 0;
1139     return RegIdx.Index <= 7;
1140   }
1141   bool isACCAsmReg() const {
1142     return isRegIdx() && RegIdx.Kind & RegKind_ACC && RegIdx.Index <= 3;
1143   }
1144   bool isCOP2AsmReg() const {
1145     return isRegIdx() && RegIdx.Kind & RegKind_COP2 && RegIdx.Index <= 31;
1146   }
1147   bool isCOP3AsmReg() const {
1148     return isRegIdx() && RegIdx.Kind & RegKind_COP3 && RegIdx.Index <= 31;
1149   }
1150   bool isMSA128AsmReg() const {
1151     return isRegIdx() && RegIdx.Kind & RegKind_MSA128 && RegIdx.Index <= 31;
1152   }
1153   bool isMSACtrlAsmReg() const {
1154     return isRegIdx() && RegIdx.Kind & RegKind_MSACtrl && RegIdx.Index <= 7;
1155   }
1156
1157   /// getStartLoc - Get the location of the first token of this operand.
1158   SMLoc getStartLoc() const override { return StartLoc; }
1159   /// getEndLoc - Get the location of the last token of this operand.
1160   SMLoc getEndLoc() const override { return EndLoc; }
1161
1162   virtual ~MipsOperand() {
1163     switch (Kind) {
1164     case k_Immediate:
1165       break;
1166     case k_Memory:
1167       delete Mem.Base;
1168       break;
1169     case k_RegList:
1170       delete RegList.List;
1171     case k_PhysRegister:
1172     case k_RegisterIndex:
1173     case k_Token:
1174     case k_RegPair:
1175       break;
1176     }
1177   }
1178
1179   void print(raw_ostream &OS) const override {
1180     switch (Kind) {
1181     case k_Immediate:
1182       OS << "Imm<";
1183       Imm.Val->print(OS);
1184       OS << ">";
1185       break;
1186     case k_Memory:
1187       OS << "Mem<";
1188       Mem.Base->print(OS);
1189       OS << ", ";
1190       Mem.Off->print(OS);
1191       OS << ">";
1192       break;
1193     case k_PhysRegister:
1194       OS << "PhysReg<" << PhysReg.Num << ">";
1195       break;
1196     case k_RegisterIndex:
1197       OS << "RegIdx<" << RegIdx.Index << ":" << RegIdx.Kind << ">";
1198       break;
1199     case k_Token:
1200       OS << Tok.Data;
1201       break;
1202     case k_RegList:
1203       OS << "RegList< ";
1204       for (auto Reg : (*RegList.List))
1205         OS << Reg << " ";
1206       OS <<  ">";
1207       break;
1208     case k_RegPair:
1209       OS << "RegPair<" << RegIdx.Index << "," << RegIdx.Index + 1 << ">";
1210       break;
1211     }
1212   }
1213 }; // class MipsOperand
1214 } // namespace
1215
1216 namespace llvm {
1217 extern const MCInstrDesc MipsInsts[];
1218 }
1219 static const MCInstrDesc &getInstDesc(unsigned Opcode) {
1220   return MipsInsts[Opcode];
1221 }
1222
1223 static bool hasShortDelaySlot(unsigned Opcode) {
1224   switch (Opcode) {
1225     case Mips::JALS_MM:
1226     case Mips::JALRS_MM:
1227     case Mips::JALRS16_MM:
1228     case Mips::BGEZALS_MM:
1229     case Mips::BLTZALS_MM:
1230       return true;
1231     default:
1232       return false;
1233   }
1234 }
1235
1236 bool MipsAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
1237                                        SmallVectorImpl<MCInst> &Instructions) {
1238   const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
1239
1240   Inst.setLoc(IDLoc);
1241
1242   if (MCID.isBranch() || MCID.isCall()) {
1243     const unsigned Opcode = Inst.getOpcode();
1244     MCOperand Offset;
1245
1246     switch (Opcode) {
1247     default:
1248       break;
1249     case Mips::BBIT0:
1250     case Mips::BBIT032:
1251     case Mips::BBIT1:
1252     case Mips::BBIT132:
1253       assert(hasCnMips() && "instruction only valid for octeon cpus");
1254       // Fall through
1255
1256     case Mips::BEQ:
1257     case Mips::BNE:
1258     case Mips::BEQ_MM:
1259     case Mips::BNE_MM:
1260       assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1261       Offset = Inst.getOperand(2);
1262       if (!Offset.isImm())
1263         break; // We'll deal with this situation later on when applying fixups.
1264       if (!isIntN(inMicroMipsMode() ? 17 : 18, Offset.getImm()))
1265         return Error(IDLoc, "branch target out of range");
1266       if (OffsetToAlignment(Offset.getImm(),
1267                             1LL << (inMicroMipsMode() ? 1 : 2)))
1268         return Error(IDLoc, "branch to misaligned address");
1269       break;
1270     case Mips::BGEZ:
1271     case Mips::BGTZ:
1272     case Mips::BLEZ:
1273     case Mips::BLTZ:
1274     case Mips::BGEZAL:
1275     case Mips::BLTZAL:
1276     case Mips::BC1F:
1277     case Mips::BC1T:
1278     case Mips::BGEZ_MM:
1279     case Mips::BGTZ_MM:
1280     case Mips::BLEZ_MM:
1281     case Mips::BLTZ_MM:
1282     case Mips::BGEZAL_MM:
1283     case Mips::BLTZAL_MM:
1284     case Mips::BC1F_MM:
1285     case Mips::BC1T_MM:
1286       assert(MCID.getNumOperands() == 2 && "unexpected number of operands");
1287       Offset = Inst.getOperand(1);
1288       if (!Offset.isImm())
1289         break; // We'll deal with this situation later on when applying fixups.
1290       if (!isIntN(inMicroMipsMode() ? 17 : 18, Offset.getImm()))
1291         return Error(IDLoc, "branch target out of range");
1292       if (OffsetToAlignment(Offset.getImm(),
1293                             1LL << (inMicroMipsMode() ? 1 : 2)))
1294         return Error(IDLoc, "branch to misaligned address");
1295       break;
1296     case Mips::BEQZ16_MM:
1297     case Mips::BNEZ16_MM:
1298       assert(MCID.getNumOperands() == 2 && "unexpected number of operands");
1299       Offset = Inst.getOperand(1);
1300       if (!Offset.isImm())
1301         break; // We'll deal with this situation later on when applying fixups.
1302       if (!isIntN(8, Offset.getImm()))
1303         return Error(IDLoc, "branch target out of range");
1304       if (OffsetToAlignment(Offset.getImm(), 2LL))
1305         return Error(IDLoc, "branch to misaligned address");
1306       break;
1307     }
1308   }
1309
1310   // SSNOP is deprecated on MIPS32r6/MIPS64r6
1311   // We still accept it but it is a normal nop.
1312   if (hasMips32r6() && Inst.getOpcode() == Mips::SSNOP) {
1313     std::string ISA = hasMips64r6() ? "MIPS64r6" : "MIPS32r6";
1314     Warning(IDLoc, "ssnop is deprecated for " + ISA + " and is equivalent to a "
1315                                                       "nop instruction");
1316   }
1317
1318   if (hasCnMips()) {
1319     const unsigned Opcode = Inst.getOpcode();
1320     MCOperand Opnd;
1321     int Imm;
1322
1323     switch (Opcode) {
1324       default:
1325         break;
1326
1327       case Mips::BBIT0:
1328       case Mips::BBIT032:
1329       case Mips::BBIT1:
1330       case Mips::BBIT132:
1331         assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1332         // The offset is handled above
1333         Opnd = Inst.getOperand(1);
1334         if (!Opnd.isImm())
1335           return Error(IDLoc, "expected immediate operand kind");
1336         Imm = Opnd.getImm();
1337         if (Imm < 0 || Imm > (Opcode == Mips::BBIT0 ||
1338                               Opcode == Mips::BBIT1 ? 63 : 31))
1339           return Error(IDLoc, "immediate operand value out of range");
1340         if (Imm > 31) {
1341           Inst.setOpcode(Opcode == Mips::BBIT0 ? Mips::BBIT032
1342                                                : Mips::BBIT132);
1343           Inst.getOperand(1).setImm(Imm - 32);
1344         }
1345         break;
1346
1347       case Mips::CINS:
1348       case Mips::CINS32:
1349       case Mips::EXTS:
1350       case Mips::EXTS32:
1351         assert(MCID.getNumOperands() == 4 && "unexpected number of operands");
1352         // Check length
1353         Opnd = Inst.getOperand(3);
1354         if (!Opnd.isImm())
1355           return Error(IDLoc, "expected immediate operand kind");
1356         Imm = Opnd.getImm();
1357         if (Imm < 0 || Imm > 31)
1358           return Error(IDLoc, "immediate operand value out of range");
1359         // Check position
1360         Opnd = Inst.getOperand(2);
1361         if (!Opnd.isImm())
1362           return Error(IDLoc, "expected immediate operand kind");
1363         Imm = Opnd.getImm();
1364         if (Imm < 0 || Imm > (Opcode == Mips::CINS ||
1365                               Opcode == Mips::EXTS ? 63 : 31))
1366           return Error(IDLoc, "immediate operand value out of range");
1367         if (Imm > 31) {
1368           Inst.setOpcode(Opcode == Mips::CINS ? Mips::CINS32 : Mips::EXTS32);
1369           Inst.getOperand(2).setImm(Imm - 32);
1370         }
1371         break;
1372
1373       case Mips::SEQi:
1374       case Mips::SNEi:
1375         assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1376         Opnd = Inst.getOperand(2);
1377         if (!Opnd.isImm())
1378           return Error(IDLoc, "expected immediate operand kind");
1379         Imm = Opnd.getImm();
1380         if (!isInt<10>(Imm))
1381           return Error(IDLoc, "immediate operand value out of range");
1382         break;
1383     }
1384   }
1385
1386   if (MCID.mayLoad() || MCID.mayStore()) {
1387     // Check the offset of memory operand, if it is a symbol
1388     // reference or immediate we may have to expand instructions.
1389     for (unsigned i = 0; i < MCID.getNumOperands(); i++) {
1390       const MCOperandInfo &OpInfo = MCID.OpInfo[i];
1391       if ((OpInfo.OperandType == MCOI::OPERAND_MEMORY) ||
1392           (OpInfo.OperandType == MCOI::OPERAND_UNKNOWN)) {
1393         MCOperand &Op = Inst.getOperand(i);
1394         if (Op.isImm()) {
1395           int MemOffset = Op.getImm();
1396           if (MemOffset < -32768 || MemOffset > 32767) {
1397             // Offset can't exceed 16bit value.
1398             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), true);
1399             return false;
1400           }
1401         } else if (Op.isExpr()) {
1402           const MCExpr *Expr = Op.getExpr();
1403           if (Expr->getKind() == MCExpr::SymbolRef) {
1404             const MCSymbolRefExpr *SR =
1405                 static_cast<const MCSymbolRefExpr *>(Expr);
1406             if (SR->getKind() == MCSymbolRefExpr::VK_None) {
1407               // Expand symbol.
1408               expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
1409               return false;
1410             }
1411           } else if (!isEvaluated(Expr)) {
1412             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
1413             return false;
1414           }
1415         }
1416       }
1417     } // for
1418   }   // if load/store
1419
1420   if (inMicroMipsMode()) {
1421     if (MCID.mayLoad()) {
1422       // Try to create 16-bit GP relative load instruction.
1423       for (unsigned i = 0; i < MCID.getNumOperands(); i++) {
1424         const MCOperandInfo &OpInfo = MCID.OpInfo[i];
1425         if ((OpInfo.OperandType == MCOI::OPERAND_MEMORY) ||
1426             (OpInfo.OperandType == MCOI::OPERAND_UNKNOWN)) {
1427           MCOperand &Op = Inst.getOperand(i);
1428           if (Op.isImm()) {
1429             int MemOffset = Op.getImm();
1430             MCOperand &DstReg = Inst.getOperand(0);
1431             MCOperand &BaseReg = Inst.getOperand(1);
1432             if (isIntN(9, MemOffset) && (MemOffset % 4 == 0) &&
1433                 getContext().getRegisterInfo()->getRegClass(
1434                   Mips::GPRMM16RegClassID).contains(DstReg.getReg()) &&
1435                 BaseReg.getReg() == Mips::GP) {
1436               MCInst TmpInst;
1437               TmpInst.setLoc(IDLoc);
1438               TmpInst.setOpcode(Mips::LWGP_MM);
1439               TmpInst.addOperand(MCOperand::CreateReg(DstReg.getReg()));
1440               TmpInst.addOperand(MCOperand::CreateReg(Mips::GP));
1441               TmpInst.addOperand(MCOperand::CreateImm(MemOffset));
1442               Instructions.push_back(TmpInst);
1443               return false;
1444             }
1445           }
1446         }
1447       } // for
1448     }   // if load
1449
1450     // TODO: Handle this with the AsmOperandClass.PredicateMethod.
1451
1452     MCOperand Opnd;
1453     int Imm;
1454
1455     switch (Inst.getOpcode()) {
1456       default:
1457         break;
1458       case Mips::ADDIUS5_MM:
1459         Opnd = Inst.getOperand(2);
1460         if (!Opnd.isImm())
1461           return Error(IDLoc, "expected immediate operand kind");
1462         Imm = Opnd.getImm();
1463         if (Imm < -8 || Imm > 7)
1464           return Error(IDLoc, "immediate operand value out of range");
1465         break;
1466       case Mips::ADDIUSP_MM:
1467         Opnd = Inst.getOperand(0);
1468         if (!Opnd.isImm())
1469           return Error(IDLoc, "expected immediate operand kind");
1470         Imm = Opnd.getImm();
1471         if (Imm < -1032 || Imm > 1028 || (Imm < 8 && Imm > -12) ||
1472             Imm % 4 != 0)
1473           return Error(IDLoc, "immediate operand value out of range");
1474         break;
1475       case Mips::SLL16_MM:
1476       case Mips::SRL16_MM:
1477         Opnd = Inst.getOperand(2);
1478         if (!Opnd.isImm())
1479           return Error(IDLoc, "expected immediate operand kind");
1480         Imm = Opnd.getImm();
1481         if (Imm < 1 || Imm > 8)
1482           return Error(IDLoc, "immediate operand value out of range");
1483         break;
1484       case Mips::LI16_MM:
1485         Opnd = Inst.getOperand(1);
1486         if (!Opnd.isImm())
1487           return Error(IDLoc, "expected immediate operand kind");
1488         Imm = Opnd.getImm();
1489         if (Imm < -1 || Imm > 126)
1490           return Error(IDLoc, "immediate operand value out of range");
1491         break;
1492       case Mips::ADDIUR2_MM:
1493         Opnd = Inst.getOperand(2);
1494         if (!Opnd.isImm())
1495           return Error(IDLoc, "expected immediate operand kind");
1496         Imm = Opnd.getImm();
1497         if (!(Imm == 1 || Imm == -1 ||
1498               ((Imm % 4 == 0) && Imm < 28 && Imm > 0)))
1499           return Error(IDLoc, "immediate operand value out of range");
1500         break;
1501       case Mips::ADDIUR1SP_MM:
1502         Opnd = Inst.getOperand(1);
1503         if (!Opnd.isImm())
1504           return Error(IDLoc, "expected immediate operand kind");
1505         Imm = Opnd.getImm();
1506         if (OffsetToAlignment(Imm, 4LL))
1507           return Error(IDLoc, "misaligned immediate operand value");
1508         if (Imm < 0 || Imm > 255)
1509           return Error(IDLoc, "immediate operand value out of range");
1510         break;
1511       case Mips::ANDI16_MM:
1512         Opnd = Inst.getOperand(2);
1513         if (!Opnd.isImm())
1514           return Error(IDLoc, "expected immediate operand kind");
1515         Imm = Opnd.getImm();
1516         if (!(Imm == 128 || (Imm >= 1 && Imm <= 4) || Imm == 7 || Imm == 8 ||
1517               Imm == 15 || Imm == 16 || Imm == 31 || Imm == 32 || Imm == 63 ||
1518               Imm == 64 || Imm == 255 || Imm == 32768 || Imm == 65535))
1519           return Error(IDLoc, "immediate operand value out of range");
1520         break;
1521       case Mips::LBU16_MM:
1522         Opnd = Inst.getOperand(2);
1523         if (!Opnd.isImm())
1524           return Error(IDLoc, "expected immediate operand kind");
1525         Imm = Opnd.getImm();
1526         if (Imm < -1 || Imm > 14)
1527           return Error(IDLoc, "immediate operand value out of range");
1528         break;
1529       case Mips::SB16_MM:
1530         Opnd = Inst.getOperand(2);
1531         if (!Opnd.isImm())
1532           return Error(IDLoc, "expected immediate operand kind");
1533         Imm = Opnd.getImm();
1534         if (Imm < 0 || Imm > 15)
1535           return Error(IDLoc, "immediate operand value out of range");
1536         break;
1537       case Mips::LHU16_MM:
1538       case Mips::SH16_MM:
1539         Opnd = Inst.getOperand(2);
1540         if (!Opnd.isImm())
1541           return Error(IDLoc, "expected immediate operand kind");
1542         Imm = Opnd.getImm();
1543         if (Imm < 0 || Imm > 30 || (Imm % 2 != 0))
1544           return Error(IDLoc, "immediate operand value out of range");
1545         break;
1546       case Mips::LW16_MM:
1547       case Mips::SW16_MM:
1548         Opnd = Inst.getOperand(2);
1549         if (!Opnd.isImm())
1550           return Error(IDLoc, "expected immediate operand kind");
1551         Imm = Opnd.getImm();
1552         if (Imm < 0 || Imm > 60 || (Imm % 4 != 0))
1553           return Error(IDLoc, "immediate operand value out of range");
1554         break;
1555       case Mips::CACHE:
1556       case Mips::PREF:
1557         Opnd = Inst.getOperand(2);
1558         if (!Opnd.isImm())
1559           return Error(IDLoc, "expected immediate operand kind");
1560         Imm = Opnd.getImm();
1561         if (!isUInt<5>(Imm))
1562           return Error(IDLoc, "immediate operand value out of range");
1563         break;
1564       case Mips::ADDIUPC_MM:
1565         MCOperand Opnd = Inst.getOperand(1);
1566         if (!Opnd.isImm())
1567           return Error(IDLoc, "expected immediate operand kind");
1568         int Imm = Opnd.getImm();
1569         if ((Imm % 4 != 0) || !isIntN(25, Imm))
1570           return Error(IDLoc, "immediate operand value out of range");
1571         break;
1572     }
1573   }
1574
1575   if (needsExpansion(Inst)) {
1576     if (expandInstruction(Inst, IDLoc, Instructions))
1577       return true;
1578   } else
1579     Instructions.push_back(Inst);
1580
1581   // If this instruction has a delay slot and .set reorder is active,
1582   // emit a NOP after it.
1583   if (MCID.hasDelaySlot() && AssemblerOptions.back()->isReorder())
1584     createNop(hasShortDelaySlot(Inst.getOpcode()), IDLoc, Instructions);
1585
1586   return false;
1587 }
1588
1589 bool MipsAsmParser::needsExpansion(MCInst &Inst) {
1590
1591   switch (Inst.getOpcode()) {
1592   case Mips::LoadImm32:
1593   case Mips::LoadImm64:
1594   case Mips::LoadAddrImm32:
1595   case Mips::LoadAddrReg32:
1596   case Mips::B_MM_Pseudo:
1597   case Mips::LWM_MM:
1598   case Mips::SWM_MM:
1599   case Mips::JalOneReg:
1600   case Mips::JalTwoReg:
1601     return true;
1602   default:
1603     return false;
1604   }
1605 }
1606
1607 bool MipsAsmParser::expandInstruction(MCInst &Inst, SMLoc IDLoc,
1608                                       SmallVectorImpl<MCInst> &Instructions) {
1609   switch (Inst.getOpcode()) {
1610   default: llvm_unreachable("unimplemented expansion");
1611   case Mips::LoadImm32:
1612     return expandLoadImm(Inst, IDLoc, Instructions);
1613   case Mips::LoadImm64:
1614     if (!isGP64bit()) {
1615       Error(IDLoc, "instruction requires a 64-bit architecture");
1616       return true;
1617     }
1618     return expandLoadImm(Inst, IDLoc, Instructions);
1619   case Mips::LoadAddrImm32:
1620     return expandLoadAddressImm(Inst, IDLoc, Instructions);
1621   case Mips::LoadAddrReg32:
1622     return expandLoadAddressReg(Inst, IDLoc, Instructions);
1623   case Mips::B_MM_Pseudo:
1624     return expandUncondBranchMMPseudo(Inst, IDLoc, Instructions);
1625   case Mips::SWM_MM:
1626   case Mips::LWM_MM:
1627     return expandLoadStoreMultiple(Inst, IDLoc, Instructions);
1628   case Mips::JalOneReg:
1629   case Mips::JalTwoReg:
1630     return expandJalWithRegs(Inst, IDLoc, Instructions);
1631   }
1632 }
1633
1634 namespace {
1635 template <bool PerformShift>
1636 void createShiftOr(MCOperand Operand, unsigned RegNo, SMLoc IDLoc,
1637                    SmallVectorImpl<MCInst> &Instructions) {
1638   MCInst tmpInst;
1639   if (PerformShift) {
1640     tmpInst.setOpcode(Mips::DSLL);
1641     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1642     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1643     tmpInst.addOperand(MCOperand::CreateImm(16));
1644     tmpInst.setLoc(IDLoc);
1645     Instructions.push_back(tmpInst);
1646     tmpInst.clear();
1647   }
1648   tmpInst.setOpcode(Mips::ORi);
1649   tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1650   tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1651   tmpInst.addOperand(Operand);
1652   tmpInst.setLoc(IDLoc);
1653   Instructions.push_back(tmpInst);
1654 }
1655
1656 template <int Shift, bool PerformShift>
1657 void createShiftOr(int64_t Value, unsigned RegNo, SMLoc IDLoc,
1658                    SmallVectorImpl<MCInst> &Instructions) {
1659   createShiftOr<PerformShift>(
1660       MCOperand::CreateImm(((Value & (0xffffLL << Shift)) >> Shift)), RegNo,
1661       IDLoc, Instructions);
1662 }
1663 }
1664
1665 bool MipsAsmParser::expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
1666                                       SmallVectorImpl<MCInst> &Instructions) {
1667   // Create a JALR instruction which is going to replace the pseudo-JAL.
1668   MCInst JalrInst;
1669   JalrInst.setLoc(IDLoc);
1670   const MCOperand FirstRegOp = Inst.getOperand(0);
1671   const unsigned Opcode = Inst.getOpcode();
1672
1673   if (Opcode == Mips::JalOneReg) {
1674     // jal $rs => jalr $rs
1675     if (inMicroMipsMode()) {
1676       JalrInst.setOpcode(Mips::JALR16_MM);
1677       JalrInst.addOperand(FirstRegOp);
1678     } else {
1679       JalrInst.setOpcode(Mips::JALR);
1680       JalrInst.addOperand(MCOperand::CreateReg(Mips::RA));
1681       JalrInst.addOperand(FirstRegOp);
1682     }
1683   } else if (Opcode == Mips::JalTwoReg) {
1684     // jal $rd, $rs => jalr $rd, $rs
1685     JalrInst.setOpcode(inMicroMipsMode() ? Mips::JALR_MM : Mips::JALR);
1686     JalrInst.addOperand(FirstRegOp);
1687     const MCOperand SecondRegOp = Inst.getOperand(1);
1688     JalrInst.addOperand(SecondRegOp);
1689   }
1690   Instructions.push_back(JalrInst);
1691
1692   // If .set reorder is active, emit a NOP after it.
1693   if (AssemblerOptions.back()->isReorder()) {
1694     // This is a 32-bit NOP because these 2 pseudo-instructions
1695     // do not have a short delay slot.
1696     MCInst NopInst;
1697     NopInst.setOpcode(Mips::SLL);
1698     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1699     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1700     NopInst.addOperand(MCOperand::CreateImm(0));
1701     Instructions.push_back(NopInst);
1702   }
1703
1704   return false;
1705 }
1706
1707 bool MipsAsmParser::expandLoadImm(MCInst &Inst, SMLoc IDLoc,
1708                                   SmallVectorImpl<MCInst> &Instructions) {
1709   MCInst tmpInst;
1710   const MCOperand &ImmOp = Inst.getOperand(1);
1711   assert(ImmOp.isImm() && "expected immediate operand kind");
1712   const MCOperand &RegOp = Inst.getOperand(0);
1713   assert(RegOp.isReg() && "expected register operand kind");
1714
1715   int64_t ImmValue = ImmOp.getImm();
1716   tmpInst.setLoc(IDLoc);
1717   // FIXME: gas has a special case for values that are 000...1111, which
1718   // becomes a li -1 and then a dsrl
1719   if (0 <= ImmValue && ImmValue <= 65535) {
1720     // For unsigned and positive signed 16-bit values (0 <= j <= 65535):
1721     // li d,j => ori d,$zero,j
1722     tmpInst.setOpcode(Mips::ORi);
1723     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1724     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1725     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
1726     Instructions.push_back(tmpInst);
1727   } else if (ImmValue < 0 && ImmValue >= -32768) {
1728     // For negative signed 16-bit values (-32768 <= j < 0):
1729     // li d,j => addiu d,$zero,j
1730     tmpInst.setOpcode(Mips::ADDiu);
1731     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1732     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1733     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
1734     Instructions.push_back(tmpInst);
1735   } else if ((ImmValue & 0xffffffff) == ImmValue) {
1736     // For all other values which are representable as a 32-bit integer:
1737     // li d,j => lui d,hi16(j)
1738     //           ori d,d,lo16(j)
1739     tmpInst.setOpcode(Mips::LUi);
1740     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1741     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
1742     Instructions.push_back(tmpInst);
1743     createShiftOr<0, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1744   } else if ((ImmValue & (0xffffLL << 48)) == 0) {
1745     if (!isGP64bit()) {
1746       Error(IDLoc, "instruction requires a 64-bit architecture");
1747       return true;
1748     }
1749
1750     //            <-------  lo32 ------>
1751     // <-------  hi32 ------>
1752     // <- hi16 ->             <- lo16 ->
1753     //  _________________________________
1754     // |          |          |          |
1755     // | 16-bytes | 16-bytes | 16-bytes |
1756     // |__________|__________|__________|
1757     //
1758     // For any 64-bit value that is representable as a 48-bit integer:
1759     // li d,j => lui d,hi16(j)
1760     //           ori d,d,hi16(lo32(j))
1761     //           dsll d,d,16
1762     //           ori d,d,lo16(lo32(j))
1763     tmpInst.setOpcode(Mips::LUi);
1764     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1765     tmpInst.addOperand(
1766         MCOperand::CreateImm((ImmValue & (0xffffLL << 32)) >> 32));
1767     Instructions.push_back(tmpInst);
1768     createShiftOr<16, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1769     createShiftOr<0, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1770   } else {
1771     if (!isGP64bit()) {
1772       Error(IDLoc, "instruction requires a 64-bit architecture");
1773       return true;
1774     }
1775
1776     // <-------  hi32 ------> <-------  lo32 ------>
1777     // <- hi16 ->                        <- lo16 ->
1778     //  ___________________________________________
1779     // |          |          |          |          |
1780     // | 16-bytes | 16-bytes | 16-bytes | 16-bytes |
1781     // |__________|__________|__________|__________|
1782     //
1783     // For all other values which are representable as a 64-bit integer:
1784     // li d,j => lui d,hi16(j)
1785     //           ori d,d,lo16(hi32(j))
1786     //           dsll d,d,16
1787     //           ori d,d,hi16(lo32(j))
1788     //           dsll d,d,16
1789     //           ori d,d,lo16(lo32(j))
1790     tmpInst.setOpcode(Mips::LUi);
1791     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1792     tmpInst.addOperand(
1793         MCOperand::CreateImm((ImmValue & (0xffffLL << 48)) >> 48));
1794     Instructions.push_back(tmpInst);
1795     createShiftOr<32, false>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1796     createShiftOr<16, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1797     createShiftOr<0, true>(ImmValue, RegOp.getReg(), IDLoc, Instructions);
1798   }
1799   return false;
1800 }
1801
1802 bool
1803 MipsAsmParser::expandLoadAddressReg(MCInst &Inst, SMLoc IDLoc,
1804                                     SmallVectorImpl<MCInst> &Instructions) {
1805   MCInst tmpInst;
1806   const MCOperand &ImmOp = Inst.getOperand(2);
1807   assert((ImmOp.isImm() || ImmOp.isExpr()) &&
1808          "expected immediate operand kind");
1809   if (!ImmOp.isImm()) {
1810     expandLoadAddressSym(Inst, IDLoc, Instructions);
1811     return false;
1812   }
1813   const MCOperand &SrcRegOp = Inst.getOperand(1);
1814   assert(SrcRegOp.isReg() && "expected register operand kind");
1815   const MCOperand &DstRegOp = Inst.getOperand(0);
1816   assert(DstRegOp.isReg() && "expected register operand kind");
1817   int ImmValue = ImmOp.getImm();
1818   if (-32768 <= ImmValue && ImmValue <= 65535) {
1819     // For -32768 <= j <= 65535.
1820     // la d,j(s) => addiu d,s,j
1821     tmpInst.setOpcode(Mips::ADDiu);
1822     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1823     tmpInst.addOperand(MCOperand::CreateReg(SrcRegOp.getReg()));
1824     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
1825     Instructions.push_back(tmpInst);
1826   } else {
1827     // For any other value of j that is representable as a 32-bit integer.
1828     // la d,j(s) => lui d,hi16(j)
1829     //              ori d,d,lo16(j)
1830     //              addu d,d,s
1831     tmpInst.setOpcode(Mips::LUi);
1832     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1833     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
1834     Instructions.push_back(tmpInst);
1835     tmpInst.clear();
1836     tmpInst.setOpcode(Mips::ORi);
1837     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1838     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1839     tmpInst.addOperand(MCOperand::CreateImm(ImmValue & 0xffff));
1840     Instructions.push_back(tmpInst);
1841     tmpInst.clear();
1842     tmpInst.setOpcode(Mips::ADDu);
1843     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1844     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
1845     tmpInst.addOperand(MCOperand::CreateReg(SrcRegOp.getReg()));
1846     Instructions.push_back(tmpInst);
1847   }
1848   return false;
1849 }
1850
1851 bool
1852 MipsAsmParser::expandLoadAddressImm(MCInst &Inst, SMLoc IDLoc,
1853                                     SmallVectorImpl<MCInst> &Instructions) {
1854   MCInst tmpInst;
1855   const MCOperand &ImmOp = Inst.getOperand(1);
1856   assert((ImmOp.isImm() || ImmOp.isExpr()) &&
1857          "expected immediate operand kind");
1858   if (!ImmOp.isImm()) {
1859     expandLoadAddressSym(Inst, IDLoc, Instructions);
1860     return false;
1861   }
1862   const MCOperand &RegOp = Inst.getOperand(0);
1863   assert(RegOp.isReg() && "expected register operand kind");
1864   int ImmValue = ImmOp.getImm();
1865   if (-32768 <= ImmValue && ImmValue <= 65535) {
1866     // For -32768 <= j <= 65535.
1867     // la d,j => addiu d,$zero,j
1868     tmpInst.setOpcode(Mips::ADDiu);
1869     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1870     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1871     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
1872     Instructions.push_back(tmpInst);
1873   } else {
1874     // For any other value of j that is representable as a 32-bit integer.
1875     // la d,j => lui d,hi16(j)
1876     //           ori d,d,lo16(j)
1877     tmpInst.setOpcode(Mips::LUi);
1878     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1879     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
1880     Instructions.push_back(tmpInst);
1881     tmpInst.clear();
1882     tmpInst.setOpcode(Mips::ORi);
1883     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1884     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
1885     tmpInst.addOperand(MCOperand::CreateImm(ImmValue & 0xffff));
1886     Instructions.push_back(tmpInst);
1887   }
1888   return false;
1889 }
1890
1891 void
1892 MipsAsmParser::expandLoadAddressSym(MCInst &Inst, SMLoc IDLoc,
1893                                     SmallVectorImpl<MCInst> &Instructions) {
1894   // FIXME: If we do have a valid at register to use, we should generate a
1895   // slightly shorter sequence here.
1896   MCInst tmpInst;
1897   int ExprOperandNo = 1;
1898   // Sometimes the assembly parser will get the immediate expression as
1899   // a $zero + an immediate.
1900   if (Inst.getNumOperands() == 3) {
1901     assert(Inst.getOperand(1).getReg() ==
1902            (isGP64bit() ? Mips::ZERO_64 : Mips::ZERO));
1903     ExprOperandNo = 2;
1904   }
1905   const MCOperand &SymOp = Inst.getOperand(ExprOperandNo);
1906   assert(SymOp.isExpr() && "expected symbol operand kind");
1907   const MCOperand &RegOp = Inst.getOperand(0);
1908   unsigned RegNo = RegOp.getReg();
1909   const MCSymbolRefExpr *Symbol = cast<MCSymbolRefExpr>(SymOp.getExpr());
1910   const MCSymbolRefExpr *HiExpr =
1911       MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
1912                               MCSymbolRefExpr::VK_Mips_ABS_HI, getContext());
1913   const MCSymbolRefExpr *LoExpr =
1914       MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
1915                               MCSymbolRefExpr::VK_Mips_ABS_LO, getContext());
1916   if (isGP64bit()) {
1917     // If it's a 64-bit architecture, expand to:
1918     // la d,sym => lui  d,highest(sym)
1919     //             ori  d,d,higher(sym)
1920     //             dsll d,d,16
1921     //             ori  d,d,hi16(sym)
1922     //             dsll d,d,16
1923     //             ori  d,d,lo16(sym)
1924     const MCSymbolRefExpr *HighestExpr =
1925         MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
1926                                 MCSymbolRefExpr::VK_Mips_HIGHEST, getContext());
1927     const MCSymbolRefExpr *HigherExpr =
1928         MCSymbolRefExpr::Create(Symbol->getSymbol().getName(),
1929                                 MCSymbolRefExpr::VK_Mips_HIGHER, getContext());
1930
1931     tmpInst.setOpcode(Mips::LUi);
1932     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1933     tmpInst.addOperand(MCOperand::CreateExpr(HighestExpr));
1934     Instructions.push_back(tmpInst);
1935
1936     createShiftOr<false>(MCOperand::CreateExpr(HigherExpr), RegNo, SMLoc(),
1937                          Instructions);
1938     createShiftOr<true>(MCOperand::CreateExpr(HiExpr), RegNo, SMLoc(),
1939                         Instructions);
1940     createShiftOr<true>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
1941                         Instructions);
1942   } else {
1943     // Otherwise, expand to:
1944     // la d,sym => lui  d,hi16(sym)
1945     //             ori  d,d,lo16(sym)
1946     tmpInst.setOpcode(Mips::LUi);
1947     tmpInst.addOperand(MCOperand::CreateReg(RegNo));
1948     tmpInst.addOperand(MCOperand::CreateExpr(HiExpr));
1949     Instructions.push_back(tmpInst);
1950
1951     createShiftOr<false>(MCOperand::CreateExpr(LoExpr), RegNo, SMLoc(),
1952                          Instructions);
1953   }
1954 }
1955
1956 bool MipsAsmParser::expandUncondBranchMMPseudo(
1957     MCInst &Inst, SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
1958   assert(getInstDesc(Inst.getOpcode()).getNumOperands() == 1 &&
1959          "unexpected number of operands");
1960
1961   MCOperand Offset = Inst.getOperand(0);
1962   if (Offset.isExpr()) {
1963     Inst.clear();
1964     Inst.setOpcode(Mips::BEQ_MM);
1965     Inst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1966     Inst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1967     Inst.addOperand(MCOperand::CreateExpr(Offset.getExpr()));
1968   } else {
1969     assert(Offset.isImm() && "expected immediate operand kind");
1970     if (isIntN(11, Offset.getImm())) {
1971       // If offset fits into 11 bits then this instruction becomes microMIPS
1972       // 16-bit unconditional branch instruction.
1973       Inst.setOpcode(Mips::B16_MM);
1974     } else {
1975       if (!isIntN(17, Offset.getImm()))
1976         Error(IDLoc, "branch target out of range");
1977       if (OffsetToAlignment(Offset.getImm(), 1LL << 1))
1978         Error(IDLoc, "branch to misaligned address");
1979       Inst.clear();
1980       Inst.setOpcode(Mips::BEQ_MM);
1981       Inst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1982       Inst.addOperand(MCOperand::CreateReg(Mips::ZERO));
1983       Inst.addOperand(MCOperand::CreateImm(Offset.getImm()));
1984     }
1985   }
1986   Instructions.push_back(Inst);
1987
1988   // If .set reorder is active, emit a NOP after the branch instruction.
1989   if (AssemblerOptions.back()->isReorder())
1990     createNop(true, IDLoc, Instructions);
1991
1992   return false;
1993 }
1994
1995 void MipsAsmParser::expandMemInst(MCInst &Inst, SMLoc IDLoc,
1996                                   SmallVectorImpl<MCInst> &Instructions,
1997                                   bool isLoad, bool isImmOpnd) {
1998   const MCSymbolRefExpr *SR;
1999   MCInst TempInst;
2000   unsigned ImmOffset, HiOffset, LoOffset;
2001   const MCExpr *ExprOffset;
2002   unsigned TmpRegNum;
2003   // 1st operand is either the source or destination register.
2004   assert(Inst.getOperand(0).isReg() && "expected register operand kind");
2005   unsigned RegOpNum = Inst.getOperand(0).getReg();
2006   // 2nd operand is the base register.
2007   assert(Inst.getOperand(1).isReg() && "expected register operand kind");
2008   unsigned BaseRegNum = Inst.getOperand(1).getReg();
2009   // 3rd operand is either an immediate or expression.
2010   if (isImmOpnd) {
2011     assert(Inst.getOperand(2).isImm() && "expected immediate operand kind");
2012     ImmOffset = Inst.getOperand(2).getImm();
2013     LoOffset = ImmOffset & 0x0000ffff;
2014     HiOffset = (ImmOffset & 0xffff0000) >> 16;
2015     // If msb of LoOffset is 1(negative number) we must increment HiOffset.
2016     if (LoOffset & 0x8000)
2017       HiOffset++;
2018   } else
2019     ExprOffset = Inst.getOperand(2).getExpr();
2020   // All instructions will have the same location.
2021   TempInst.setLoc(IDLoc);
2022   // These are some of the types of expansions we perform here:
2023   // 1) lw $8, sym        => lui $8, %hi(sym)
2024   //                         lw $8, %lo(sym)($8)
2025   // 2) lw $8, offset($9) => lui $8, %hi(offset)
2026   //                         add $8, $8, $9
2027   //                         lw $8, %lo(offset)($9)
2028   // 3) lw $8, offset($8) => lui $at, %hi(offset)
2029   //                         add $at, $at, $8
2030   //                         lw $8, %lo(offset)($at)
2031   // 4) sw $8, sym        => lui $at, %hi(sym)
2032   //                         sw $8, %lo(sym)($at)
2033   // 5) sw $8, offset($8) => lui $at, %hi(offset)
2034   //                         add $at, $at, $8
2035   //                         sw $8, %lo(offset)($at)
2036   // 6) ldc1 $f0, sym     => lui $at, %hi(sym)
2037   //                         ldc1 $f0, %lo(sym)($at)
2038   //
2039   // For load instructions we can use the destination register as a temporary
2040   // if base and dst are different (examples 1 and 2) and if the base register
2041   // is general purpose otherwise we must use $at (example 6) and error if it's
2042   // not available. For stores we must use $at (examples 4 and 5) because we
2043   // must not clobber the source register setting up the offset.
2044   const MCInstrDesc &Desc = getInstDesc(Inst.getOpcode());
2045   int16_t RegClassOp0 = Desc.OpInfo[0].RegClass;
2046   unsigned RegClassIDOp0 =
2047       getContext().getRegisterInfo()->getRegClass(RegClassOp0).getID();
2048   bool IsGPR = (RegClassIDOp0 == Mips::GPR32RegClassID) ||
2049                (RegClassIDOp0 == Mips::GPR64RegClassID);
2050   if (isLoad && IsGPR && (BaseRegNum != RegOpNum))
2051     TmpRegNum = RegOpNum;
2052   else {
2053     // At this point we need AT to perform the expansions and we exit if it is
2054     // not available.
2055     TmpRegNum = getATReg(IDLoc);
2056     if (!TmpRegNum)
2057       return;
2058   }
2059
2060   TempInst.setOpcode(Mips::LUi);
2061   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
2062   if (isImmOpnd)
2063     TempInst.addOperand(MCOperand::CreateImm(HiOffset));
2064   else {
2065     if (ExprOffset->getKind() == MCExpr::SymbolRef) {
2066       SR = static_cast<const MCSymbolRefExpr *>(ExprOffset);
2067       const MCSymbolRefExpr *HiExpr = MCSymbolRefExpr::Create(
2068           SR->getSymbol().getName(), MCSymbolRefExpr::VK_Mips_ABS_HI,
2069           getContext());
2070       TempInst.addOperand(MCOperand::CreateExpr(HiExpr));
2071     } else {
2072       const MCExpr *HiExpr = evaluateRelocExpr(ExprOffset, "hi");
2073       TempInst.addOperand(MCOperand::CreateExpr(HiExpr));
2074     }
2075   }
2076   // Add the instruction to the list.
2077   Instructions.push_back(TempInst);
2078   // Prepare TempInst for next instruction.
2079   TempInst.clear();
2080   // Add temp register to base.
2081   if (BaseRegNum != Mips::ZERO) {
2082     TempInst.setOpcode(Mips::ADDu);
2083     TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
2084     TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
2085     TempInst.addOperand(MCOperand::CreateReg(BaseRegNum));
2086     Instructions.push_back(TempInst);
2087     TempInst.clear();
2088   }
2089   // And finally, create original instruction with low part
2090   // of offset and new base.
2091   TempInst.setOpcode(Inst.getOpcode());
2092   TempInst.addOperand(MCOperand::CreateReg(RegOpNum));
2093   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
2094   if (isImmOpnd)
2095     TempInst.addOperand(MCOperand::CreateImm(LoOffset));
2096   else {
2097     if (ExprOffset->getKind() == MCExpr::SymbolRef) {
2098       const MCSymbolRefExpr *LoExpr = MCSymbolRefExpr::Create(
2099           SR->getSymbol().getName(), MCSymbolRefExpr::VK_Mips_ABS_LO,
2100           getContext());
2101       TempInst.addOperand(MCOperand::CreateExpr(LoExpr));
2102     } else {
2103       const MCExpr *LoExpr = evaluateRelocExpr(ExprOffset, "lo");
2104       TempInst.addOperand(MCOperand::CreateExpr(LoExpr));
2105     }
2106   }
2107   Instructions.push_back(TempInst);
2108   TempInst.clear();
2109 }
2110
2111 bool
2112 MipsAsmParser::expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc,
2113                                        SmallVectorImpl<MCInst> &Instructions) {
2114   unsigned OpNum = Inst.getNumOperands();
2115   unsigned Opcode = Inst.getOpcode();
2116   unsigned NewOpcode = Opcode == Mips::SWM_MM ? Mips::SWM32_MM : Mips::LWM32_MM;
2117
2118   assert (Inst.getOperand(OpNum - 1).isImm() &&
2119           Inst.getOperand(OpNum - 2).isReg() &&
2120           Inst.getOperand(OpNum - 3).isReg() && "Invalid instruction operand.");
2121
2122   if (OpNum < 8 && Inst.getOperand(OpNum - 1).getImm() <= 60 &&
2123       Inst.getOperand(OpNum - 1).getImm() >= 0 &&
2124       Inst.getOperand(OpNum - 2).getReg() == Mips::SP &&
2125       Inst.getOperand(OpNum - 3).getReg() == Mips::RA)
2126     // It can be implemented as SWM16 or LWM16 instruction.
2127     NewOpcode = Opcode == Mips::SWM_MM ? Mips::SWM16_MM : Mips::LWM16_MM;
2128
2129   Inst.setOpcode(NewOpcode);
2130   Instructions.push_back(Inst);
2131   return false;
2132 }
2133
2134 void MipsAsmParser::createNop(bool hasShortDelaySlot, SMLoc IDLoc,
2135                               SmallVectorImpl<MCInst> &Instructions) {
2136   MCInst NopInst;
2137   if (hasShortDelaySlot) {
2138     NopInst.setOpcode(Mips::MOVE16_MM);
2139     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
2140     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
2141   } else {
2142     NopInst.setOpcode(Mips::SLL);
2143     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
2144     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
2145     NopInst.addOperand(MCOperand::CreateImm(0));
2146   }
2147   Instructions.push_back(NopInst);
2148 }
2149
2150 unsigned MipsAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
2151   // As described by the Mips32r2 spec, the registers Rd and Rs for
2152   // jalr.hb must be different.
2153   unsigned Opcode = Inst.getOpcode();
2154
2155   if (Opcode == Mips::JALR_HB &&
2156       (Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg()))
2157     return Match_RequiresDifferentSrcAndDst;
2158
2159   return Match_Success;
2160 }
2161
2162 bool MipsAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
2163                                             OperandVector &Operands,
2164                                             MCStreamer &Out,
2165                                             uint64_t &ErrorInfo,
2166                                             bool MatchingInlineAsm) {
2167
2168   MCInst Inst;
2169   SmallVector<MCInst, 8> Instructions;
2170   unsigned MatchResult =
2171       MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
2172
2173   switch (MatchResult) {
2174   case Match_Success: {
2175     if (processInstruction(Inst, IDLoc, Instructions))
2176       return true;
2177     for (unsigned i = 0; i < Instructions.size(); i++)
2178       Out.EmitInstruction(Instructions[i], STI);
2179     return false;
2180   }
2181   case Match_MissingFeature:
2182     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
2183     return true;
2184   case Match_InvalidOperand: {
2185     SMLoc ErrorLoc = IDLoc;
2186     if (ErrorInfo != ~0ULL) {
2187       if (ErrorInfo >= Operands.size())
2188         return Error(IDLoc, "too few operands for instruction");
2189
2190       ErrorLoc = ((MipsOperand &)*Operands[ErrorInfo]).getStartLoc();
2191       if (ErrorLoc == SMLoc())
2192         ErrorLoc = IDLoc;
2193     }
2194
2195     return Error(ErrorLoc, "invalid operand for instruction");
2196   }
2197   case Match_MnemonicFail:
2198     return Error(IDLoc, "invalid instruction");
2199   case Match_RequiresDifferentSrcAndDst:
2200     return Error(IDLoc, "source and destination must be different");
2201   }
2202
2203   llvm_unreachable("Implement any new match types added!");
2204 }
2205
2206 void MipsAsmParser::warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc) {
2207   if (RegIndex != 0 && AssemblerOptions.back()->getATRegIndex() == RegIndex)
2208     Warning(Loc, "used $at (currently $" + Twine(RegIndex) +
2209                      ") without \".set noat\"");
2210 }
2211
2212 void
2213 MipsAsmParser::printWarningWithFixIt(const Twine &Msg, const Twine &FixMsg,
2214                                      SMRange Range, bool ShowColors) {
2215   getSourceManager().PrintMessage(Range.Start, SourceMgr::DK_Warning, Msg,
2216                                   Range, SMFixIt(Range, FixMsg),
2217                                   ShowColors);
2218 }
2219
2220 int MipsAsmParser::matchCPURegisterName(StringRef Name) {
2221   int CC;
2222
2223   CC = StringSwitch<unsigned>(Name)
2224            .Case("zero", 0)
2225            .Case("at", 1)
2226            .Case("a0", 4)
2227            .Case("a1", 5)
2228            .Case("a2", 6)
2229            .Case("a3", 7)
2230            .Case("v0", 2)
2231            .Case("v1", 3)
2232            .Case("s0", 16)
2233            .Case("s1", 17)
2234            .Case("s2", 18)
2235            .Case("s3", 19)
2236            .Case("s4", 20)
2237            .Case("s5", 21)
2238            .Case("s6", 22)
2239            .Case("s7", 23)
2240            .Case("k0", 26)
2241            .Case("k1", 27)
2242            .Case("gp", 28)
2243            .Case("sp", 29)
2244            .Case("fp", 30)
2245            .Case("s8", 30)
2246            .Case("ra", 31)
2247            .Case("t0", 8)
2248            .Case("t1", 9)
2249            .Case("t2", 10)
2250            .Case("t3", 11)
2251            .Case("t4", 12)
2252            .Case("t5", 13)
2253            .Case("t6", 14)
2254            .Case("t7", 15)
2255            .Case("t8", 24)
2256            .Case("t9", 25)
2257            .Default(-1);
2258
2259   if (!(isABI_N32() || isABI_N64()))
2260     return CC;
2261
2262   if (12 <= CC && CC <= 15) {
2263     // Name is one of t4-t7
2264     AsmToken RegTok = getLexer().peekTok();
2265     SMRange RegRange = RegTok.getLocRange();
2266
2267     StringRef FixedName = StringSwitch<StringRef>(Name)
2268                               .Case("t4", "t0")
2269                               .Case("t5", "t1")
2270                               .Case("t6", "t2")
2271                               .Case("t7", "t3")
2272                               .Default("");
2273     assert(FixedName != "" &&  "Register name is not one of t4-t7.");
2274
2275     printWarningWithFixIt("register names $t4-$t7 are only available in O32.",
2276                           "Did you mean $" + FixedName + "?", RegRange);
2277   }
2278
2279   // Although SGI documentation just cuts out t0-t3 for n32/n64,
2280   // GNU pushes the values of t0-t3 to override the o32/o64 values for t4-t7
2281   // We are supporting both cases, so for t0-t3 we'll just push them to t4-t7.
2282   if (8 <= CC && CC <= 11)
2283     CC += 4;
2284
2285   if (CC == -1)
2286     CC = StringSwitch<unsigned>(Name)
2287              .Case("a4", 8)
2288              .Case("a5", 9)
2289              .Case("a6", 10)
2290              .Case("a7", 11)
2291              .Case("kt0", 26)
2292              .Case("kt1", 27)
2293              .Default(-1);
2294
2295   return CC;
2296 }
2297
2298 int MipsAsmParser::matchHWRegsRegisterName(StringRef Name) {
2299   int CC;
2300
2301   CC = StringSwitch<unsigned>(Name)
2302             .Case("hwr_cpunum", 0)
2303             .Case("hwr_synci_step", 1)
2304             .Case("hwr_cc", 2)
2305             .Case("hwr_ccres", 3)
2306             .Case("hwr_ulr", 29)
2307             .Default(-1);
2308
2309   return CC;
2310 }
2311
2312 int MipsAsmParser::matchFPURegisterName(StringRef Name) {
2313
2314   if (Name[0] == 'f') {
2315     StringRef NumString = Name.substr(1);
2316     unsigned IntVal;
2317     if (NumString.getAsInteger(10, IntVal))
2318       return -1;     // This is not an integer.
2319     if (IntVal > 31) // Maximum index for fpu register.
2320       return -1;
2321     return IntVal;
2322   }
2323   return -1;
2324 }
2325
2326 int MipsAsmParser::matchFCCRegisterName(StringRef Name) {
2327
2328   if (Name.startswith("fcc")) {
2329     StringRef NumString = Name.substr(3);
2330     unsigned IntVal;
2331     if (NumString.getAsInteger(10, IntVal))
2332       return -1;    // This is not an integer.
2333     if (IntVal > 7) // There are only 8 fcc registers.
2334       return -1;
2335     return IntVal;
2336   }
2337   return -1;
2338 }
2339
2340 int MipsAsmParser::matchACRegisterName(StringRef Name) {
2341
2342   if (Name.startswith("ac")) {
2343     StringRef NumString = Name.substr(2);
2344     unsigned IntVal;
2345     if (NumString.getAsInteger(10, IntVal))
2346       return -1;    // This is not an integer.
2347     if (IntVal > 3) // There are only 3 acc registers.
2348       return -1;
2349     return IntVal;
2350   }
2351   return -1;
2352 }
2353
2354 int MipsAsmParser::matchMSA128RegisterName(StringRef Name) {
2355   unsigned IntVal;
2356
2357   if (Name.front() != 'w' || Name.drop_front(1).getAsInteger(10, IntVal))
2358     return -1;
2359
2360   if (IntVal > 31)
2361     return -1;
2362
2363   return IntVal;
2364 }
2365
2366 int MipsAsmParser::matchMSA128CtrlRegisterName(StringRef Name) {
2367   int CC;
2368
2369   CC = StringSwitch<unsigned>(Name)
2370            .Case("msair", 0)
2371            .Case("msacsr", 1)
2372            .Case("msaaccess", 2)
2373            .Case("msasave", 3)
2374            .Case("msamodify", 4)
2375            .Case("msarequest", 5)
2376            .Case("msamap", 6)
2377            .Case("msaunmap", 7)
2378            .Default(-1);
2379
2380   return CC;
2381 }
2382
2383 unsigned MipsAsmParser::getATReg(SMLoc Loc) {
2384   unsigned ATIndex = AssemblerOptions.back()->getATRegIndex();
2385   if (ATIndex == 0) {
2386     reportParseError(Loc,
2387                      "pseudo-instruction requires $at, which is not available");
2388     return 0;
2389   }
2390   unsigned AT = getReg(
2391       (isGP64bit()) ? Mips::GPR64RegClassID : Mips::GPR32RegClassID, ATIndex);
2392   return AT;
2393 }
2394
2395 unsigned MipsAsmParser::getReg(int RC, int RegNo) {
2396   return *(getContext().getRegisterInfo()->getRegClass(RC).begin() + RegNo);
2397 }
2398
2399 unsigned MipsAsmParser::getGPR(int RegNo) {
2400   return getReg(isGP64bit() ? Mips::GPR64RegClassID : Mips::GPR32RegClassID,
2401                 RegNo);
2402 }
2403
2404 int MipsAsmParser::matchRegisterByNumber(unsigned RegNum, unsigned RegClass) {
2405   if (RegNum >
2406       getContext().getRegisterInfo()->getRegClass(RegClass).getNumRegs() - 1)
2407     return -1;
2408
2409   return getReg(RegClass, RegNum);
2410 }
2411
2412 bool MipsAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
2413   MCAsmParser &Parser = getParser();
2414   DEBUG(dbgs() << "parseOperand\n");
2415
2416   // Check if the current operand has a custom associated parser, if so, try to
2417   // custom parse the operand, or fallback to the general approach.
2418   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
2419   if (ResTy == MatchOperand_Success)
2420     return false;
2421   // If there wasn't a custom match, try the generic matcher below. Otherwise,
2422   // there was a match, but an error occurred, in which case, just return that
2423   // the operand parsing failed.
2424   if (ResTy == MatchOperand_ParseFail)
2425     return true;
2426
2427   DEBUG(dbgs() << ".. Generic Parser\n");
2428
2429   switch (getLexer().getKind()) {
2430   default:
2431     Error(Parser.getTok().getLoc(), "unexpected token in operand");
2432     return true;
2433   case AsmToken::Dollar: {
2434     // Parse the register.
2435     SMLoc S = Parser.getTok().getLoc();
2436
2437     // Almost all registers have been parsed by custom parsers. There is only
2438     // one exception to this. $zero (and it's alias $0) will reach this point
2439     // for div, divu, and similar instructions because it is not an operand
2440     // to the instruction definition but an explicit register. Special case
2441     // this situation for now.
2442     if (parseAnyRegister(Operands) != MatchOperand_NoMatch)
2443       return false;
2444
2445     // Maybe it is a symbol reference.
2446     StringRef Identifier;
2447     if (Parser.parseIdentifier(Identifier))
2448       return true;
2449
2450     SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2451     MCSymbol *Sym = getContext().GetOrCreateSymbol("$" + Identifier);
2452     // Otherwise create a symbol reference.
2453     const MCExpr *Res =
2454         MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_None, getContext());
2455
2456     Operands.push_back(MipsOperand::CreateImm(Res, S, E, *this));
2457     return false;
2458   }
2459   // Else drop to expression parsing.
2460   case AsmToken::LParen:
2461   case AsmToken::Minus:
2462   case AsmToken::Plus:
2463   case AsmToken::Integer:
2464   case AsmToken::Tilde:
2465   case AsmToken::String: {
2466     DEBUG(dbgs() << ".. generic integer\n");
2467     OperandMatchResultTy ResTy = parseImm(Operands);
2468     return ResTy != MatchOperand_Success;
2469   }
2470   case AsmToken::Percent: {
2471     // It is a symbol reference or constant expression.
2472     const MCExpr *IdVal;
2473     SMLoc S = Parser.getTok().getLoc(); // Start location of the operand.
2474     if (parseRelocOperand(IdVal))
2475       return true;
2476
2477     SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2478
2479     Operands.push_back(MipsOperand::CreateImm(IdVal, S, E, *this));
2480     return false;
2481   } // case AsmToken::Percent
2482   } // switch(getLexer().getKind())
2483   return true;
2484 }
2485
2486 const MCExpr *MipsAsmParser::evaluateRelocExpr(const MCExpr *Expr,
2487                                                StringRef RelocStr) {
2488   const MCExpr *Res;
2489   // Check the type of the expression.
2490   if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Expr)) {
2491     // It's a constant, evaluate reloc value.
2492     int16_t Val;
2493     switch (getVariantKind(RelocStr)) {
2494     case MCSymbolRefExpr::VK_Mips_ABS_LO:
2495       // Get the 1st 16-bits.
2496       Val = MCE->getValue() & 0xffff;
2497       break;
2498     case MCSymbolRefExpr::VK_Mips_ABS_HI:
2499       // Get the 2nd 16-bits. Also add 1 if bit 15 is 1, to compensate for low
2500       // 16 bits being negative.
2501       Val = ((MCE->getValue() + 0x8000) >> 16) & 0xffff;
2502       break;
2503     case MCSymbolRefExpr::VK_Mips_HIGHER:
2504       // Get the 3rd 16-bits.
2505       Val = ((MCE->getValue() + 0x80008000LL) >> 32) & 0xffff;
2506       break;
2507     case MCSymbolRefExpr::VK_Mips_HIGHEST:
2508       // Get the 4th 16-bits.
2509       Val = ((MCE->getValue() + 0x800080008000LL) >> 48) & 0xffff;
2510       break;
2511     default:
2512       report_fatal_error("unsupported reloc value");
2513     }
2514     return MCConstantExpr::Create(Val, getContext());
2515   }
2516
2517   if (const MCSymbolRefExpr *MSRE = dyn_cast<MCSymbolRefExpr>(Expr)) {
2518     // It's a symbol, create a symbolic expression from the symbol.
2519     StringRef Symbol = MSRE->getSymbol().getName();
2520     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
2521     Res = MCSymbolRefExpr::Create(Symbol, VK, getContext());
2522     return Res;
2523   }
2524
2525   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
2526     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
2527
2528     // Try to create target expression.
2529     if (MipsMCExpr::isSupportedBinaryExpr(VK, BE))
2530       return MipsMCExpr::Create(VK, Expr, getContext());
2531
2532     const MCExpr *LExp = evaluateRelocExpr(BE->getLHS(), RelocStr);
2533     const MCExpr *RExp = evaluateRelocExpr(BE->getRHS(), RelocStr);
2534     Res = MCBinaryExpr::Create(BE->getOpcode(), LExp, RExp, getContext());
2535     return Res;
2536   }
2537
2538   if (const MCUnaryExpr *UN = dyn_cast<MCUnaryExpr>(Expr)) {
2539     const MCExpr *UnExp = evaluateRelocExpr(UN->getSubExpr(), RelocStr);
2540     Res = MCUnaryExpr::Create(UN->getOpcode(), UnExp, getContext());
2541     return Res;
2542   }
2543   // Just return the original expression.
2544   return Expr;
2545 }
2546
2547 bool MipsAsmParser::isEvaluated(const MCExpr *Expr) {
2548
2549   switch (Expr->getKind()) {
2550   case MCExpr::Constant:
2551     return true;
2552   case MCExpr::SymbolRef:
2553     return (cast<MCSymbolRefExpr>(Expr)->getKind() != MCSymbolRefExpr::VK_None);
2554   case MCExpr::Binary:
2555     if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
2556       if (!isEvaluated(BE->getLHS()))
2557         return false;
2558       return isEvaluated(BE->getRHS());
2559     }
2560   case MCExpr::Unary:
2561     return isEvaluated(cast<MCUnaryExpr>(Expr)->getSubExpr());
2562   case MCExpr::Target:
2563     return true;
2564   }
2565   return false;
2566 }
2567
2568 bool MipsAsmParser::parseRelocOperand(const MCExpr *&Res) {
2569   MCAsmParser &Parser = getParser();
2570   Parser.Lex();                          // Eat the % token.
2571   const AsmToken &Tok = Parser.getTok(); // Get next token, operation.
2572   if (Tok.isNot(AsmToken::Identifier))
2573     return true;
2574
2575   std::string Str = Tok.getIdentifier();
2576
2577   Parser.Lex(); // Eat the identifier.
2578   // Now make an expression from the rest of the operand.
2579   const MCExpr *IdVal;
2580   SMLoc EndLoc;
2581
2582   if (getLexer().getKind() == AsmToken::LParen) {
2583     while (1) {
2584       Parser.Lex(); // Eat the '(' token.
2585       if (getLexer().getKind() == AsmToken::Percent) {
2586         Parser.Lex(); // Eat the % token.
2587         const AsmToken &nextTok = Parser.getTok();
2588         if (nextTok.isNot(AsmToken::Identifier))
2589           return true;
2590         Str += "(%";
2591         Str += nextTok.getIdentifier();
2592         Parser.Lex(); // Eat the identifier.
2593         if (getLexer().getKind() != AsmToken::LParen)
2594           return true;
2595       } else
2596         break;
2597     }
2598     if (getParser().parseParenExpression(IdVal, EndLoc))
2599       return true;
2600
2601     while (getLexer().getKind() == AsmToken::RParen)
2602       Parser.Lex(); // Eat the ')' token.
2603
2604   } else
2605     return true; // Parenthesis must follow the relocation operand.
2606
2607   Res = evaluateRelocExpr(IdVal, Str);
2608   return false;
2609 }
2610
2611 bool MipsAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
2612                                   SMLoc &EndLoc) {
2613   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 1> Operands;
2614   OperandMatchResultTy ResTy = parseAnyRegister(Operands);
2615   if (ResTy == MatchOperand_Success) {
2616     assert(Operands.size() == 1);
2617     MipsOperand &Operand = static_cast<MipsOperand &>(*Operands.front());
2618     StartLoc = Operand.getStartLoc();
2619     EndLoc = Operand.getEndLoc();
2620
2621     // AFAIK, we only support numeric registers and named GPR's in CFI
2622     // directives.
2623     // Don't worry about eating tokens before failing. Using an unrecognised
2624     // register is a parse error.
2625     if (Operand.isGPRAsmReg()) {
2626       // Resolve to GPR32 or GPR64 appropriately.
2627       RegNo = isGP64bit() ? Operand.getGPR64Reg() : Operand.getGPR32Reg();
2628     }
2629
2630     return (RegNo == (unsigned)-1);
2631   }
2632
2633   assert(Operands.size() == 0);
2634   return (RegNo == (unsigned)-1);
2635 }
2636
2637 bool MipsAsmParser::parseMemOffset(const MCExpr *&Res, bool isParenExpr) {
2638   MCAsmParser &Parser = getParser();
2639   SMLoc S;
2640   bool Result = true;
2641
2642   while (getLexer().getKind() == AsmToken::LParen)
2643     Parser.Lex();
2644
2645   switch (getLexer().getKind()) {
2646   default:
2647     return true;
2648   case AsmToken::Identifier:
2649   case AsmToken::LParen:
2650   case AsmToken::Integer:
2651   case AsmToken::Minus:
2652   case AsmToken::Plus:
2653     if (isParenExpr)
2654       Result = getParser().parseParenExpression(Res, S);
2655     else
2656       Result = (getParser().parseExpression(Res));
2657     while (getLexer().getKind() == AsmToken::RParen)
2658       Parser.Lex();
2659     break;
2660   case AsmToken::Percent:
2661     Result = parseRelocOperand(Res);
2662   }
2663   return Result;
2664 }
2665
2666 MipsAsmParser::OperandMatchResultTy
2667 MipsAsmParser::parseMemOperand(OperandVector &Operands) {
2668   MCAsmParser &Parser = getParser();
2669   DEBUG(dbgs() << "parseMemOperand\n");
2670   const MCExpr *IdVal = nullptr;
2671   SMLoc S;
2672   bool isParenExpr = false;
2673   MipsAsmParser::OperandMatchResultTy Res = MatchOperand_NoMatch;
2674   // First operand is the offset.
2675   S = Parser.getTok().getLoc();
2676
2677   if (getLexer().getKind() == AsmToken::LParen) {
2678     Parser.Lex();
2679     isParenExpr = true;
2680   }
2681
2682   if (getLexer().getKind() != AsmToken::Dollar) {
2683     if (parseMemOffset(IdVal, isParenExpr))
2684       return MatchOperand_ParseFail;
2685
2686     const AsmToken &Tok = Parser.getTok(); // Get the next token.
2687     if (Tok.isNot(AsmToken::LParen)) {
2688       MipsOperand &Mnemonic = static_cast<MipsOperand &>(*Operands[0]);
2689       if (Mnemonic.getToken() == "la") {
2690         SMLoc E =
2691             SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2692         Operands.push_back(MipsOperand::CreateImm(IdVal, S, E, *this));
2693         return MatchOperand_Success;
2694       }
2695       if (Tok.is(AsmToken::EndOfStatement)) {
2696         SMLoc E =
2697             SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2698
2699         // Zero register assumed, add a memory operand with ZERO as its base.
2700         // "Base" will be managed by k_Memory.
2701         auto Base = MipsOperand::createGPRReg(0, getContext().getRegisterInfo(),
2702                                               S, E, *this);
2703         Operands.push_back(
2704             MipsOperand::CreateMem(std::move(Base), IdVal, S, E, *this));
2705         return MatchOperand_Success;
2706       }
2707       Error(Parser.getTok().getLoc(), "'(' expected");
2708       return MatchOperand_ParseFail;
2709     }
2710
2711     Parser.Lex(); // Eat the '(' token.
2712   }
2713
2714   Res = parseAnyRegister(Operands);
2715   if (Res != MatchOperand_Success)
2716     return Res;
2717
2718   if (Parser.getTok().isNot(AsmToken::RParen)) {
2719     Error(Parser.getTok().getLoc(), "')' expected");
2720     return MatchOperand_ParseFail;
2721   }
2722
2723   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2724
2725   Parser.Lex(); // Eat the ')' token.
2726
2727   if (!IdVal)
2728     IdVal = MCConstantExpr::Create(0, getContext());
2729
2730   // Replace the register operand with the memory operand.
2731   std::unique_ptr<MipsOperand> op(
2732       static_cast<MipsOperand *>(Operands.back().release()));
2733   // Remove the register from the operands.
2734   // "op" will be managed by k_Memory.
2735   Operands.pop_back();
2736   // Add the memory operand.
2737   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(IdVal)) {
2738     int64_t Imm;
2739     if (IdVal->EvaluateAsAbsolute(Imm))
2740       IdVal = MCConstantExpr::Create(Imm, getContext());
2741     else if (BE->getLHS()->getKind() != MCExpr::SymbolRef)
2742       IdVal = MCBinaryExpr::Create(BE->getOpcode(), BE->getRHS(), BE->getLHS(),
2743                                    getContext());
2744   }
2745
2746   Operands.push_back(MipsOperand::CreateMem(std::move(op), IdVal, S, E, *this));
2747   return MatchOperand_Success;
2748 }
2749
2750 bool MipsAsmParser::searchSymbolAlias(OperandVector &Operands) {
2751   MCAsmParser &Parser = getParser();
2752   MCSymbol *Sym = getContext().LookupSymbol(Parser.getTok().getIdentifier());
2753   if (Sym) {
2754     SMLoc S = Parser.getTok().getLoc();
2755     const MCExpr *Expr;
2756     if (Sym->isVariable())
2757       Expr = Sym->getVariableValue();
2758     else
2759       return false;
2760     if (Expr->getKind() == MCExpr::SymbolRef) {
2761       const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr *>(Expr);
2762       StringRef DefSymbol = Ref->getSymbol().getName();
2763       if (DefSymbol.startswith("$")) {
2764         OperandMatchResultTy ResTy =
2765             matchAnyRegisterNameWithoutDollar(Operands, DefSymbol.substr(1), S);
2766         if (ResTy == MatchOperand_Success) {
2767           Parser.Lex();
2768           return true;
2769         } else if (ResTy == MatchOperand_ParseFail)
2770           llvm_unreachable("Should never ParseFail");
2771         return false;
2772       }
2773     } else if (Expr->getKind() == MCExpr::Constant) {
2774       Parser.Lex();
2775       const MCConstantExpr *Const = static_cast<const MCConstantExpr *>(Expr);
2776       Operands.push_back(
2777           MipsOperand::CreateImm(Const, S, Parser.getTok().getLoc(), *this));
2778       return true;
2779     }
2780   }
2781   return false;
2782 }
2783
2784 MipsAsmParser::OperandMatchResultTy
2785 MipsAsmParser::matchAnyRegisterNameWithoutDollar(OperandVector &Operands,
2786                                                  StringRef Identifier,
2787                                                  SMLoc S) {
2788   int Index = matchCPURegisterName(Identifier);
2789   if (Index != -1) {
2790     Operands.push_back(MipsOperand::createGPRReg(
2791         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2792     return MatchOperand_Success;
2793   }
2794
2795   Index = matchHWRegsRegisterName(Identifier);
2796   if (Index != -1) {
2797     Operands.push_back(MipsOperand::createHWRegsReg(
2798         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2799     return MatchOperand_Success;
2800   }
2801
2802   Index = matchFPURegisterName(Identifier);
2803   if (Index != -1) {
2804     Operands.push_back(MipsOperand::createFGRReg(
2805         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2806     return MatchOperand_Success;
2807   }
2808
2809   Index = matchFCCRegisterName(Identifier);
2810   if (Index != -1) {
2811     Operands.push_back(MipsOperand::createFCCReg(
2812         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2813     return MatchOperand_Success;
2814   }
2815
2816   Index = matchACRegisterName(Identifier);
2817   if (Index != -1) {
2818     Operands.push_back(MipsOperand::createACCReg(
2819         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2820     return MatchOperand_Success;
2821   }
2822
2823   Index = matchMSA128RegisterName(Identifier);
2824   if (Index != -1) {
2825     Operands.push_back(MipsOperand::createMSA128Reg(
2826         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2827     return MatchOperand_Success;
2828   }
2829
2830   Index = matchMSA128CtrlRegisterName(Identifier);
2831   if (Index != -1) {
2832     Operands.push_back(MipsOperand::createMSACtrlReg(
2833         Index, getContext().getRegisterInfo(), S, getLexer().getLoc(), *this));
2834     return MatchOperand_Success;
2835   }
2836
2837   return MatchOperand_NoMatch;
2838 }
2839
2840 MipsAsmParser::OperandMatchResultTy
2841 MipsAsmParser::matchAnyRegisterWithoutDollar(OperandVector &Operands, SMLoc S) {
2842   MCAsmParser &Parser = getParser();
2843   auto Token = Parser.getLexer().peekTok(false);
2844
2845   if (Token.is(AsmToken::Identifier)) {
2846     DEBUG(dbgs() << ".. identifier\n");
2847     StringRef Identifier = Token.getIdentifier();
2848     OperandMatchResultTy ResTy =
2849         matchAnyRegisterNameWithoutDollar(Operands, Identifier, S);
2850     return ResTy;
2851   } else if (Token.is(AsmToken::Integer)) {
2852     DEBUG(dbgs() << ".. integer\n");
2853     Operands.push_back(MipsOperand::createNumericReg(
2854         Token.getIntVal(), getContext().getRegisterInfo(), S, Token.getLoc(),
2855         *this));
2856     return MatchOperand_Success;
2857   }
2858
2859   DEBUG(dbgs() << Parser.getTok().getKind() << "\n");
2860
2861   return MatchOperand_NoMatch;
2862 }
2863
2864 MipsAsmParser::OperandMatchResultTy
2865 MipsAsmParser::parseAnyRegister(OperandVector &Operands) {
2866   MCAsmParser &Parser = getParser();
2867   DEBUG(dbgs() << "parseAnyRegister\n");
2868
2869   auto Token = Parser.getTok();
2870
2871   SMLoc S = Token.getLoc();
2872
2873   if (Token.isNot(AsmToken::Dollar)) {
2874     DEBUG(dbgs() << ".. !$ -> try sym aliasing\n");
2875     if (Token.is(AsmToken::Identifier)) {
2876       if (searchSymbolAlias(Operands))
2877         return MatchOperand_Success;
2878     }
2879     DEBUG(dbgs() << ".. !symalias -> NoMatch\n");
2880     return MatchOperand_NoMatch;
2881   }
2882   DEBUG(dbgs() << ".. $\n");
2883
2884   OperandMatchResultTy ResTy = matchAnyRegisterWithoutDollar(Operands, S);
2885   if (ResTy == MatchOperand_Success) {
2886     Parser.Lex(); // $
2887     Parser.Lex(); // identifier
2888   }
2889   return ResTy;
2890 }
2891
2892 MipsAsmParser::OperandMatchResultTy
2893 MipsAsmParser::parseImm(OperandVector &Operands) {
2894   MCAsmParser &Parser = getParser();
2895   switch (getLexer().getKind()) {
2896   default:
2897     return MatchOperand_NoMatch;
2898   case AsmToken::LParen:
2899   case AsmToken::Minus:
2900   case AsmToken::Plus:
2901   case AsmToken::Integer:
2902   case AsmToken::Tilde:
2903   case AsmToken::String:
2904     break;
2905   }
2906
2907   const MCExpr *IdVal;
2908   SMLoc S = Parser.getTok().getLoc();
2909   if (getParser().parseExpression(IdVal))
2910     return MatchOperand_ParseFail;
2911
2912   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2913   Operands.push_back(MipsOperand::CreateImm(IdVal, S, E, *this));
2914   return MatchOperand_Success;
2915 }
2916
2917 MipsAsmParser::OperandMatchResultTy
2918 MipsAsmParser::parseJumpTarget(OperandVector &Operands) {
2919   MCAsmParser &Parser = getParser();
2920   DEBUG(dbgs() << "parseJumpTarget\n");
2921
2922   SMLoc S = getLexer().getLoc();
2923
2924   // Integers and expressions are acceptable
2925   OperandMatchResultTy ResTy = parseImm(Operands);
2926   if (ResTy != MatchOperand_NoMatch)
2927     return ResTy;
2928
2929   // Registers are a valid target and have priority over symbols.
2930   ResTy = parseAnyRegister(Operands);
2931   if (ResTy != MatchOperand_NoMatch)
2932     return ResTy;
2933
2934   const MCExpr *Expr = nullptr;
2935   if (Parser.parseExpression(Expr)) {
2936     // We have no way of knowing if a symbol was consumed so we must ParseFail
2937     return MatchOperand_ParseFail;
2938   }
2939   Operands.push_back(
2940       MipsOperand::CreateImm(Expr, S, getLexer().getLoc(), *this));
2941   return MatchOperand_Success;
2942 }
2943
2944 MipsAsmParser::OperandMatchResultTy
2945 MipsAsmParser::parseInvNum(OperandVector &Operands) {
2946   MCAsmParser &Parser = getParser();
2947   const MCExpr *IdVal;
2948   // If the first token is '$' we may have register operand.
2949   if (Parser.getTok().is(AsmToken::Dollar))
2950     return MatchOperand_NoMatch;
2951   SMLoc S = Parser.getTok().getLoc();
2952   if (getParser().parseExpression(IdVal))
2953     return MatchOperand_ParseFail;
2954   const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(IdVal);
2955   assert(MCE && "Unexpected MCExpr type.");
2956   int64_t Val = MCE->getValue();
2957   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2958   Operands.push_back(MipsOperand::CreateImm(
2959       MCConstantExpr::Create(0 - Val, getContext()), S, E, *this));
2960   return MatchOperand_Success;
2961 }
2962
2963 MipsAsmParser::OperandMatchResultTy
2964 MipsAsmParser::parseLSAImm(OperandVector &Operands) {
2965   MCAsmParser &Parser = getParser();
2966   switch (getLexer().getKind()) {
2967   default:
2968     return MatchOperand_NoMatch;
2969   case AsmToken::LParen:
2970   case AsmToken::Plus:
2971   case AsmToken::Minus:
2972   case AsmToken::Integer:
2973     break;
2974   }
2975
2976   const MCExpr *Expr;
2977   SMLoc S = Parser.getTok().getLoc();
2978
2979   if (getParser().parseExpression(Expr))
2980     return MatchOperand_ParseFail;
2981
2982   int64_t Val;
2983   if (!Expr->EvaluateAsAbsolute(Val)) {
2984     Error(S, "expected immediate value");
2985     return MatchOperand_ParseFail;
2986   }
2987
2988   // The LSA instruction allows a 2-bit unsigned immediate. For this reason
2989   // and because the CPU always adds one to the immediate field, the allowed
2990   // range becomes 1..4. We'll only check the range here and will deal
2991   // with the addition/subtraction when actually decoding/encoding
2992   // the instruction.
2993   if (Val < 1 || Val > 4) {
2994     Error(S, "immediate not in range (1..4)");
2995     return MatchOperand_ParseFail;
2996   }
2997
2998   Operands.push_back(
2999       MipsOperand::CreateImm(Expr, S, Parser.getTok().getLoc(), *this));
3000   return MatchOperand_Success;
3001 }
3002
3003 MipsAsmParser::OperandMatchResultTy
3004 MipsAsmParser::parseRegisterList(OperandVector &Operands) {
3005   MCAsmParser &Parser = getParser();
3006   SmallVector<unsigned, 10> Regs;
3007   unsigned RegNo;
3008   unsigned PrevReg = Mips::NoRegister;
3009   bool RegRange = false;
3010   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> TmpOperands;
3011
3012   if (Parser.getTok().isNot(AsmToken::Dollar))
3013     return MatchOperand_ParseFail;
3014
3015   SMLoc S = Parser.getTok().getLoc();
3016   while (parseAnyRegister(TmpOperands) == MatchOperand_Success) {
3017     SMLoc E = getLexer().getLoc();
3018     MipsOperand &Reg = static_cast<MipsOperand &>(*TmpOperands.back());
3019     RegNo = isGP64bit() ? Reg.getGPR64Reg() : Reg.getGPR32Reg();
3020     if (RegRange) {
3021       // Remove last register operand because registers from register range
3022       // should be inserted first.
3023       if (RegNo == Mips::RA) {
3024         Regs.push_back(RegNo);
3025       } else {
3026         unsigned TmpReg = PrevReg + 1;
3027         while (TmpReg <= RegNo) {
3028           if ((TmpReg < Mips::S0) || (TmpReg > Mips::S7)) {
3029             Error(E, "invalid register operand");
3030             return MatchOperand_ParseFail;
3031           }
3032
3033           PrevReg = TmpReg;
3034           Regs.push_back(TmpReg++);
3035         }
3036       }
3037
3038       RegRange = false;
3039     } else {
3040       if ((PrevReg == Mips::NoRegister) && (RegNo != Mips::S0) &&
3041           (RegNo != Mips::RA)) {
3042         Error(E, "$16 or $31 expected");
3043         return MatchOperand_ParseFail;
3044       } else if (((RegNo < Mips::S0) || (RegNo > Mips::S7)) &&
3045                  (RegNo != Mips::FP) && (RegNo != Mips::RA)) {
3046         Error(E, "invalid register operand");
3047         return MatchOperand_ParseFail;
3048       } else if ((PrevReg != Mips::NoRegister) && (RegNo != PrevReg + 1) &&
3049                  (RegNo != Mips::FP) && (RegNo != Mips::RA)) {
3050         Error(E, "consecutive register numbers expected");
3051         return MatchOperand_ParseFail;
3052       }
3053
3054       Regs.push_back(RegNo);
3055     }
3056
3057     if (Parser.getTok().is(AsmToken::Minus))
3058       RegRange = true;
3059
3060     if (!Parser.getTok().isNot(AsmToken::Minus) &&
3061         !Parser.getTok().isNot(AsmToken::Comma)) {
3062       Error(E, "',' or '-' expected");
3063       return MatchOperand_ParseFail;
3064     }
3065
3066     Lex(); // Consume comma or minus
3067     if (Parser.getTok().isNot(AsmToken::Dollar))
3068       break;
3069
3070     PrevReg = RegNo;
3071   }
3072
3073   SMLoc E = Parser.getTok().getLoc();
3074   Operands.push_back(MipsOperand::CreateRegList(Regs, S, E, *this));
3075   parseMemOperand(Operands);
3076   return MatchOperand_Success;
3077 }
3078
3079 MipsAsmParser::OperandMatchResultTy
3080 MipsAsmParser::parseRegisterPair(OperandVector &Operands) {
3081   MCAsmParser &Parser = getParser();
3082
3083   SMLoc S = Parser.getTok().getLoc();
3084   if (parseAnyRegister(Operands) != MatchOperand_Success)
3085     return MatchOperand_ParseFail;
3086
3087   SMLoc E = Parser.getTok().getLoc();
3088   MipsOperand &Op = static_cast<MipsOperand &>(*Operands.back());
3089   unsigned Reg = Op.getGPR32Reg();
3090   Operands.pop_back();
3091   Operands.push_back(MipsOperand::CreateRegPair(Reg, S, E, *this));
3092   return MatchOperand_Success;
3093 }
3094
3095 MipsAsmParser::OperandMatchResultTy
3096 MipsAsmParser::parseMovePRegPair(OperandVector &Operands) {
3097   MCAsmParser &Parser = getParser();
3098   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> TmpOperands;
3099   SmallVector<unsigned, 10> Regs;
3100
3101   if (Parser.getTok().isNot(AsmToken::Dollar))
3102     return MatchOperand_ParseFail;
3103
3104   SMLoc S = Parser.getTok().getLoc();
3105
3106   if (parseAnyRegister(TmpOperands) != MatchOperand_Success)
3107     return MatchOperand_ParseFail;
3108
3109   MipsOperand *Reg = &static_cast<MipsOperand &>(*TmpOperands.back());
3110   unsigned RegNo = isGP64bit() ? Reg->getGPR64Reg() : Reg->getGPR32Reg();
3111   Regs.push_back(RegNo);
3112
3113   SMLoc E = Parser.getTok().getLoc();
3114   if (Parser.getTok().isNot(AsmToken::Comma)) {
3115     Error(E, "',' expected");
3116     return MatchOperand_ParseFail;
3117   }
3118
3119   // Remove comma.
3120   Parser.Lex();
3121
3122   if (parseAnyRegister(TmpOperands) != MatchOperand_Success)
3123     return MatchOperand_ParseFail;
3124
3125   Reg = &static_cast<MipsOperand &>(*TmpOperands.back());
3126   RegNo = isGP64bit() ? Reg->getGPR64Reg() : Reg->getGPR32Reg();
3127   Regs.push_back(RegNo);
3128
3129   Operands.push_back(MipsOperand::CreateRegList(Regs, S, E, *this));
3130
3131   return MatchOperand_Success;
3132 }
3133
3134 MCSymbolRefExpr::VariantKind MipsAsmParser::getVariantKind(StringRef Symbol) {
3135
3136   MCSymbolRefExpr::VariantKind VK =
3137       StringSwitch<MCSymbolRefExpr::VariantKind>(Symbol)
3138           .Case("hi", MCSymbolRefExpr::VK_Mips_ABS_HI)
3139           .Case("lo", MCSymbolRefExpr::VK_Mips_ABS_LO)
3140           .Case("gp_rel", MCSymbolRefExpr::VK_Mips_GPREL)
3141           .Case("call16", MCSymbolRefExpr::VK_Mips_GOT_CALL)
3142           .Case("got", MCSymbolRefExpr::VK_Mips_GOT)
3143           .Case("tlsgd", MCSymbolRefExpr::VK_Mips_TLSGD)
3144           .Case("tlsldm", MCSymbolRefExpr::VK_Mips_TLSLDM)
3145           .Case("dtprel_hi", MCSymbolRefExpr::VK_Mips_DTPREL_HI)
3146           .Case("dtprel_lo", MCSymbolRefExpr::VK_Mips_DTPREL_LO)
3147           .Case("gottprel", MCSymbolRefExpr::VK_Mips_GOTTPREL)
3148           .Case("tprel_hi", MCSymbolRefExpr::VK_Mips_TPREL_HI)
3149           .Case("tprel_lo", MCSymbolRefExpr::VK_Mips_TPREL_LO)
3150           .Case("got_disp", MCSymbolRefExpr::VK_Mips_GOT_DISP)
3151           .Case("got_page", MCSymbolRefExpr::VK_Mips_GOT_PAGE)
3152           .Case("got_ofst", MCSymbolRefExpr::VK_Mips_GOT_OFST)
3153           .Case("hi(%neg(%gp_rel", MCSymbolRefExpr::VK_Mips_GPOFF_HI)
3154           .Case("lo(%neg(%gp_rel", MCSymbolRefExpr::VK_Mips_GPOFF_LO)
3155           .Case("got_hi", MCSymbolRefExpr::VK_Mips_GOT_HI16)
3156           .Case("got_lo", MCSymbolRefExpr::VK_Mips_GOT_LO16)
3157           .Case("call_hi", MCSymbolRefExpr::VK_Mips_CALL_HI16)
3158           .Case("call_lo", MCSymbolRefExpr::VK_Mips_CALL_LO16)
3159           .Case("higher", MCSymbolRefExpr::VK_Mips_HIGHER)
3160           .Case("highest", MCSymbolRefExpr::VK_Mips_HIGHEST)
3161           .Case("pcrel_hi", MCSymbolRefExpr::VK_Mips_PCREL_HI16)
3162           .Case("pcrel_lo", MCSymbolRefExpr::VK_Mips_PCREL_LO16)
3163           .Default(MCSymbolRefExpr::VK_None);
3164
3165   assert(VK != MCSymbolRefExpr::VK_None);
3166
3167   return VK;
3168 }
3169
3170 /// Sometimes (i.e. load/stores) the operand may be followed immediately by
3171 /// either this.
3172 /// ::= '(', register, ')'
3173 /// handle it before we iterate so we don't get tripped up by the lack of
3174 /// a comma.
3175 bool MipsAsmParser::parseParenSuffix(StringRef Name, OperandVector &Operands) {
3176   MCAsmParser &Parser = getParser();
3177   if (getLexer().is(AsmToken::LParen)) {
3178     Operands.push_back(
3179         MipsOperand::CreateToken("(", getLexer().getLoc(), *this));
3180     Parser.Lex();
3181     if (parseOperand(Operands, Name)) {
3182       SMLoc Loc = getLexer().getLoc();
3183       Parser.eatToEndOfStatement();
3184       return Error(Loc, "unexpected token in argument list");
3185     }
3186     if (Parser.getTok().isNot(AsmToken::RParen)) {
3187       SMLoc Loc = getLexer().getLoc();
3188       Parser.eatToEndOfStatement();
3189       return Error(Loc, "unexpected token, expected ')'");
3190     }
3191     Operands.push_back(
3192         MipsOperand::CreateToken(")", getLexer().getLoc(), *this));
3193     Parser.Lex();
3194   }
3195   return false;
3196 }
3197
3198 /// Sometimes (i.e. in MSA) the operand may be followed immediately by
3199 /// either one of these.
3200 /// ::= '[', register, ']'
3201 /// ::= '[', integer, ']'
3202 /// handle it before we iterate so we don't get tripped up by the lack of
3203 /// a comma.
3204 bool MipsAsmParser::parseBracketSuffix(StringRef Name,
3205                                        OperandVector &Operands) {
3206   MCAsmParser &Parser = getParser();
3207   if (getLexer().is(AsmToken::LBrac)) {
3208     Operands.push_back(
3209         MipsOperand::CreateToken("[", getLexer().getLoc(), *this));
3210     Parser.Lex();
3211     if (parseOperand(Operands, Name)) {
3212       SMLoc Loc = getLexer().getLoc();
3213       Parser.eatToEndOfStatement();
3214       return Error(Loc, "unexpected token in argument list");
3215     }
3216     if (Parser.getTok().isNot(AsmToken::RBrac)) {
3217       SMLoc Loc = getLexer().getLoc();
3218       Parser.eatToEndOfStatement();
3219       return Error(Loc, "unexpected token, expected ']'");
3220     }
3221     Operands.push_back(
3222         MipsOperand::CreateToken("]", getLexer().getLoc(), *this));
3223     Parser.Lex();
3224   }
3225   return false;
3226 }
3227
3228 bool MipsAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
3229                                      SMLoc NameLoc, OperandVector &Operands) {
3230   MCAsmParser &Parser = getParser();
3231   DEBUG(dbgs() << "ParseInstruction\n");
3232
3233   // We have reached first instruction, module directive are now forbidden.
3234   getTargetStreamer().forbidModuleDirective();
3235
3236   // Check if we have valid mnemonic
3237   if (!mnemonicIsValid(Name, 0)) {
3238     Parser.eatToEndOfStatement();
3239     return Error(NameLoc, "unknown instruction");
3240   }
3241   // First operand in MCInst is instruction mnemonic.
3242   Operands.push_back(MipsOperand::CreateToken(Name, NameLoc, *this));
3243
3244   // Read the remaining operands.
3245   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3246     // Read the first operand.
3247     if (parseOperand(Operands, Name)) {
3248       SMLoc Loc = getLexer().getLoc();
3249       Parser.eatToEndOfStatement();
3250       return Error(Loc, "unexpected token in argument list");
3251     }
3252     if (getLexer().is(AsmToken::LBrac) && parseBracketSuffix(Name, Operands))
3253       return true;
3254     // AFAIK, parenthesis suffixes are never on the first operand
3255
3256     while (getLexer().is(AsmToken::Comma)) {
3257       Parser.Lex(); // Eat the comma.
3258       // Parse and remember the operand.
3259       if (parseOperand(Operands, Name)) {
3260         SMLoc Loc = getLexer().getLoc();
3261         Parser.eatToEndOfStatement();
3262         return Error(Loc, "unexpected token in argument list");
3263       }
3264       // Parse bracket and parenthesis suffixes before we iterate
3265       if (getLexer().is(AsmToken::LBrac)) {
3266         if (parseBracketSuffix(Name, Operands))
3267           return true;
3268       } else if (getLexer().is(AsmToken::LParen) &&
3269                  parseParenSuffix(Name, Operands))
3270         return true;
3271     }
3272   }
3273   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3274     SMLoc Loc = getLexer().getLoc();
3275     Parser.eatToEndOfStatement();
3276     return Error(Loc, "unexpected token in argument list");
3277   }
3278   Parser.Lex(); // Consume the EndOfStatement.
3279   return false;
3280 }
3281
3282 bool MipsAsmParser::reportParseError(Twine ErrorMsg) {
3283   MCAsmParser &Parser = getParser();
3284   SMLoc Loc = getLexer().getLoc();
3285   Parser.eatToEndOfStatement();
3286   return Error(Loc, ErrorMsg);
3287 }
3288
3289 bool MipsAsmParser::reportParseError(SMLoc Loc, Twine ErrorMsg) {
3290   return Error(Loc, ErrorMsg);
3291 }
3292
3293 bool MipsAsmParser::parseSetNoAtDirective() {
3294   MCAsmParser &Parser = getParser();
3295   // Line should look like: ".set noat".
3296
3297   // Set the $at register to $0.
3298   AssemblerOptions.back()->setATRegIndex(0);
3299
3300   Parser.Lex(); // Eat "noat".
3301
3302   // If this is not the end of the statement, report an error.
3303   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3304     reportParseError("unexpected token, expected end of statement");
3305     return false;
3306   }
3307
3308   getTargetStreamer().emitDirectiveSetNoAt();
3309   Parser.Lex(); // Consume the EndOfStatement.
3310   return false;
3311 }
3312
3313 bool MipsAsmParser::parseSetAtDirective() {
3314   // Line can be: ".set at", which sets $at to $1
3315   //          or  ".set at=$reg", which sets $at to $reg.
3316   MCAsmParser &Parser = getParser();
3317   Parser.Lex(); // Eat "at".
3318
3319   if (getLexer().is(AsmToken::EndOfStatement)) {
3320     // No register was specified, so we set $at to $1.
3321     AssemblerOptions.back()->setATRegIndex(1);
3322
3323     getTargetStreamer().emitDirectiveSetAt();
3324     Parser.Lex(); // Consume the EndOfStatement.
3325     return false;
3326   }
3327
3328   if (getLexer().isNot(AsmToken::Equal)) {
3329     reportParseError("unexpected token, expected equals sign");
3330     return false;
3331   }
3332   Parser.Lex(); // Eat "=".
3333
3334   if (getLexer().isNot(AsmToken::Dollar)) {
3335     if (getLexer().is(AsmToken::EndOfStatement)) {
3336       reportParseError("no register specified");
3337       return false;
3338     } else {
3339       reportParseError("unexpected token, expected dollar sign '$'");
3340       return false;
3341     }
3342   }
3343   Parser.Lex(); // Eat "$".
3344
3345   // Find out what "reg" is.
3346   unsigned AtRegNo;
3347   const AsmToken &Reg = Parser.getTok();
3348   if (Reg.is(AsmToken::Identifier)) {
3349     AtRegNo = matchCPURegisterName(Reg.getIdentifier());
3350   } else if (Reg.is(AsmToken::Integer)) {
3351     AtRegNo = Reg.getIntVal();
3352   } else {
3353     reportParseError("unexpected token, expected identifier or integer");
3354     return false;
3355   }
3356
3357   // Check if $reg is a valid register. If it is, set $at to $reg.
3358   if (!AssemblerOptions.back()->setATRegIndex(AtRegNo)) {
3359     reportParseError("invalid register");
3360     return false;
3361   }
3362   Parser.Lex(); // Eat "reg".
3363
3364   // If this is not the end of the statement, report an error.
3365   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3366     reportParseError("unexpected token, expected end of statement");
3367     return false;
3368   }
3369
3370   getTargetStreamer().emitDirectiveSetAtWithArg(AtRegNo);
3371
3372   Parser.Lex(); // Consume the EndOfStatement.
3373   return false;
3374 }
3375
3376 bool MipsAsmParser::parseSetReorderDirective() {
3377   MCAsmParser &Parser = getParser();
3378   Parser.Lex();
3379   // If this is not the end of the statement, report an error.
3380   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3381     reportParseError("unexpected token, expected end of statement");
3382     return false;
3383   }
3384   AssemblerOptions.back()->setReorder();
3385   getTargetStreamer().emitDirectiveSetReorder();
3386   Parser.Lex(); // Consume the EndOfStatement.
3387   return false;
3388 }
3389
3390 bool MipsAsmParser::parseSetNoReorderDirective() {
3391   MCAsmParser &Parser = getParser();
3392   Parser.Lex();
3393   // If this is not the end of the statement, report an error.
3394   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3395     reportParseError("unexpected token, expected end of statement");
3396     return false;
3397   }
3398   AssemblerOptions.back()->setNoReorder();
3399   getTargetStreamer().emitDirectiveSetNoReorder();
3400   Parser.Lex(); // Consume the EndOfStatement.
3401   return false;
3402 }
3403
3404 bool MipsAsmParser::parseSetMacroDirective() {
3405   MCAsmParser &Parser = getParser();
3406   Parser.Lex();
3407   // If this is not the end of the statement, report an error.
3408   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3409     reportParseError("unexpected token, expected end of statement");
3410     return false;
3411   }
3412   AssemblerOptions.back()->setMacro();
3413   Parser.Lex(); // Consume the EndOfStatement.
3414   return false;
3415 }
3416
3417 bool MipsAsmParser::parseSetNoMacroDirective() {
3418   MCAsmParser &Parser = getParser();
3419   Parser.Lex();
3420   // If this is not the end of the statement, report an error.
3421   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3422     reportParseError("unexpected token, expected end of statement");
3423     return false;
3424   }
3425   if (AssemblerOptions.back()->isReorder()) {
3426     reportParseError("`noreorder' must be set before `nomacro'");
3427     return false;
3428   }
3429   AssemblerOptions.back()->setNoMacro();
3430   Parser.Lex(); // Consume the EndOfStatement.
3431   return false;
3432 }
3433
3434 bool MipsAsmParser::parseSetMsaDirective() {
3435   MCAsmParser &Parser = getParser();
3436   Parser.Lex();
3437
3438   // If this is not the end of the statement, report an error.
3439   if (getLexer().isNot(AsmToken::EndOfStatement))
3440     return reportParseError("unexpected token, expected end of statement");
3441
3442   setFeatureBits(Mips::FeatureMSA, "msa");
3443   getTargetStreamer().emitDirectiveSetMsa();
3444   return false;
3445 }
3446
3447 bool MipsAsmParser::parseSetNoMsaDirective() {
3448   MCAsmParser &Parser = getParser();
3449   Parser.Lex();
3450
3451   // If this is not the end of the statement, report an error.
3452   if (getLexer().isNot(AsmToken::EndOfStatement))
3453     return reportParseError("unexpected token, expected end of statement");
3454
3455   clearFeatureBits(Mips::FeatureMSA, "msa");
3456   getTargetStreamer().emitDirectiveSetNoMsa();
3457   return false;
3458 }
3459
3460 bool MipsAsmParser::parseSetNoDspDirective() {
3461   MCAsmParser &Parser = getParser();
3462   Parser.Lex(); // Eat "nodsp".
3463
3464   // If this is not the end of the statement, report an error.
3465   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3466     reportParseError("unexpected token, expected end of statement");
3467     return false;
3468   }
3469
3470   clearFeatureBits(Mips::FeatureDSP, "dsp");
3471   getTargetStreamer().emitDirectiveSetNoDsp();
3472   return false;
3473 }
3474
3475 bool MipsAsmParser::parseSetMips16Directive() {
3476   MCAsmParser &Parser = getParser();
3477   Parser.Lex(); // Eat "mips16".
3478
3479   // If this is not the end of the statement, report an error.
3480   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3481     reportParseError("unexpected token, expected end of statement");
3482     return false;
3483   }
3484
3485   setFeatureBits(Mips::FeatureMips16, "mips16");
3486   getTargetStreamer().emitDirectiveSetMips16();
3487   Parser.Lex(); // Consume the EndOfStatement.
3488   return false;
3489 }
3490
3491 bool MipsAsmParser::parseSetNoMips16Directive() {
3492   MCAsmParser &Parser = getParser();
3493   Parser.Lex(); // Eat "nomips16".
3494
3495   // If this is not the end of the statement, report an error.
3496   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3497     reportParseError("unexpected token, expected end of statement");
3498     return false;
3499   }
3500
3501   clearFeatureBits(Mips::FeatureMips16, "mips16");
3502   getTargetStreamer().emitDirectiveSetNoMips16();
3503   Parser.Lex(); // Consume the EndOfStatement.
3504   return false;
3505 }
3506
3507 bool MipsAsmParser::parseSetFpDirective() {
3508   MCAsmParser &Parser = getParser();
3509   MipsABIFlagsSection::FpABIKind FpAbiVal;
3510   // Line can be: .set fp=32
3511   //              .set fp=xx
3512   //              .set fp=64
3513   Parser.Lex(); // Eat fp token
3514   AsmToken Tok = Parser.getTok();
3515   if (Tok.isNot(AsmToken::Equal)) {
3516     reportParseError("unexpected token, expected equals sign '='");
3517     return false;
3518   }
3519   Parser.Lex(); // Eat '=' token.
3520   Tok = Parser.getTok();
3521
3522   if (!parseFpABIValue(FpAbiVal, ".set"))
3523     return false;
3524
3525   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3526     reportParseError("unexpected token, expected end of statement");
3527     return false;
3528   }
3529   getTargetStreamer().emitDirectiveSetFp(FpAbiVal);
3530   Parser.Lex(); // Consume the EndOfStatement.
3531   return false;
3532 }
3533
3534 bool MipsAsmParser::parseSetPopDirective() {
3535   MCAsmParser &Parser = getParser();
3536   SMLoc Loc = getLexer().getLoc();
3537
3538   Parser.Lex();
3539   if (getLexer().isNot(AsmToken::EndOfStatement))
3540     return reportParseError("unexpected token, expected end of statement");
3541
3542   // Always keep an element on the options "stack" to prevent the user
3543   // from changing the initial options. This is how we remember them.
3544   if (AssemblerOptions.size() == 2)
3545     return reportParseError(Loc, ".set pop with no .set push");
3546
3547   AssemblerOptions.pop_back();
3548   setAvailableFeatures(AssemblerOptions.back()->getFeatures());
3549
3550   getTargetStreamer().emitDirectiveSetPop();
3551   return false;
3552 }
3553
3554 bool MipsAsmParser::parseSetPushDirective() {
3555   MCAsmParser &Parser = getParser();
3556   Parser.Lex();
3557   if (getLexer().isNot(AsmToken::EndOfStatement))
3558     return reportParseError("unexpected token, expected end of statement");
3559
3560   // Create a copy of the current assembler options environment and push it.
3561   AssemblerOptions.push_back(
3562               make_unique<MipsAssemblerOptions>(AssemblerOptions.back().get()));
3563
3564   getTargetStreamer().emitDirectiveSetPush();
3565   return false;
3566 }
3567
3568 bool MipsAsmParser::parseSetAssignment() {
3569   StringRef Name;
3570   const MCExpr *Value;
3571   MCAsmParser &Parser = getParser();
3572
3573   if (Parser.parseIdentifier(Name))
3574     reportParseError("expected identifier after .set");
3575
3576   if (getLexer().isNot(AsmToken::Comma))
3577     return reportParseError("unexpected token, expected comma");
3578   Lex(); // Eat comma
3579
3580   if (Parser.parseExpression(Value))
3581     return reportParseError("expected valid expression after comma");
3582
3583   MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
3584   Sym->setVariableValue(Value);
3585
3586   return false;
3587 }
3588
3589 bool MipsAsmParser::parseSetMips0Directive() {
3590   MCAsmParser &Parser = getParser();
3591   Parser.Lex();
3592   if (getLexer().isNot(AsmToken::EndOfStatement))
3593     return reportParseError("unexpected token, expected end of statement");
3594
3595   // Reset assembler options to their initial values.
3596   setAvailableFeatures(AssemblerOptions.front()->getFeatures());
3597   AssemblerOptions.back()->setFeatures(AssemblerOptions.front()->getFeatures());
3598
3599   getTargetStreamer().emitDirectiveSetMips0();
3600   return false;
3601 }
3602
3603 bool MipsAsmParser::parseSetArchDirective() {
3604   MCAsmParser &Parser = getParser();
3605   Parser.Lex();
3606   if (getLexer().isNot(AsmToken::Equal))
3607     return reportParseError("unexpected token, expected equals sign");
3608
3609   Parser.Lex();
3610   StringRef Arch;
3611   if (Parser.parseIdentifier(Arch))
3612     return reportParseError("expected arch identifier");
3613
3614   StringRef ArchFeatureName =
3615       StringSwitch<StringRef>(Arch)
3616           .Case("mips1", "mips1")
3617           .Case("mips2", "mips2")
3618           .Case("mips3", "mips3")
3619           .Case("mips4", "mips4")
3620           .Case("mips5", "mips5")
3621           .Case("mips32", "mips32")
3622           .Case("mips32r2", "mips32r2")
3623           .Case("mips32r3", "mips32r3")
3624           .Case("mips32r5", "mips32r5")
3625           .Case("mips32r6", "mips32r6")
3626           .Case("mips64", "mips64")
3627           .Case("mips64r2", "mips64r2")
3628           .Case("mips64r3", "mips64r3")
3629           .Case("mips64r5", "mips64r5")
3630           .Case("mips64r6", "mips64r6")
3631           .Case("cnmips", "cnmips")
3632           .Case("r4000", "mips3") // This is an implementation of Mips3.
3633           .Default("");
3634
3635   if (ArchFeatureName.empty())
3636     return reportParseError("unsupported architecture");
3637
3638   selectArch(ArchFeatureName);
3639   getTargetStreamer().emitDirectiveSetArch(Arch);
3640   return false;
3641 }
3642
3643 bool MipsAsmParser::parseSetFeature(uint64_t Feature) {
3644   MCAsmParser &Parser = getParser();
3645   Parser.Lex();
3646   if (getLexer().isNot(AsmToken::EndOfStatement))
3647     return reportParseError("unexpected token, expected end of statement");
3648
3649   switch (Feature) {
3650   default:
3651     llvm_unreachable("Unimplemented feature");
3652   case Mips::FeatureDSP:
3653     setFeatureBits(Mips::FeatureDSP, "dsp");
3654     getTargetStreamer().emitDirectiveSetDsp();
3655     break;
3656   case Mips::FeatureMicroMips:
3657     getTargetStreamer().emitDirectiveSetMicroMips();
3658     break;
3659   case Mips::FeatureMips1:
3660     selectArch("mips1");
3661     getTargetStreamer().emitDirectiveSetMips1();
3662     break;
3663   case Mips::FeatureMips2:
3664     selectArch("mips2");
3665     getTargetStreamer().emitDirectiveSetMips2();
3666     break;
3667   case Mips::FeatureMips3:
3668     selectArch("mips3");
3669     getTargetStreamer().emitDirectiveSetMips3();
3670     break;
3671   case Mips::FeatureMips4:
3672     selectArch("mips4");
3673     getTargetStreamer().emitDirectiveSetMips4();
3674     break;
3675   case Mips::FeatureMips5:
3676     selectArch("mips5");
3677     getTargetStreamer().emitDirectiveSetMips5();
3678     break;
3679   case Mips::FeatureMips32:
3680     selectArch("mips32");
3681     getTargetStreamer().emitDirectiveSetMips32();
3682     break;
3683   case Mips::FeatureMips32r2:
3684     selectArch("mips32r2");
3685     getTargetStreamer().emitDirectiveSetMips32R2();
3686     break;
3687   case Mips::FeatureMips32r3:
3688     selectArch("mips32r3");
3689     getTargetStreamer().emitDirectiveSetMips32R3();
3690     break;
3691   case Mips::FeatureMips32r5:
3692     selectArch("mips32r5");
3693     getTargetStreamer().emitDirectiveSetMips32R5();
3694     break;
3695   case Mips::FeatureMips32r6:
3696     selectArch("mips32r6");
3697     getTargetStreamer().emitDirectiveSetMips32R6();
3698     break;
3699   case Mips::FeatureMips64:
3700     selectArch("mips64");
3701     getTargetStreamer().emitDirectiveSetMips64();
3702     break;
3703   case Mips::FeatureMips64r2:
3704     selectArch("mips64r2");
3705     getTargetStreamer().emitDirectiveSetMips64R2();
3706     break;
3707   case Mips::FeatureMips64r3:
3708     selectArch("mips64r3");
3709     getTargetStreamer().emitDirectiveSetMips64R3();
3710     break;
3711   case Mips::FeatureMips64r5:
3712     selectArch("mips64r5");
3713     getTargetStreamer().emitDirectiveSetMips64R5();
3714     break;
3715   case Mips::FeatureMips64r6:
3716     selectArch("mips64r6");
3717     getTargetStreamer().emitDirectiveSetMips64R6();
3718     break;
3719   }
3720   return false;
3721 }
3722
3723 bool MipsAsmParser::eatComma(StringRef ErrorStr) {
3724   MCAsmParser &Parser = getParser();
3725   if (getLexer().isNot(AsmToken::Comma)) {
3726     SMLoc Loc = getLexer().getLoc();
3727     Parser.eatToEndOfStatement();
3728     return Error(Loc, ErrorStr);
3729   }
3730
3731   Parser.Lex(); // Eat the comma.
3732   return true;
3733 }
3734
3735 bool MipsAsmParser::parseDirectiveCpLoad(SMLoc Loc) {
3736   if (AssemblerOptions.back()->isReorder())
3737     Warning(Loc, ".cpload should be inside a noreorder section");
3738
3739   if (inMips16Mode()) {
3740     reportParseError(".cpload is not supported in Mips16 mode");
3741     return false;
3742   }
3743
3744   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 1> Reg;
3745   OperandMatchResultTy ResTy = parseAnyRegister(Reg);
3746   if (ResTy == MatchOperand_NoMatch || ResTy == MatchOperand_ParseFail) {
3747     reportParseError("expected register containing function address");
3748     return false;
3749   }
3750
3751   MipsOperand &RegOpnd = static_cast<MipsOperand &>(*Reg[0]);
3752   if (!RegOpnd.isGPRAsmReg()) {
3753     reportParseError(RegOpnd.getStartLoc(), "invalid register");
3754     return false;
3755   }
3756
3757   // If this is not the end of the statement, report an error.
3758   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3759     reportParseError("unexpected token, expected end of statement");
3760     return false;
3761   }
3762
3763   getTargetStreamer().emitDirectiveCpLoad(RegOpnd.getGPR32Reg());
3764   return false;
3765 }
3766
3767 bool MipsAsmParser::parseDirectiveCPSetup() {
3768   MCAsmParser &Parser = getParser();
3769   unsigned FuncReg;
3770   unsigned Save;
3771   bool SaveIsReg = true;
3772
3773   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 1> TmpReg;
3774   OperandMatchResultTy ResTy = parseAnyRegister(TmpReg);
3775   if (ResTy == MatchOperand_NoMatch) {
3776     reportParseError("expected register containing function address");
3777     Parser.eatToEndOfStatement();
3778     return false;
3779   }
3780
3781   MipsOperand &FuncRegOpnd = static_cast<MipsOperand &>(*TmpReg[0]);
3782   if (!FuncRegOpnd.isGPRAsmReg()) {
3783     reportParseError(FuncRegOpnd.getStartLoc(), "invalid register");
3784     Parser.eatToEndOfStatement();
3785     return false;
3786   }
3787
3788   FuncReg = FuncRegOpnd.getGPR32Reg();
3789   TmpReg.clear();
3790
3791   if (!eatComma("unexpected token, expected comma"))
3792     return true;
3793
3794   ResTy = parseAnyRegister(TmpReg);
3795   if (ResTy == MatchOperand_NoMatch) {
3796     const AsmToken &Tok = Parser.getTok();
3797     if (Tok.is(AsmToken::Integer)) {
3798       Save = Tok.getIntVal();
3799       SaveIsReg = false;
3800       Parser.Lex();
3801     } else {
3802       reportParseError("expected save register or stack offset");
3803       Parser.eatToEndOfStatement();
3804       return false;
3805     }
3806   } else {
3807     MipsOperand &SaveOpnd = static_cast<MipsOperand &>(*TmpReg[0]);
3808     if (!SaveOpnd.isGPRAsmReg()) {
3809       reportParseError(SaveOpnd.getStartLoc(), "invalid register");
3810       Parser.eatToEndOfStatement();
3811       return false;
3812     }
3813     Save = SaveOpnd.getGPR32Reg();
3814   }
3815
3816   if (!eatComma("unexpected token, expected comma"))
3817     return true;
3818
3819   const MCExpr *Expr;
3820   if (Parser.parseExpression(Expr)) {
3821     reportParseError("expected expression");
3822     return false;
3823   }
3824
3825   if (Expr->getKind() != MCExpr::SymbolRef) {
3826     reportParseError("expected symbol");
3827     return false;
3828   }
3829   const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr *>(Expr);
3830
3831   getTargetStreamer().emitDirectiveCpsetup(FuncReg, Save, Ref->getSymbol(),
3832                                            SaveIsReg);
3833   return false;
3834 }
3835
3836 bool MipsAsmParser::parseDirectiveNaN() {
3837   MCAsmParser &Parser = getParser();
3838   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3839     const AsmToken &Tok = Parser.getTok();
3840
3841     if (Tok.getString() == "2008") {
3842       Parser.Lex();
3843       getTargetStreamer().emitDirectiveNaN2008();
3844       return false;
3845     } else if (Tok.getString() == "legacy") {
3846       Parser.Lex();
3847       getTargetStreamer().emitDirectiveNaNLegacy();
3848       return false;
3849     }
3850   }
3851   // If we don't recognize the option passed to the .nan
3852   // directive (e.g. no option or unknown option), emit an error.
3853   reportParseError("invalid option in .nan directive");
3854   return false;
3855 }
3856
3857 bool MipsAsmParser::parseDirectiveSet() {
3858   MCAsmParser &Parser = getParser();
3859   // Get the next token.
3860   const AsmToken &Tok = Parser.getTok();
3861
3862   if (Tok.getString() == "noat") {
3863     return parseSetNoAtDirective();
3864   } else if (Tok.getString() == "at") {
3865     return parseSetAtDirective();
3866   } else if (Tok.getString() == "arch") {
3867     return parseSetArchDirective();
3868   } else if (Tok.getString() == "fp") {
3869     return parseSetFpDirective();
3870   } else if (Tok.getString() == "pop") {
3871     return parseSetPopDirective();
3872   } else if (Tok.getString() == "push") {
3873     return parseSetPushDirective();
3874   } else if (Tok.getString() == "reorder") {
3875     return parseSetReorderDirective();
3876   } else if (Tok.getString() == "noreorder") {
3877     return parseSetNoReorderDirective();
3878   } else if (Tok.getString() == "macro") {
3879     return parseSetMacroDirective();
3880   } else if (Tok.getString() == "nomacro") {
3881     return parseSetNoMacroDirective();
3882   } else if (Tok.getString() == "mips16") {
3883     return parseSetMips16Directive();
3884   } else if (Tok.getString() == "nomips16") {
3885     return parseSetNoMips16Directive();
3886   } else if (Tok.getString() == "nomicromips") {
3887     getTargetStreamer().emitDirectiveSetNoMicroMips();
3888     Parser.eatToEndOfStatement();
3889     return false;
3890   } else if (Tok.getString() == "micromips") {
3891     return parseSetFeature(Mips::FeatureMicroMips);
3892   } else if (Tok.getString() == "mips0") {
3893     return parseSetMips0Directive();
3894   } else if (Tok.getString() == "mips1") {
3895     return parseSetFeature(Mips::FeatureMips1);
3896   } else if (Tok.getString() == "mips2") {
3897     return parseSetFeature(Mips::FeatureMips2);
3898   } else if (Tok.getString() == "mips3") {
3899     return parseSetFeature(Mips::FeatureMips3);
3900   } else if (Tok.getString() == "mips4") {
3901     return parseSetFeature(Mips::FeatureMips4);
3902   } else if (Tok.getString() == "mips5") {
3903     return parseSetFeature(Mips::FeatureMips5);
3904   } else if (Tok.getString() == "mips32") {
3905     return parseSetFeature(Mips::FeatureMips32);
3906   } else if (Tok.getString() == "mips32r2") {
3907     return parseSetFeature(Mips::FeatureMips32r2);
3908   } else if (Tok.getString() == "mips32r3") {
3909     return parseSetFeature(Mips::FeatureMips32r3);
3910   } else if (Tok.getString() == "mips32r5") {
3911     return parseSetFeature(Mips::FeatureMips32r5);
3912   } else if (Tok.getString() == "mips32r6") {
3913     return parseSetFeature(Mips::FeatureMips32r6);
3914   } else if (Tok.getString() == "mips64") {
3915     return parseSetFeature(Mips::FeatureMips64);
3916   } else if (Tok.getString() == "mips64r2") {
3917     return parseSetFeature(Mips::FeatureMips64r2);
3918   } else if (Tok.getString() == "mips64r3") {
3919     return parseSetFeature(Mips::FeatureMips64r3);
3920   } else if (Tok.getString() == "mips64r5") {
3921     return parseSetFeature(Mips::FeatureMips64r5);
3922   } else if (Tok.getString() == "mips64r6") {
3923     return parseSetFeature(Mips::FeatureMips64r6);
3924   } else if (Tok.getString() == "dsp") {
3925     return parseSetFeature(Mips::FeatureDSP);
3926   } else if (Tok.getString() == "nodsp") {
3927     return parseSetNoDspDirective();
3928   } else if (Tok.getString() == "msa") {
3929     return parseSetMsaDirective();
3930   } else if (Tok.getString() == "nomsa") {
3931     return parseSetNoMsaDirective();
3932   } else {
3933     // It is just an identifier, look for an assignment.
3934     parseSetAssignment();
3935     return false;
3936   }
3937
3938   return true;
3939 }
3940
3941 /// parseDataDirective
3942 ///  ::= .word [ expression (, expression)* ]
3943 bool MipsAsmParser::parseDataDirective(unsigned Size, SMLoc L) {
3944   MCAsmParser &Parser = getParser();
3945   if (getLexer().isNot(AsmToken::EndOfStatement)) {
3946     for (;;) {
3947       const MCExpr *Value;
3948       if (getParser().parseExpression(Value))
3949         return true;
3950
3951       getParser().getStreamer().EmitValue(Value, Size);
3952
3953       if (getLexer().is(AsmToken::EndOfStatement))
3954         break;
3955
3956       if (getLexer().isNot(AsmToken::Comma))
3957         return Error(L, "unexpected token, expected comma");
3958       Parser.Lex();
3959     }
3960   }
3961
3962   Parser.Lex();
3963   return false;
3964 }
3965
3966 /// parseDirectiveGpWord
3967 ///  ::= .gpword local_sym
3968 bool MipsAsmParser::parseDirectiveGpWord() {
3969   MCAsmParser &Parser = getParser();
3970   const MCExpr *Value;
3971   // EmitGPRel32Value requires an expression, so we are using base class
3972   // method to evaluate the expression.
3973   if (getParser().parseExpression(Value))
3974     return true;
3975   getParser().getStreamer().EmitGPRel32Value(Value);
3976
3977   if (getLexer().isNot(AsmToken::EndOfStatement))
3978     return Error(getLexer().getLoc(),
3979                 "unexpected token, expected end of statement");
3980   Parser.Lex(); // Eat EndOfStatement token.
3981   return false;
3982 }
3983
3984 /// parseDirectiveGpDWord
3985 ///  ::= .gpdword local_sym
3986 bool MipsAsmParser::parseDirectiveGpDWord() {
3987   MCAsmParser &Parser = getParser();
3988   const MCExpr *Value;
3989   // EmitGPRel64Value requires an expression, so we are using base class
3990   // method to evaluate the expression.
3991   if (getParser().parseExpression(Value))
3992     return true;
3993   getParser().getStreamer().EmitGPRel64Value(Value);
3994
3995   if (getLexer().isNot(AsmToken::EndOfStatement))
3996     return Error(getLexer().getLoc(),
3997                 "unexpected token, expected end of statement");
3998   Parser.Lex(); // Eat EndOfStatement token.
3999   return false;
4000 }
4001
4002 bool MipsAsmParser::parseDirectiveOption() {
4003   MCAsmParser &Parser = getParser();
4004   // Get the option token.
4005   AsmToken Tok = Parser.getTok();
4006   // At the moment only identifiers are supported.
4007   if (Tok.isNot(AsmToken::Identifier)) {
4008     Error(Parser.getTok().getLoc(), "unexpected token, expected identifier");
4009     Parser.eatToEndOfStatement();
4010     return false;
4011   }
4012
4013   StringRef Option = Tok.getIdentifier();
4014
4015   if (Option == "pic0") {
4016     getTargetStreamer().emitDirectiveOptionPic0();
4017     Parser.Lex();
4018     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
4019       Error(Parser.getTok().getLoc(),
4020             "unexpected token, expected end of statement");
4021       Parser.eatToEndOfStatement();
4022     }
4023     return false;
4024   }
4025
4026   if (Option == "pic2") {
4027     getTargetStreamer().emitDirectiveOptionPic2();
4028     Parser.Lex();
4029     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
4030       Error(Parser.getTok().getLoc(),
4031             "unexpected token, expected end of statement");
4032       Parser.eatToEndOfStatement();
4033     }
4034     return false;
4035   }
4036
4037   // Unknown option.
4038   Warning(Parser.getTok().getLoc(),
4039           "unknown option, expected 'pic0' or 'pic2'");
4040   Parser.eatToEndOfStatement();
4041   return false;
4042 }
4043
4044 /// parseInsnDirective
4045 ///  ::= .insn
4046 bool MipsAsmParser::parseInsnDirective() {
4047   // If this is not the end of the statement, report an error.
4048   if (getLexer().isNot(AsmToken::EndOfStatement)) {
4049     reportParseError("unexpected token, expected end of statement");
4050     return false;
4051   }
4052
4053   // The actual label marking happens in
4054   // MipsELFStreamer::createPendingLabelRelocs().
4055   getTargetStreamer().emitDirectiveInsn();
4056
4057   getParser().Lex(); // Eat EndOfStatement token.
4058   return false;
4059 }
4060
4061 /// parseDirectiveModule
4062 ///  ::= .module oddspreg
4063 ///  ::= .module nooddspreg
4064 ///  ::= .module fp=value
4065 bool MipsAsmParser::parseDirectiveModule() {
4066   MCAsmParser &Parser = getParser();
4067   MCAsmLexer &Lexer = getLexer();
4068   SMLoc L = Lexer.getLoc();
4069
4070   if (!getTargetStreamer().isModuleDirectiveAllowed()) {
4071     // TODO : get a better message.
4072     reportParseError(".module directive must appear before any code");
4073     return false;
4074   }
4075
4076   StringRef Option;
4077   if (Parser.parseIdentifier(Option)) {
4078     reportParseError("expected .module option identifier");
4079     return false;
4080   }
4081
4082   if (Option == "oddspreg") {
4083     getTargetStreamer().emitDirectiveModuleOddSPReg(true, isABI_O32());
4084     clearFeatureBits(Mips::FeatureNoOddSPReg, "nooddspreg");
4085
4086     // If this is not the end of the statement, report an error.
4087     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4088       reportParseError("unexpected token, expected end of statement");
4089       return false;
4090     }
4091
4092     return false; // parseDirectiveModule has finished successfully.
4093   } else if (Option == "nooddspreg") {
4094     if (!isABI_O32()) {
4095       Error(L, "'.module nooddspreg' requires the O32 ABI");
4096       return false;
4097     }
4098
4099     getTargetStreamer().emitDirectiveModuleOddSPReg(false, isABI_O32());
4100     setFeatureBits(Mips::FeatureNoOddSPReg, "nooddspreg");
4101
4102     // If this is not the end of the statement, report an error.
4103     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4104       reportParseError("unexpected token, expected end of statement");
4105       return false;
4106     }
4107
4108     return false; // parseDirectiveModule has finished successfully.
4109   } else if (Option == "fp") {
4110     return parseDirectiveModuleFP();
4111   } else {
4112     return Error(L, "'" + Twine(Option) + "' is not a valid .module option.");
4113   }
4114 }
4115
4116 /// parseDirectiveModuleFP
4117 ///  ::= =32
4118 ///  ::= =xx
4119 ///  ::= =64
4120 bool MipsAsmParser::parseDirectiveModuleFP() {
4121   MCAsmParser &Parser = getParser();
4122   MCAsmLexer &Lexer = getLexer();
4123
4124   if (Lexer.isNot(AsmToken::Equal)) {
4125     reportParseError("unexpected token, expected equals sign '='");
4126     return false;
4127   }
4128   Parser.Lex(); // Eat '=' token.
4129
4130   MipsABIFlagsSection::FpABIKind FpABI;
4131   if (!parseFpABIValue(FpABI, ".module"))
4132     return false;
4133
4134   if (getLexer().isNot(AsmToken::EndOfStatement)) {
4135     reportParseError("unexpected token, expected end of statement");
4136     return false;
4137   }
4138
4139   // Emit appropriate flags.
4140   getTargetStreamer().emitDirectiveModuleFP(FpABI, isABI_O32());
4141   Parser.Lex(); // Consume the EndOfStatement.
4142   return false;
4143 }
4144
4145 bool MipsAsmParser::parseFpABIValue(MipsABIFlagsSection::FpABIKind &FpABI,
4146                                     StringRef Directive) {
4147   MCAsmParser &Parser = getParser();
4148   MCAsmLexer &Lexer = getLexer();
4149
4150   if (Lexer.is(AsmToken::Identifier)) {
4151     StringRef Value = Parser.getTok().getString();
4152     Parser.Lex();
4153
4154     if (Value != "xx") {
4155       reportParseError("unsupported value, expected 'xx', '32' or '64'");
4156       return false;
4157     }
4158
4159     if (!isABI_O32()) {
4160       reportParseError("'" + Directive + " fp=xx' requires the O32 ABI");
4161       return false;
4162     }
4163
4164     FpABI = MipsABIFlagsSection::FpABIKind::XX;
4165     return true;
4166   }
4167
4168   if (Lexer.is(AsmToken::Integer)) {
4169     unsigned Value = Parser.getTok().getIntVal();
4170     Parser.Lex();
4171
4172     if (Value != 32 && Value != 64) {
4173       reportParseError("unsupported value, expected 'xx', '32' or '64'");
4174       return false;
4175     }
4176
4177     if (Value == 32) {
4178       if (!isABI_O32()) {
4179         reportParseError("'" + Directive + " fp=32' requires the O32 ABI");
4180         return false;
4181       }
4182
4183       FpABI = MipsABIFlagsSection::FpABIKind::S32;
4184     } else
4185       FpABI = MipsABIFlagsSection::FpABIKind::S64;
4186
4187     return true;
4188   }
4189
4190   return false;
4191 }
4192
4193 bool MipsAsmParser::ParseDirective(AsmToken DirectiveID) {
4194   MCAsmParser &Parser = getParser();
4195   StringRef IDVal = DirectiveID.getString();
4196
4197   if (IDVal == ".cpload")
4198     return parseDirectiveCpLoad(DirectiveID.getLoc());
4199   if (IDVal == ".dword") {
4200     parseDataDirective(8, DirectiveID.getLoc());
4201     return false;
4202   }
4203   if (IDVal == ".ent") {
4204     StringRef SymbolName;
4205
4206     if (Parser.parseIdentifier(SymbolName)) {
4207       reportParseError("expected identifier after .ent");
4208       return false;
4209     }
4210
4211     // There's an undocumented extension that allows an integer to
4212     // follow the name of the procedure which AFAICS is ignored by GAS.
4213     // Example: .ent foo,2
4214     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4215       if (getLexer().isNot(AsmToken::Comma)) {
4216         // Even though we accept this undocumented extension for compatibility
4217         // reasons, the additional integer argument does not actually change
4218         // the behaviour of the '.ent' directive, so we would like to discourage
4219         // its use. We do this by not referring to the extended version in
4220         // error messages which are not directly related to its use.
4221         reportParseError("unexpected token, expected end of statement");
4222         return false;
4223       }
4224       Parser.Lex(); // Eat the comma.
4225       const MCExpr *DummyNumber;
4226       int64_t DummyNumberVal;
4227       // If the user was explicitly trying to use the extended version,
4228       // we still give helpful extension-related error messages.
4229       if (Parser.parseExpression(DummyNumber)) {
4230         reportParseError("expected number after comma");
4231         return false;
4232       }
4233       if (!DummyNumber->EvaluateAsAbsolute(DummyNumberVal)) {
4234         reportParseError("expected an absolute expression after comma");
4235         return false;
4236       }
4237     }
4238
4239     // If this is not the end of the statement, report an error.
4240     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4241       reportParseError("unexpected token, expected end of statement");
4242       return false;
4243     }
4244
4245     MCSymbol *Sym = getContext().GetOrCreateSymbol(SymbolName);
4246
4247     getTargetStreamer().emitDirectiveEnt(*Sym);
4248     CurrentFn = Sym;
4249     return false;
4250   }
4251
4252   if (IDVal == ".end") {
4253     StringRef SymbolName;
4254
4255     if (Parser.parseIdentifier(SymbolName)) {
4256       reportParseError("expected identifier after .end");
4257       return false;
4258     }
4259
4260     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4261       reportParseError("unexpected token, expected end of statement");
4262       return false;
4263     }
4264
4265     if (CurrentFn == nullptr) {
4266       reportParseError(".end used without .ent");
4267       return false;
4268     }
4269
4270     if ((SymbolName != CurrentFn->getName())) {
4271       reportParseError(".end symbol does not match .ent symbol");
4272       return false;
4273     }
4274
4275     getTargetStreamer().emitDirectiveEnd(SymbolName);
4276     CurrentFn = nullptr;
4277     return false;
4278   }
4279
4280   if (IDVal == ".frame") {
4281     // .frame $stack_reg, frame_size_in_bytes, $return_reg
4282     SmallVector<std::unique_ptr<MCParsedAsmOperand>, 1> TmpReg;
4283     OperandMatchResultTy ResTy = parseAnyRegister(TmpReg);
4284     if (ResTy == MatchOperand_NoMatch || ResTy == MatchOperand_ParseFail) {
4285       reportParseError("expected stack register");
4286       return false;
4287     }
4288
4289     MipsOperand &StackRegOpnd = static_cast<MipsOperand &>(*TmpReg[0]);
4290     if (!StackRegOpnd.isGPRAsmReg()) {
4291       reportParseError(StackRegOpnd.getStartLoc(),
4292                        "expected general purpose register");
4293       return false;
4294     }
4295     unsigned StackReg = StackRegOpnd.getGPR32Reg();
4296
4297     if (Parser.getTok().is(AsmToken::Comma))
4298       Parser.Lex();
4299     else {
4300       reportParseError("unexpected token, expected comma");
4301       return false;
4302     }
4303
4304     // Parse the frame size.
4305     const MCExpr *FrameSize;
4306     int64_t FrameSizeVal;
4307
4308     if (Parser.parseExpression(FrameSize)) {
4309       reportParseError("expected frame size value");
4310       return false;
4311     }
4312
4313     if (!FrameSize->EvaluateAsAbsolute(FrameSizeVal)) {
4314       reportParseError("frame size not an absolute expression");
4315       return false;
4316     }
4317
4318     if (Parser.getTok().is(AsmToken::Comma))
4319       Parser.Lex();
4320     else {
4321       reportParseError("unexpected token, expected comma");
4322       return false;
4323     }
4324
4325     // Parse the return register.
4326     TmpReg.clear();
4327     ResTy = parseAnyRegister(TmpReg);
4328     if (ResTy == MatchOperand_NoMatch || ResTy == MatchOperand_ParseFail) {
4329       reportParseError("expected return register");
4330       return false;
4331     }
4332
4333     MipsOperand &ReturnRegOpnd = static_cast<MipsOperand &>(*TmpReg[0]);
4334     if (!ReturnRegOpnd.isGPRAsmReg()) {
4335       reportParseError(ReturnRegOpnd.getStartLoc(),
4336                        "expected general purpose register");
4337       return false;
4338     }
4339
4340     // If this is not the end of the statement, report an error.
4341     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4342       reportParseError("unexpected token, expected end of statement");
4343       return false;
4344     }
4345
4346     getTargetStreamer().emitFrame(StackReg, FrameSizeVal,
4347                                   ReturnRegOpnd.getGPR32Reg());
4348     return false;
4349   }
4350
4351   if (IDVal == ".set") {
4352     return parseDirectiveSet();
4353   }
4354
4355   if (IDVal == ".mask" || IDVal == ".fmask") {
4356     // .mask bitmask, frame_offset
4357     // bitmask: One bit for each register used.
4358     // frame_offset: Offset from Canonical Frame Address ($sp on entry) where
4359     //               first register is expected to be saved.
4360     // Examples:
4361     //   .mask 0x80000000, -4
4362     //   .fmask 0x80000000, -4
4363     //
4364
4365     // Parse the bitmask
4366     const MCExpr *BitMask;
4367     int64_t BitMaskVal;
4368
4369     if (Parser.parseExpression(BitMask)) {
4370       reportParseError("expected bitmask value");
4371       return false;
4372     }
4373
4374     if (!BitMask->EvaluateAsAbsolute(BitMaskVal)) {
4375       reportParseError("bitmask not an absolute expression");
4376       return false;
4377     }
4378
4379     if (Parser.getTok().is(AsmToken::Comma))
4380       Parser.Lex();
4381     else {
4382       reportParseError("unexpected token, expected comma");
4383       return false;
4384     }
4385
4386     // Parse the frame_offset
4387     const MCExpr *FrameOffset;
4388     int64_t FrameOffsetVal;
4389
4390     if (Parser.parseExpression(FrameOffset)) {
4391       reportParseError("expected frame offset value");
4392       return false;
4393     }
4394
4395     if (!FrameOffset->EvaluateAsAbsolute(FrameOffsetVal)) {
4396       reportParseError("frame offset not an absolute expression");
4397       return false;
4398     }
4399
4400     // If this is not the end of the statement, report an error.
4401     if (getLexer().isNot(AsmToken::EndOfStatement)) {
4402       reportParseError("unexpected token, expected end of statement");
4403       return false;
4404     }
4405
4406     if (IDVal == ".mask")
4407       getTargetStreamer().emitMask(BitMaskVal, FrameOffsetVal);
4408     else
4409       getTargetStreamer().emitFMask(BitMaskVal, FrameOffsetVal);
4410     return false;
4411   }
4412
4413   if (IDVal == ".nan")
4414     return parseDirectiveNaN();
4415
4416   if (IDVal == ".gpword") {
4417     parseDirectiveGpWord();
4418     return false;
4419   }
4420
4421   if (IDVal == ".gpdword") {
4422     parseDirectiveGpDWord();
4423     return false;
4424   }
4425
4426   if (IDVal == ".word") {
4427     parseDataDirective(4, DirectiveID.getLoc());
4428     return false;
4429   }
4430
4431   if (IDVal == ".option")
4432     return parseDirectiveOption();
4433
4434   if (IDVal == ".abicalls") {
4435     getTargetStreamer().emitDirectiveAbiCalls();
4436     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
4437       Error(Parser.getTok().getLoc(),
4438             "unexpected token, expected end of statement");
4439       // Clear line
4440       Parser.eatToEndOfStatement();
4441     }
4442     return false;
4443   }
4444
4445   if (IDVal == ".cpsetup")
4446     return parseDirectiveCPSetup();
4447
4448   if (IDVal == ".module")
4449     return parseDirectiveModule();
4450
4451   if (IDVal == ".llvm_internal_mips_reallow_module_directive")
4452     return parseInternalDirectiveReallowModule();
4453
4454   if (IDVal == ".insn")
4455     return parseInsnDirective();
4456
4457   return true;
4458 }
4459
4460 bool MipsAsmParser::parseInternalDirectiveReallowModule() {
4461   // If this is not the end of the statement, report an error.
4462   if (getLexer().isNot(AsmToken::EndOfStatement)) {
4463     reportParseError("unexpected token, expected end of statement");
4464     return false;
4465   }
4466
4467   getTargetStreamer().reallowModuleDirective();
4468
4469   getParser().Lex(); // Eat EndOfStatement token.
4470   return false;
4471 }
4472
4473 extern "C" void LLVMInitializeMipsAsmParser() {
4474   RegisterMCAsmParser<MipsAsmParser> X(TheMipsTarget);
4475   RegisterMCAsmParser<MipsAsmParser> Y(TheMipselTarget);
4476   RegisterMCAsmParser<MipsAsmParser> A(TheMips64Target);
4477   RegisterMCAsmParser<MipsAsmParser> B(TheMips64elTarget);
4478 }
4479
4480 #define GET_REGISTER_MATCHER
4481 #define GET_MATCHER_IMPLEMENTATION
4482 #include "MipsGenAsmMatcher.inc"