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/MipsMCExpr.h"
  11 #include "MCTargetDesc/MipsMCTargetDesc.h"
  12 #include "MipsRegisterInfo.h"
  13 #include "MipsTargetStreamer.h"
  14 #include "llvm/ADT/APInt.h"
  15 #include "llvm/ADT/StringSwitch.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCExpr.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/MC/MCInstBuilder.h"
  20 #include "llvm/MC/MCParser/MCAsmLexer.h"
  21 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  22 #include "llvm/MC/MCStreamer.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCSymbol.h"
  25 #include "llvm/MC/MCTargetAsmParser.h"
  26 #include "llvm/Support/MathExtras.h"
  27 #include "llvm/Support/TargetRegistry.h"
  28
  29 using namespace llvm;
  30
  31 namespace llvm {
  32 class MCInstrInfo;
  33 }
  34
  35 namespace {
  36 class MipsAssemblerOptions {
  37 public:
  38   MipsAssemblerOptions() : aTReg(1), reorder(true), macro(true) {}
  39
  40   unsigned getATRegNum() { return aTReg; }
  41   bool setATReg(unsigned Reg);
  42
  43   bool isReorder() { return reorder; }
  44   void setReorder() { reorder = true; }
  45   void setNoreorder() { reorder = false; }
  46
  47   bool isMacro() { return macro; }
  48   void setMacro() { macro = true; }
  49   void setNomacro() { macro = false; }
  50
  51 private:
  52   unsigned aTReg;
  53   bool reorder;
  54   bool macro;
  55 };
  56 }
  57
  58 namespace {
  59 class MipsAsmParser : public MCTargetAsmParser {
  60
  61   MipsTargetStreamer &getTargetStreamer() {
  62     MCTargetStreamer &TS = *Parser.getStreamer().getTargetStreamer();
  63     return static_cast<MipsTargetStreamer &>(TS);
  64   }
  65
  66   MCSubtargetInfo &STI;
  67   MCAsmParser &Parser;
  68   MipsAssemblerOptions Options;
  69   bool hasConsumedDollar;
  70
  71 #define GET_ASSEMBLER_HEADER
  72 #include "MipsGenAsmMatcher.inc"
  73
  74   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
  75                                SmallVectorImpl<MCParsedAsmOperand *> &Operands,
  76                                MCStreamer &Out, unsigned &ErrorInfo,
  77                                bool MatchingInlineAsm);
  78
  79   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
  80
  81   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
  82                         SMLoc NameLoc,
  83                         SmallVectorImpl<MCParsedAsmOperand *> &Operands);
  84
  85   bool ParseDirective(AsmToken DirectiveID);
  86
  87   MipsAsmParser::OperandMatchResultTy
  88   parseRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands, int RegKind);
  89
  90   MipsAsmParser::OperandMatchResultTy
  91   parseMSARegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands, int RegKind);
  92
  93   MipsAsmParser::OperandMatchResultTy
  94   parseMSACtrlRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
  95                    int RegKind);
  96
  97   MipsAsmParser::OperandMatchResultTy
  98   parseMemOperand(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
  99
 100   bool parsePtrReg(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
 101                    int RegKind);
 102
 103   MipsAsmParser::OperandMatchResultTy
 104   parsePtrReg(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 105
 106   MipsAsmParser::OperandMatchResultTy
 107   parseGPR32(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 108
 109   MipsAsmParser::OperandMatchResultTy
 110   parseGPR64(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 111
 112   MipsAsmParser::OperandMatchResultTy
 113   parseHWRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 114
 115   MipsAsmParser::OperandMatchResultTy
 116   parseCCRRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 117
 118   MipsAsmParser::OperandMatchResultTy
 119   parseAFGR64Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 120
 121   MipsAsmParser::OperandMatchResultTy
 122   parseFGR64Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 123
 124   MipsAsmParser::OperandMatchResultTy
 125   parseFGR32Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 126
 127   MipsAsmParser::OperandMatchResultTy
 128   parseFGRH32Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 129
 130   MipsAsmParser::OperandMatchResultTy
 131   parseFCCRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 132
 133   MipsAsmParser::OperandMatchResultTy
 134   parseACC64DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 135
 136   MipsAsmParser::OperandMatchResultTy
 137   parseLO32DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 138
 139   MipsAsmParser::OperandMatchResultTy
 140   parseHI32DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 141
 142   MipsAsmParser::OperandMatchResultTy
 143   parseCOP2(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 144
 145   MipsAsmParser::OperandMatchResultTy
 146   parseMSA128BRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 147
 148   MipsAsmParser::OperandMatchResultTy
 149   parseMSA128HRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 150
 151   MipsAsmParser::OperandMatchResultTy
 152   parseMSA128WRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 153
 154   MipsAsmParser::OperandMatchResultTy
 155   parseMSA128DRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 156
 157   MipsAsmParser::OperandMatchResultTy
 158   parseMSA128CtrlRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 159
 160   MipsAsmParser::OperandMatchResultTy
 161   parseInvNum(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 162
 163   MipsAsmParser::OperandMatchResultTy
 164   parseLSAImm(SmallVectorImpl<MCParsedAsmOperand *> &Operands);
 165
 166   bool searchSymbolAlias(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
 167                          unsigned RegKind);
 168
 169   bool ParseOperand(SmallVectorImpl<MCParsedAsmOperand *> &,
 170                     StringRef Mnemonic);
 171
 172   int tryParseRegister(bool is64BitReg);
 173
 174   bool tryParseRegisterOperand(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
 175                                bool is64BitReg);
 176
 177   bool needsExpansion(MCInst &Inst);
 178
 179   void expandInstruction(MCInst &Inst, SMLoc IDLoc,
 180                          SmallVectorImpl<MCInst> &Instructions);
 181   void expandLoadImm(MCInst &Inst, SMLoc IDLoc,
 182                      SmallVectorImpl<MCInst> &Instructions);
 183   void expandLoadAddressImm(MCInst &Inst, SMLoc IDLoc,
 184                             SmallVectorImpl<MCInst> &Instructions);
 185   void expandLoadAddressReg(MCInst &Inst, SMLoc IDLoc,
 186                             SmallVectorImpl<MCInst> &Instructions);
 187   void expandMemInst(MCInst &Inst, SMLoc IDLoc,
 188                      SmallVectorImpl<MCInst> &Instructions, bool isLoad,
 189                      bool isImmOpnd);
 190   bool reportParseError(StringRef ErrorMsg);
 191
 192   bool parseMemOffset(const MCExpr *&Res, bool isParenExpr);
 193   bool parseRelocOperand(const MCExpr *&Res);
 194
 195   const MCExpr *evaluateRelocExpr(const MCExpr *Expr, StringRef RelocStr);
 196
 197   bool isEvaluated(const MCExpr *Expr);
 198   bool parseSetFeature(uint64_t Feature);
 199   bool parseDirectiveCPSetup();
 200   bool parseDirectiveSet();
 201   bool parseDirectiveOption();
 202
 203   bool parseSetAtDirective();
 204   bool parseSetNoAtDirective();
 205   bool parseSetMacroDirective();
 206   bool parseSetNoMacroDirective();
 207   bool parseSetReorderDirective();
 208   bool parseSetNoReorderDirective();
 209   bool parseSetNoMips16Directive();
 210
 211   bool parseSetAssignment();
 212
 213   bool parseDataDirective(unsigned Size, SMLoc L);
 214   bool parseDirectiveGpWord();
 215   bool parseDirectiveGpdWord();
 216
 217   MCSymbolRefExpr::VariantKind getVariantKind(StringRef Symbol);
 218
 219   bool isGP64() const {
 220     return (STI.getFeatureBits() & Mips::FeatureGP64Bit) != 0;
 221   }
 222
 223   bool isFP64() const {
 224     return (STI.getFeatureBits() & Mips::FeatureFP64Bit) != 0;
 225   }
 226
 227   bool isN32() const { return STI.getFeatureBits() & Mips::FeatureN32; }
 228   bool isN64() const { return STI.getFeatureBits() & Mips::FeatureN64; }
 229
 230   bool isMicroMips() const {
 231     return STI.getFeatureBits() & Mips::FeatureMicroMips;
 232   }
 233
 234   bool parseRegister(unsigned &RegNum);
 235
 236   bool eatComma(StringRef ErrorStr);
 237
 238   int matchRegisterName(StringRef Symbol, bool is64BitReg);
 239
 240   int matchCPURegisterName(StringRef Symbol);
 241
 242   int matchRegisterByNumber(unsigned RegNum, unsigned RegClass);
 243
 244   int matchFPURegisterName(StringRef Name);
 245
 246   int matchFCCRegisterName(StringRef Name);
 247
 248   int matchACRegisterName(StringRef Name);
 249
 250   int matchMSA128RegisterName(StringRef Name);
 251
 252   int matchMSA128CtrlRegisterName(StringRef Name);
 253
 254   int regKindToRegClass(int RegKind);
 255
 256   unsigned getReg(int RC, int RegNo);
 257
 258   unsigned getGPR(int RegNo);
 259
 260   int getATReg();
 261
 262   // Warn if RegNo is the current assembler temporary.
 263   void warnIfAssemblerTemporary(int RegNo);
 264
 265   bool processInstruction(MCInst &Inst, SMLoc IDLoc,
 266                           SmallVectorImpl<MCInst> &Instructions);
 267
 268   // Helper function that checks if the value of a vector index is within the
 269   // boundaries of accepted values for each RegisterKind
 270   // Example: INSERT.B $w0[n], $1 => 16 > n >= 0
 271   bool validateMSAIndex(int Val, int RegKind);
 272
 273   void setFeatureBits(unsigned Feature, StringRef FeatureString) {
 274     if (!(STI.getFeatureBits() & Feature)) {
 275       setAvailableFeatures(ComputeAvailableFeatures(
 276                            STI.ToggleFeature(FeatureString)));
 277     }
 278   }
 279
 280   void clearFeatureBits(unsigned Feature, StringRef FeatureString) {
 281     if (STI.getFeatureBits() & Feature) {
 282      setAvailableFeatures(ComputeAvailableFeatures(
 283                            STI.ToggleFeature(FeatureString)));
 284     }
 285   }
 286
 287 public:
 288   MipsAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
 289                 const MCInstrInfo &MII)
 290       : MCTargetAsmParser(), STI(sti), Parser(parser),
 291         hasConsumedDollar(false) {
 292     // Initialize the set of available features.
 293     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 294
 295     // Assert exactly one ABI was chosen.
 296     assert((((STI.getFeatureBits() & Mips::FeatureO32) != 0) +
 297             ((STI.getFeatureBits() & Mips::FeatureEABI) != 0) +
 298             ((STI.getFeatureBits() & Mips::FeatureN32) != 0) +
 299             ((STI.getFeatureBits() & Mips::FeatureN64) != 0)) == 1);
 300   }
 301
 302   MCAsmParser &getParser() const { return Parser; }
 303   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
 304 };
 305 }
 306
 307 namespace {
 308
 309 /// MipsOperand - Instances of this class represent a parsed Mips machine
 310 /// instruction.
 311 class MipsOperand : public MCParsedAsmOperand {
 312
 313 public:
 314   enum RegisterKind {
 315     Kind_None,
 316     Kind_GPR32,
 317     Kind_GPR64,
 318     Kind_HWRegs,
 319     Kind_FGR32Regs,
 320     Kind_FGRH32Regs,
 321     Kind_FGR64Regs,
 322     Kind_AFGR64Regs,
 323     Kind_CCRRegs,
 324     Kind_FCCRegs,
 325     Kind_ACC64DSP,
 326     Kind_LO32DSP,
 327     Kind_HI32DSP,
 328     Kind_COP2,
 329     Kind_MSA128BRegs,
 330     Kind_MSA128HRegs,
 331     Kind_MSA128WRegs,
 332     Kind_MSA128DRegs,
 333     Kind_MSA128CtrlRegs
 334   };
 335
 336 private:
 337   enum KindTy {
 338     k_CondCode,
 339     k_CoprocNum,
 340     k_Immediate,
 341     k_Memory,
 342     k_PostIndexRegister,
 343     k_Register,
 344     k_PtrReg,
 345     k_Token,
 346     k_LSAImm
 347   } Kind;
 348
 349   MipsOperand(KindTy K) : MCParsedAsmOperand(), Kind(K) {}
 350
 351   struct Token {
 352     const char *Data;
 353     unsigned Length;
 354   };
 355
 356   struct RegOp {
 357     unsigned RegNum;
 358     RegisterKind Kind;
 359   };
 360
 361   struct ImmOp {
 362     const MCExpr *Val;
 363   };
 364
 365   struct MemOp {
 366     unsigned Base;
 367     const MCExpr *Off;
 368   };
 369
 370   union {
 371     struct Token Tok;
 372     struct RegOp Reg;
 373     struct ImmOp Imm;
 374     struct MemOp Mem;
 375   };
 376
 377   SMLoc StartLoc, EndLoc;
 378
 379 public:
 380   void addRegOperands(MCInst &Inst, unsigned N) const {
 381     assert(N == 1 && "Invalid number of operands!");
 382     Inst.addOperand(MCOperand::CreateReg(getReg()));
 383   }
 384
 385   void addPtrRegOperands(MCInst &Inst, unsigned N) const {
 386     assert(N == 1 && "Invalid number of operands!");
 387     Inst.addOperand(MCOperand::CreateReg(getPtrReg()));
 388   }
 389
 390   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
 391     // Add as immediate when possible.  Null MCExpr = 0.
 392     if (Expr == 0)
 393       Inst.addOperand(MCOperand::CreateImm(0));
 394     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
 395       Inst.addOperand(MCOperand::CreateImm(CE->getValue()));
 396     else
 397       Inst.addOperand(MCOperand::CreateExpr(Expr));
 398   }
 399
 400   void addImmOperands(MCInst &Inst, unsigned N) const {
 401     assert(N == 1 && "Invalid number of operands!");
 402     const MCExpr *Expr = getImm();
 403     addExpr(Inst, Expr);
 404   }
 405
 406   void addMemOperands(MCInst &Inst, unsigned N) const {
 407     assert(N == 2 && "Invalid number of operands!");
 408
 409     Inst.addOperand(MCOperand::CreateReg(getMemBase()));
 410
 411     const MCExpr *Expr = getMemOff();
 412     addExpr(Inst, Expr);
 413   }
 414
 415   bool isReg() const { return Kind == k_Register; }
 416   bool isImm() const { return Kind == k_Immediate; }
 417   bool isToken() const { return Kind == k_Token; }
 418   bool isMem() const { return Kind == k_Memory; }
 419   bool isPtrReg() const { return Kind == k_PtrReg; }
 420   bool isInvNum() const { return Kind == k_Immediate; }
 421   bool isLSAImm() const { return Kind == k_LSAImm; }
 422
 423   StringRef getToken() const {
 424     assert(Kind == k_Token && "Invalid access!");
 425     return StringRef(Tok.Data, Tok.Length);
 426   }
 427
 428   unsigned getReg() const {
 429     assert((Kind == k_Register) && "Invalid access!");
 430     return Reg.RegNum;
 431   }
 432
 433   unsigned getPtrReg() const {
 434     assert((Kind == k_PtrReg) && "Invalid access!");
 435     return Reg.RegNum;
 436   }
 437
 438   void setRegKind(RegisterKind RegKind) {
 439     assert((Kind == k_Register || Kind == k_PtrReg) && "Invalid access!");
 440     Reg.Kind = RegKind;
 441   }
 442
 443   const MCExpr *getImm() const {
 444     assert((Kind == k_Immediate || Kind == k_LSAImm) && "Invalid access!");
 445     return Imm.Val;
 446   }
 447
 448   unsigned getMemBase() const {
 449     assert((Kind == k_Memory) && "Invalid access!");
 450     return Mem.Base;
 451   }
 452
 453   const MCExpr *getMemOff() const {
 454     assert((Kind == k_Memory) && "Invalid access!");
 455     return Mem.Off;
 456   }
 457
 458   static MipsOperand *CreateToken(StringRef Str, SMLoc S) {
 459     MipsOperand *Op = new MipsOperand(k_Token);
 460     Op->Tok.Data = Str.data();
 461     Op->Tok.Length = Str.size();
 462     Op->StartLoc = S;
 463     Op->EndLoc = S;
 464     return Op;
 465   }
 466
 467   static MipsOperand *CreateReg(unsigned RegNum, SMLoc S, SMLoc E) {
 468     MipsOperand *Op = new MipsOperand(k_Register);
 469     Op->Reg.RegNum = RegNum;
 470     Op->StartLoc = S;
 471     Op->EndLoc = E;
 472     return Op;
 473   }
 474
 475   static MipsOperand *CreatePtrReg(unsigned RegNum, SMLoc S, SMLoc E) {
 476     MipsOperand *Op = new MipsOperand(k_PtrReg);
 477     Op->Reg.RegNum = RegNum;
 478     Op->StartLoc = S;
 479     Op->EndLoc = E;
 480     return Op;
 481   }
 482
 483   static MipsOperand *CreateImm(const MCExpr *Val, SMLoc S, SMLoc E) {
 484     MipsOperand *Op = new MipsOperand(k_Immediate);
 485     Op->Imm.Val = Val;
 486     Op->StartLoc = S;
 487     Op->EndLoc = E;
 488     return Op;
 489   }
 490
 491   static MipsOperand *CreateLSAImm(const MCExpr *Val, SMLoc S, SMLoc E) {
 492     MipsOperand *Op = new MipsOperand(k_LSAImm);
 493     Op->Imm.Val = Val;
 494     Op->StartLoc = S;
 495     Op->EndLoc = E;
 496     return Op;
 497   }
 498
 499   static MipsOperand *CreateMem(unsigned Base, const MCExpr *Off, SMLoc S,
 500                                 SMLoc E) {
 501     MipsOperand *Op = new MipsOperand(k_Memory);
 502     Op->Mem.Base = Base;
 503     Op->Mem.Off = Off;
 504     Op->StartLoc = S;
 505     Op->EndLoc = E;
 506     return Op;
 507   }
 508
 509   bool isGPR32Asm() const {
 510     return Kind == k_Register && Reg.Kind == Kind_GPR32;
 511   }
 512   void addRegAsmOperands(MCInst &Inst, unsigned N) const {
 513     Inst.addOperand(MCOperand::CreateReg(Reg.RegNum));
 514   }
 515
 516   bool isGPR64Asm() const {
 517     return Kind == k_Register && Reg.Kind == Kind_GPR64;
 518   }
 519
 520   bool isHWRegsAsm() const {
 521     assert((Kind == k_Register) && "Invalid access!");
 522     return Reg.Kind == Kind_HWRegs;
 523   }
 524
 525   bool isCCRAsm() const {
 526     assert((Kind == k_Register) && "Invalid access!");
 527     return Reg.Kind == Kind_CCRRegs;
 528   }
 529
 530   bool isAFGR64Asm() const {
 531     return Kind == k_Register && Reg.Kind == Kind_AFGR64Regs;
 532   }
 533
 534   bool isFGR64Asm() const {
 535     return Kind == k_Register && Reg.Kind == Kind_FGR64Regs;
 536   }
 537
 538   bool isFGR32Asm() const {
 539     return (Kind == k_Register) && Reg.Kind == Kind_FGR32Regs;
 540   }
 541
 542   bool isFGRH32Asm() const {
 543     return (Kind == k_Register) && Reg.Kind == Kind_FGRH32Regs;
 544   }
 545
 546   bool isFCCRegsAsm() const {
 547     return (Kind == k_Register) && Reg.Kind == Kind_FCCRegs;
 548   }
 549
 550   bool isACC64DSPAsm() const {
 551     return Kind == k_Register && Reg.Kind == Kind_ACC64DSP;
 552   }
 553
 554   bool isLO32DSPAsm() const {
 555     return Kind == k_Register && Reg.Kind == Kind_LO32DSP;
 556   }
 557
 558   bool isHI32DSPAsm() const {
 559     return Kind == k_Register && Reg.Kind == Kind_HI32DSP;
 560   }
 561
 562   bool isCOP2Asm() const { return Kind == k_Register && Reg.Kind == Kind_COP2; }
 563
 564   bool isMSA128BAsm() const {
 565     return Kind == k_Register && Reg.Kind == Kind_MSA128BRegs;
 566   }
 567
 568   bool isMSA128HAsm() const {
 569     return Kind == k_Register && Reg.Kind == Kind_MSA128HRegs;
 570   }
 571
 572   bool isMSA128WAsm() const {
 573     return Kind == k_Register && Reg.Kind == Kind_MSA128WRegs;
 574   }
 575
 576   bool isMSA128DAsm() const {
 577     return Kind == k_Register && Reg.Kind == Kind_MSA128DRegs;
 578   }
 579
 580   bool isMSA128CRAsm() const {
 581     return Kind == k_Register && Reg.Kind == Kind_MSA128CtrlRegs;
 582   }
 583
 584   /// getStartLoc - Get the location of the first token of this operand.
 585   SMLoc getStartLoc() const { return StartLoc; }
 586   /// getEndLoc - Get the location of the last token of this operand.
 587   SMLoc getEndLoc() const { return EndLoc; }
 588
 589   virtual void print(raw_ostream &OS) const {
 590     llvm_unreachable("unimplemented!");
 591   }
 592 }; // class MipsOperand
 593 } // namespace
 594
 595 namespace llvm {
 596 extern const MCInstrDesc MipsInsts[];
 597 }
 598 static const MCInstrDesc &getInstDesc(unsigned Opcode) {
 599   return MipsInsts[Opcode];
 600 }
 601
 602 bool MipsAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
 603                                        SmallVectorImpl<MCInst> &Instructions) {
 604   const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
 605
 606   Inst.setLoc(IDLoc);
 607
 608   if (MCID.isBranch() || MCID.isCall()) {
 609     const unsigned Opcode = Inst.getOpcode();
 610     MCOperand Offset;
 611
 612     switch (Opcode) {
 613     default:
 614       break;
 615     case Mips::BEQ:
 616     case Mips::BNE:
 617       assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
 618       Offset = Inst.getOperand(2);
 619       if (!Offset.isImm())
 620         break; // We'll deal with this situation later on when applying fixups.
 621       if (!isIntN(isMicroMips() ? 17 : 18, Offset.getImm()))
 622         return Error(IDLoc, "branch target out of range");
 623       if (OffsetToAlignment(Offset.getImm(), 1LL << (isMicroMips() ? 1 : 2)))
 624         return Error(IDLoc, "branch to misaligned address");
 625       break;
 626     case Mips::BGEZ:
 627     case Mips::BGTZ:
 628     case Mips::BLEZ:
 629     case Mips::BLTZ:
 630     case Mips::BGEZAL:
 631     case Mips::BLTZAL:
 632     case Mips::BC1F:
 633     case Mips::BC1T:
 634       assert(MCID.getNumOperands() == 2 && "unexpected number of operands");
 635       Offset = Inst.getOperand(1);
 636       if (!Offset.isImm())
 637         break; // We'll deal with this situation later on when applying fixups.
 638       if (!isIntN(isMicroMips() ? 17 : 18, Offset.getImm()))
 639         return Error(IDLoc, "branch target out of range");
 640       if (OffsetToAlignment(Offset.getImm(), 1LL << (isMicroMips() ? 1 : 2)))
 641         return Error(IDLoc, "branch to misaligned address");
 642       break;
 643     }
 644   }
 645
 646   if (MCID.hasDelaySlot() && Options.isReorder()) {
 647     // If this instruction has a delay slot and .set reorder is active,
 648     // emit a NOP after it.
 649     Instructions.push_back(Inst);
 650     MCInst NopInst;
 651     NopInst.setOpcode(Mips::SLL);
 652     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
 653     NopInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
 654     NopInst.addOperand(MCOperand::CreateImm(0));
 655     Instructions.push_back(NopInst);
 656     return false;
 657   }
 658
 659   if (MCID.mayLoad() || MCID.mayStore()) {
 660     // Check the offset of memory operand, if it is a symbol
 661     // reference or immediate we may have to expand instructions.
 662     for (unsigned i = 0; i < MCID.getNumOperands(); i++) {
 663       const MCOperandInfo &OpInfo = MCID.OpInfo[i];
 664       if ((OpInfo.OperandType == MCOI::OPERAND_MEMORY) ||
 665           (OpInfo.OperandType == MCOI::OPERAND_UNKNOWN)) {
 666         MCOperand &Op = Inst.getOperand(i);
 667         if (Op.isImm()) {
 668           int MemOffset = Op.getImm();
 669           if (MemOffset < -32768 || MemOffset > 32767) {
 670             // Offset can't exceed 16bit value.
 671             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), true);
 672             return false;
 673           }
 674         } else if (Op.isExpr()) {
 675           const MCExpr *Expr = Op.getExpr();
 676           if (Expr->getKind() == MCExpr::SymbolRef) {
 677             const MCSymbolRefExpr *SR =
 678                 static_cast<const MCSymbolRefExpr *>(Expr);
 679             if (SR->getKind() == MCSymbolRefExpr::VK_None) {
 680               // Expand symbol.
 681               expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
 682               return false;
 683             }
 684           } else if (!isEvaluated(Expr)) {
 685             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
 686             return false;
 687           }
 688         }
 689       }
 690     } // for
 691   }   // if load/store
 692
 693   if (needsExpansion(Inst))
 694     expandInstruction(Inst, IDLoc, Instructions);
 695   else
 696     Instructions.push_back(Inst);
 697
 698   return false;
 699 }
 700
 701 bool MipsAsmParser::needsExpansion(MCInst &Inst) {
 702
 703   switch (Inst.getOpcode()) {
 704   case Mips::LoadImm32Reg:
 705   case Mips::LoadAddr32Imm:
 706   case Mips::LoadAddr32Reg:
 707   case Mips::SUBi:
 708   case Mips::SUBiu:
 709   case Mips::DSUBi:
 710   case Mips::DSUBiu:
 711     return true;
 712   default:
 713     return false;
 714   }
 715 }
 716
 717 void MipsAsmParser::expandInstruction(MCInst &Inst, SMLoc IDLoc,
 718                                       SmallVectorImpl<MCInst> &Instructions) {
 719   switch (Inst.getOpcode()) {
 720   case Mips::LoadImm32Reg:
 721     return expandLoadImm(Inst, IDLoc, Instructions);
 722   case Mips::LoadAddr32Imm:
 723     return expandLoadAddressImm(Inst, IDLoc, Instructions);
 724   case Mips::LoadAddr32Reg:
 725     return expandLoadAddressReg(Inst, IDLoc, Instructions);
 726   case Mips::SUBi:
 727     Instructions.push_back(MCInstBuilder(Mips::ADDi)
 728                                .addReg(Inst.getOperand(0).getReg())
 729                                .addReg(Inst.getOperand(1).getReg())
 730                                .addImm(-Inst.getOperand(2).getImm()));
 731     return;
 732   case Mips::SUBiu:
 733     Instructions.push_back(MCInstBuilder(Mips::ADDiu)
 734                                .addReg(Inst.getOperand(0).getReg())
 735                                .addReg(Inst.getOperand(1).getReg())
 736                                .addImm(-Inst.getOperand(2).getImm()));
 737     return;
 738   case Mips::DSUBi:
 739     Instructions.push_back(MCInstBuilder(Mips::DADDi)
 740                                .addReg(Inst.getOperand(0).getReg())
 741                                .addReg(Inst.getOperand(1).getReg())
 742                                .addImm(-Inst.getOperand(2).getImm()));
 743     return;
 744   case Mips::DSUBiu:
 745     Instructions.push_back(MCInstBuilder(Mips::DADDiu)
 746                                .addReg(Inst.getOperand(0).getReg())
 747                                .addReg(Inst.getOperand(1).getReg())
 748                                .addImm(-Inst.getOperand(2).getImm()));
 749     return;
 750   }
 751 }
 752
 753 void MipsAsmParser::expandLoadImm(MCInst &Inst, SMLoc IDLoc,
 754                                   SmallVectorImpl<MCInst> &Instructions) {
 755   MCInst tmpInst;
 756   const MCOperand &ImmOp = Inst.getOperand(1);
 757   assert(ImmOp.isImm() && "expected immediate operand kind");
 758   const MCOperand &RegOp = Inst.getOperand(0);
 759   assert(RegOp.isReg() && "expected register operand kind");
 760
 761   int ImmValue = ImmOp.getImm();
 762   tmpInst.setLoc(IDLoc);
 763   if (0 <= ImmValue && ImmValue <= 65535) {
 764     // For 0 <= j <= 65535.
 765     // li d,j => ori d,$zero,j
 766     tmpInst.setOpcode(Mips::ORi);
 767     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 768     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
 769     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
 770     Instructions.push_back(tmpInst);
 771   } else if (ImmValue < 0 && ImmValue >= -32768) {
 772     // For -32768 <= j < 0.
 773     // li d,j => addiu d,$zero,j
 774     tmpInst.setOpcode(Mips::ADDiu);
 775     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 776     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
 777     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
 778     Instructions.push_back(tmpInst);
 779   } else {
 780     // For any other value of j that is representable as a 32-bit integer.
 781     // li d,j => lui d,hi16(j)
 782     //           ori d,d,lo16(j)
 783     tmpInst.setOpcode(Mips::LUi);
 784     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 785     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
 786     Instructions.push_back(tmpInst);
 787     tmpInst.clear();
 788     tmpInst.setOpcode(Mips::ORi);
 789     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 790     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 791     tmpInst.addOperand(MCOperand::CreateImm(ImmValue & 0xffff));
 792     tmpInst.setLoc(IDLoc);
 793     Instructions.push_back(tmpInst);
 794   }
 795 }
 796
 797 void
 798 MipsAsmParser::expandLoadAddressReg(MCInst &Inst, SMLoc IDLoc,
 799                                     SmallVectorImpl<MCInst> &Instructions) {
 800   MCInst tmpInst;
 801   const MCOperand &ImmOp = Inst.getOperand(2);
 802   assert(ImmOp.isImm() && "expected immediate operand kind");
 803   const MCOperand &SrcRegOp = Inst.getOperand(1);
 804   assert(SrcRegOp.isReg() && "expected register operand kind");
 805   const MCOperand &DstRegOp = Inst.getOperand(0);
 806   assert(DstRegOp.isReg() && "expected register operand kind");
 807   int ImmValue = ImmOp.getImm();
 808   if (-32768 <= ImmValue && ImmValue <= 65535) {
 809     // For -32768 <= j <= 65535.
 810     // la d,j(s) => addiu d,s,j
 811     tmpInst.setOpcode(Mips::ADDiu);
 812     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 813     tmpInst.addOperand(MCOperand::CreateReg(SrcRegOp.getReg()));
 814     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
 815     Instructions.push_back(tmpInst);
 816   } else {
 817     // For any other value of j that is representable as a 32-bit integer.
 818     // la d,j(s) => lui d,hi16(j)
 819     //              ori d,d,lo16(j)
 820     //              addu d,d,s
 821     tmpInst.setOpcode(Mips::LUi);
 822     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 823     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
 824     Instructions.push_back(tmpInst);
 825     tmpInst.clear();
 826     tmpInst.setOpcode(Mips::ORi);
 827     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 828     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 829     tmpInst.addOperand(MCOperand::CreateImm(ImmValue & 0xffff));
 830     Instructions.push_back(tmpInst);
 831     tmpInst.clear();
 832     tmpInst.setOpcode(Mips::ADDu);
 833     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 834     tmpInst.addOperand(MCOperand::CreateReg(DstRegOp.getReg()));
 835     tmpInst.addOperand(MCOperand::CreateReg(SrcRegOp.getReg()));
 836     Instructions.push_back(tmpInst);
 837   }
 838 }
 839
 840 void
 841 MipsAsmParser::expandLoadAddressImm(MCInst &Inst, SMLoc IDLoc,
 842                                     SmallVectorImpl<MCInst> &Instructions) {
 843   MCInst tmpInst;
 844   const MCOperand &ImmOp = Inst.getOperand(1);
 845   assert(ImmOp.isImm() && "expected immediate operand kind");
 846   const MCOperand &RegOp = Inst.getOperand(0);
 847   assert(RegOp.isReg() && "expected register operand kind");
 848   int ImmValue = ImmOp.getImm();
 849   if (-32768 <= ImmValue && ImmValue <= 65535) {
 850     // For -32768 <= j <= 65535.
 851     // la d,j => addiu d,$zero,j
 852     tmpInst.setOpcode(Mips::ADDiu);
 853     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 854     tmpInst.addOperand(MCOperand::CreateReg(Mips::ZERO));
 855     tmpInst.addOperand(MCOperand::CreateImm(ImmValue));
 856     Instructions.push_back(tmpInst);
 857   } else {
 858     // For any other value of j that is representable as a 32-bit integer.
 859     // la d,j => lui d,hi16(j)
 860     //           ori d,d,lo16(j)
 861     tmpInst.setOpcode(Mips::LUi);
 862     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 863     tmpInst.addOperand(MCOperand::CreateImm((ImmValue & 0xffff0000) >> 16));
 864     Instructions.push_back(tmpInst);
 865     tmpInst.clear();
 866     tmpInst.setOpcode(Mips::ORi);
 867     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 868     tmpInst.addOperand(MCOperand::CreateReg(RegOp.getReg()));
 869     tmpInst.addOperand(MCOperand::CreateImm(ImmValue & 0xffff));
 870     Instructions.push_back(tmpInst);
 871   }
 872 }
 873
 874 void MipsAsmParser::expandMemInst(MCInst &Inst, SMLoc IDLoc,
 875                                   SmallVectorImpl<MCInst> &Instructions,
 876                                   bool isLoad, bool isImmOpnd) {
 877   const MCSymbolRefExpr *SR;
 878   MCInst TempInst;
 879   unsigned ImmOffset, HiOffset, LoOffset;
 880   const MCExpr *ExprOffset;
 881   unsigned TmpRegNum;
 882   unsigned AtRegNum = getReg(
 883       (isGP64()) ? Mips::GPR64RegClassID : Mips::GPR32RegClassID, getATReg());
 884   // 1st operand is either the source or destination register.
 885   assert(Inst.getOperand(0).isReg() && "expected register operand kind");
 886   unsigned RegOpNum = Inst.getOperand(0).getReg();
 887   // 2nd operand is the base register.
 888   assert(Inst.getOperand(1).isReg() && "expected register operand kind");
 889   unsigned BaseRegNum = Inst.getOperand(1).getReg();
 890   // 3rd operand is either an immediate or expression.
 891   if (isImmOpnd) {
 892     assert(Inst.getOperand(2).isImm() && "expected immediate operand kind");
 893     ImmOffset = Inst.getOperand(2).getImm();
 894     LoOffset = ImmOffset & 0x0000ffff;
 895     HiOffset = (ImmOffset & 0xffff0000) >> 16;
 896     // If msb of LoOffset is 1(negative number) we must increment HiOffset.
 897     if (LoOffset & 0x8000)
 898       HiOffset++;
 899   } else
 900     ExprOffset = Inst.getOperand(2).getExpr();
 901   // All instructions will have the same location.
 902   TempInst.setLoc(IDLoc);
 903   // 1st instruction in expansion is LUi. For load instruction we can use
 904   // the dst register as a temporary if base and dst are different,
 905   // but for stores we must use $at.
 906   TmpRegNum = (isLoad && (BaseRegNum != RegOpNum)) ? RegOpNum : AtRegNum;
 907   TempInst.setOpcode(Mips::LUi);
 908   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
 909   if (isImmOpnd)
 910     TempInst.addOperand(MCOperand::CreateImm(HiOffset));
 911   else {
 912     if (ExprOffset->getKind() == MCExpr::SymbolRef) {
 913       SR = static_cast<const MCSymbolRefExpr *>(ExprOffset);
 914       const MCSymbolRefExpr *HiExpr = MCSymbolRefExpr::Create(
 915           SR->getSymbol().getName(), MCSymbolRefExpr::VK_Mips_ABS_HI,
 916           getContext());
 917       TempInst.addOperand(MCOperand::CreateExpr(HiExpr));
 918     } else {
 919       const MCExpr *HiExpr = evaluateRelocExpr(ExprOffset, "hi");
 920       TempInst.addOperand(MCOperand::CreateExpr(HiExpr));
 921     }
 922   }
 923   // Add the instruction to the list.
 924   Instructions.push_back(TempInst);
 925   // Prepare TempInst for next instruction.
 926   TempInst.clear();
 927   // Add temp register to base.
 928   TempInst.setOpcode(Mips::ADDu);
 929   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
 930   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
 931   TempInst.addOperand(MCOperand::CreateReg(BaseRegNum));
 932   Instructions.push_back(TempInst);
 933   TempInst.clear();
 934   // And finally, create original instruction with low part
 935   // of offset and new base.
 936   TempInst.setOpcode(Inst.getOpcode());
 937   TempInst.addOperand(MCOperand::CreateReg(RegOpNum));
 938   TempInst.addOperand(MCOperand::CreateReg(TmpRegNum));
 939   if (isImmOpnd)
 940     TempInst.addOperand(MCOperand::CreateImm(LoOffset));
 941   else {
 942     if (ExprOffset->getKind() == MCExpr::SymbolRef) {
 943       const MCSymbolRefExpr *LoExpr = MCSymbolRefExpr::Create(
 944           SR->getSymbol().getName(), MCSymbolRefExpr::VK_Mips_ABS_LO,
 945           getContext());
 946       TempInst.addOperand(MCOperand::CreateExpr(LoExpr));
 947     } else {
 948       const MCExpr *LoExpr = evaluateRelocExpr(ExprOffset, "lo");
 949       TempInst.addOperand(MCOperand::CreateExpr(LoExpr));
 950     }
 951   }
 952   Instructions.push_back(TempInst);
 953   TempInst.clear();
 954 }
 955
 956 bool MipsAsmParser::MatchAndEmitInstruction(
 957     SMLoc IDLoc, unsigned &Opcode,
 958     SmallVectorImpl<MCParsedAsmOperand *> &Operands, MCStreamer &Out,
 959     unsigned &ErrorInfo, bool MatchingInlineAsm) {
 960   MCInst Inst;
 961   SmallVector<MCInst, 8> Instructions;
 962   unsigned MatchResult =
 963       MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
 964
 965   switch (MatchResult) {
 966   default:
 967     break;
 968   case Match_Success: {
 969     if (processInstruction(Inst, IDLoc, Instructions))
 970       return true;
 971     for (unsigned i = 0; i < Instructions.size(); i++)
 972       Out.EmitInstruction(Instructions[i], STI);
 973     return false;
 974   }
 975   case Match_MissingFeature:
 976     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
 977     return true;
 978   case Match_InvalidOperand: {
 979     SMLoc ErrorLoc = IDLoc;
 980     if (ErrorInfo != ~0U) {
 981       if (ErrorInfo >= Operands.size())
 982         return Error(IDLoc, "too few operands for instruction");
 983
 984       ErrorLoc = ((MipsOperand *)Operands[ErrorInfo])->getStartLoc();
 985       if (ErrorLoc == SMLoc())
 986         ErrorLoc = IDLoc;
 987     }
 988
 989     return Error(ErrorLoc, "invalid operand for instruction");
 990   }
 991   case Match_MnemonicFail:
 992     return Error(IDLoc, "invalid instruction");
 993   }
 994   return true;
 995 }
 996
 997 void MipsAsmParser::warnIfAssemblerTemporary(int RegNo) {
 998   if ((RegNo != 0) && ((int)Options.getATRegNum() == RegNo)) {
 999     if (RegNo == 1)
1000       Warning(getLexer().getLoc(), "Used $at without \".set noat\"");
1001     else
1002       Warning(getLexer().getLoc(), Twine("Used $") + Twine(RegNo) +
1003                                        " with \".set at=$" + Twine(RegNo) +
1004                                        "\"");
1005   }
1006 }
1007
1008 int MipsAsmParser::matchCPURegisterName(StringRef Name) {
1009   int CC;
1010
1011   CC = StringSwitch<unsigned>(Name)
1012            .Case("zero", 0)
1013            .Case("at", 1)
1014            .Case("a0", 4)
1015            .Case("a1", 5)
1016            .Case("a2", 6)
1017            .Case("a3", 7)
1018            .Case("v0", 2)
1019            .Case("v1", 3)
1020            .Case("s0", 16)
1021            .Case("s1", 17)
1022            .Case("s2", 18)
1023            .Case("s3", 19)
1024            .Case("s4", 20)
1025            .Case("s5", 21)
1026            .Case("s6", 22)
1027            .Case("s7", 23)
1028            .Case("k0", 26)
1029            .Case("k1", 27)
1030            .Case("gp", 28)
1031            .Case("sp", 29)
1032            .Case("fp", 30)
1033            .Case("s8", 30)
1034            .Case("ra", 31)
1035            .Case("t0", 8)
1036            .Case("t1", 9)
1037            .Case("t2", 10)
1038            .Case("t3", 11)
1039            .Case("t4", 12)
1040            .Case("t5", 13)
1041            .Case("t6", 14)
1042            .Case("t7", 15)
1043            .Case("t8", 24)
1044            .Case("t9", 25)
1045            .Default(-1);
1046
1047   if (isN32() || isN64()) {
1048     // Although SGI documentation just cuts out t0-t3 for n32/n64,
1049     // GNU pushes the values of t0-t3 to override the o32/o64 values for t4-t7
1050     // We are supporting both cases, so for t0-t3 we'll just push them to t4-t7.
1051     if (8 <= CC && CC <= 11)
1052       CC += 4;
1053
1054     if (CC == -1)
1055       CC = StringSwitch<unsigned>(Name)
1056                .Case("a4", 8)
1057                .Case("a5", 9)
1058                .Case("a6", 10)
1059                .Case("a7", 11)
1060                .Case("kt0", 26)
1061                .Case("kt1", 27)
1062                .Default(-1);
1063   }
1064
1065   warnIfAssemblerTemporary(CC);
1066
1067   return CC;
1068 }
1069
1070 int MipsAsmParser::matchFPURegisterName(StringRef Name) {
1071
1072   if (Name[0] == 'f') {
1073     StringRef NumString = Name.substr(1);
1074     unsigned IntVal;
1075     if (NumString.getAsInteger(10, IntVal))
1076       return -1;     // This is not an integer.
1077     if (IntVal > 31) // Maximum index for fpu register.
1078       return -1;
1079     return IntVal;
1080   }
1081   return -1;
1082 }
1083
1084 int MipsAsmParser::matchFCCRegisterName(StringRef Name) {
1085
1086   if (Name.startswith("fcc")) {
1087     StringRef NumString = Name.substr(3);
1088     unsigned IntVal;
1089     if (NumString.getAsInteger(10, IntVal))
1090       return -1;    // This is not an integer.
1091     if (IntVal > 7) // There are only 8 fcc registers.
1092       return -1;
1093     return IntVal;
1094   }
1095   return -1;
1096 }
1097
1098 int MipsAsmParser::matchACRegisterName(StringRef Name) {
1099
1100   if (Name.startswith("ac")) {
1101     StringRef NumString = Name.substr(2);
1102     unsigned IntVal;
1103     if (NumString.getAsInteger(10, IntVal))
1104       return -1;    // This is not an integer.
1105     if (IntVal > 3) // There are only 3 acc registers.
1106       return -1;
1107     return IntVal;
1108   }
1109   return -1;
1110 }
1111
1112 int MipsAsmParser::matchMSA128RegisterName(StringRef Name) {
1113   unsigned IntVal;
1114
1115   if (Name.front() != 'w' || Name.drop_front(1).getAsInteger(10, IntVal))
1116     return -1;
1117
1118   if (IntVal > 31)
1119     return -1;
1120
1121   return IntVal;
1122 }
1123
1124 int MipsAsmParser::matchMSA128CtrlRegisterName(StringRef Name) {
1125   int CC;
1126
1127   CC = StringSwitch<unsigned>(Name)
1128            .Case("msair", 0)
1129            .Case("msacsr", 1)
1130            .Case("msaaccess", 2)
1131            .Case("msasave", 3)
1132            .Case("msamodify", 4)
1133            .Case("msarequest", 5)
1134            .Case("msamap", 6)
1135            .Case("msaunmap", 7)
1136            .Default(-1);
1137
1138   return CC;
1139 }
1140
1141 int MipsAsmParser::matchRegisterName(StringRef Name, bool is64BitReg) {
1142
1143   int CC;
1144   CC = matchCPURegisterName(Name);
1145   if (CC != -1)
1146     return matchRegisterByNumber(CC, is64BitReg ? Mips::GPR64RegClassID
1147                                                 : Mips::GPR32RegClassID);
1148   CC = matchFPURegisterName(Name);
1149   // TODO: decide about fpu register class
1150   if (CC != -1)
1151     return matchRegisterByNumber(CC, isFP64() ? Mips::FGR64RegClassID
1152                                               : Mips::FGR32RegClassID);
1153   return matchMSA128RegisterName(Name);
1154 }
1155
1156 int MipsAsmParser::regKindToRegClass(int RegKind) {
1157
1158   switch (RegKind) {
1159   case MipsOperand::Kind_GPR32:
1160     return Mips::GPR32RegClassID;
1161   case MipsOperand::Kind_GPR64:
1162     return Mips::GPR64RegClassID;
1163   case MipsOperand::Kind_HWRegs:
1164     return Mips::HWRegsRegClassID;
1165   case MipsOperand::Kind_FGR32Regs:
1166     return Mips::FGR32RegClassID;
1167   case MipsOperand::Kind_FGRH32Regs:
1168     return Mips::FGRH32RegClassID;
1169   case MipsOperand::Kind_FGR64Regs:
1170     return Mips::FGR64RegClassID;
1171   case MipsOperand::Kind_AFGR64Regs:
1172     return Mips::AFGR64RegClassID;
1173   case MipsOperand::Kind_CCRRegs:
1174     return Mips::CCRRegClassID;
1175   case MipsOperand::Kind_ACC64DSP:
1176     return Mips::ACC64DSPRegClassID;
1177   case MipsOperand::Kind_FCCRegs:
1178     return Mips::FCCRegClassID;
1179   case MipsOperand::Kind_MSA128BRegs:
1180     return Mips::MSA128BRegClassID;
1181   case MipsOperand::Kind_MSA128HRegs:
1182     return Mips::MSA128HRegClassID;
1183   case MipsOperand::Kind_MSA128WRegs:
1184     return Mips::MSA128WRegClassID;
1185   case MipsOperand::Kind_MSA128DRegs:
1186     return Mips::MSA128DRegClassID;
1187   case MipsOperand::Kind_MSA128CtrlRegs:
1188     return Mips::MSACtrlRegClassID;
1189   default:
1190     return -1;
1191   }
1192 }
1193
1194 bool MipsAssemblerOptions::setATReg(unsigned Reg) {
1195   if (Reg > 31)
1196     return false;
1197
1198   aTReg = Reg;
1199   return true;
1200 }
1201
1202 int MipsAsmParser::getATReg() {
1203   int AT = Options.getATRegNum();
1204   if (AT == 0)
1205     TokError("Pseudo instruction requires $at, which is not available");
1206   return AT;
1207 }
1208
1209 unsigned MipsAsmParser::getReg(int RC, int RegNo) {
1210   return *(getContext().getRegisterInfo()->getRegClass(RC).begin() + RegNo);
1211 }
1212
1213 unsigned MipsAsmParser::getGPR(int RegNo) {
1214   return getReg(isGP64() ? Mips::GPR64RegClassID : Mips::GPR32RegClassID,
1215                 RegNo);
1216 }
1217
1218 int MipsAsmParser::matchRegisterByNumber(unsigned RegNum, unsigned RegClass) {
1219   if (RegNum >
1220       getContext().getRegisterInfo()->getRegClass(RegClass).getNumRegs() - 1)
1221     return -1;
1222
1223   if (RegClass == Mips::GPR32RegClassID || RegClass == Mips::GPR64RegClassID)
1224     warnIfAssemblerTemporary(RegNum);
1225
1226   return getReg(RegClass, RegNum);
1227 }
1228
1229 int MipsAsmParser::tryParseRegister(bool is64BitReg) {
1230   const AsmToken &Tok = Parser.getTok();
1231   int RegNum = -1;
1232
1233   if (Tok.is(AsmToken::Identifier)) {
1234     std::string lowerCase = Tok.getString().lower();
1235     RegNum = matchRegisterName(lowerCase, is64BitReg);
1236   } else if (Tok.is(AsmToken::Integer))
1237     RegNum = matchRegisterByNumber(static_cast<unsigned>(Tok.getIntVal()),
1238                                    is64BitReg ? Mips::GPR64RegClassID
1239                                               : Mips::GPR32RegClassID);
1240   return RegNum;
1241 }
1242
1243 bool MipsAsmParser::tryParseRegisterOperand(
1244     SmallVectorImpl<MCParsedAsmOperand *> &Operands, bool is64BitReg) {
1245
1246   SMLoc S = Parser.getTok().getLoc();
1247   int RegNo = -1;
1248
1249   RegNo = tryParseRegister(is64BitReg);
1250   if (RegNo == -1)
1251     return true;
1252
1253   Operands.push_back(
1254       MipsOperand::CreateReg(RegNo, S, Parser.getTok().getLoc()));
1255   Parser.Lex(); // Eat register token.
1256   return false;
1257 }
1258
1259 bool
1260 MipsAsmParser::ParseOperand(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
1261                             StringRef Mnemonic) {
1262   // Check if the current operand has a custom associated parser, if so, try to
1263   // custom parse the operand, or fallback to the general approach.
1264   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
1265   if (ResTy == MatchOperand_Success)
1266     return false;
1267   // If there wasn't a custom match, try the generic matcher below. Otherwise,
1268   // there was a match, but an error occurred, in which case, just return that
1269   // the operand parsing failed.
1270   if (ResTy == MatchOperand_ParseFail)
1271     return true;
1272
1273   switch (getLexer().getKind()) {
1274   default:
1275     Error(Parser.getTok().getLoc(), "unexpected token in operand");
1276     return true;
1277   case AsmToken::Dollar: {
1278     // Parse the register.
1279     SMLoc S = Parser.getTok().getLoc();
1280     Parser.Lex(); // Eat dollar token.
1281     // Parse the register operand.
1282     if (!tryParseRegisterOperand(Operands, isGP64())) {
1283       if (getLexer().is(AsmToken::LParen)) {
1284         // Check if it is indexed addressing operand.
1285         Operands.push_back(MipsOperand::CreateToken("(", S));
1286         Parser.Lex(); // Eat the parenthesis.
1287         if (getLexer().isNot(AsmToken::Dollar))
1288           return true;
1289
1290         Parser.Lex(); // Eat the dollar
1291         if (tryParseRegisterOperand(Operands, isGP64()))
1292           return true;
1293
1294         if (!getLexer().is(AsmToken::RParen))
1295           return true;
1296
1297         S = Parser.getTok().getLoc();
1298         Operands.push_back(MipsOperand::CreateToken(")", S));
1299         Parser.Lex();
1300       }
1301       return false;
1302     }
1303     // Maybe it is a symbol reference.
1304     StringRef Identifier;
1305     if (Parser.parseIdentifier(Identifier))
1306       return true;
1307
1308     SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1309     MCSymbol *Sym = getContext().GetOrCreateSymbol("$" + Identifier);
1310     // Otherwise create a symbol reference.
1311     const MCExpr *Res =
1312         MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_None, getContext());
1313
1314     Operands.push_back(MipsOperand::CreateImm(Res, S, E));
1315     return false;
1316   }
1317   case AsmToken::Identifier:
1318     // For instruction aliases like "bc1f $Label" dedicated parser will
1319     // eat the '$' sign before failing. So in order to look for appropriate
1320     // label we must check first if we have already consumed '$'.
1321     if (hasConsumedDollar) {
1322       hasConsumedDollar = false;
1323       SMLoc S = Parser.getTok().getLoc();
1324       StringRef Identifier;
1325       if (Parser.parseIdentifier(Identifier))
1326         return true;
1327       SMLoc E =
1328           SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1329       MCSymbol *Sym = getContext().GetOrCreateSymbol("$" + Identifier);
1330       // Create a symbol reference.
1331       const MCExpr *Res =
1332           MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_None, getContext());
1333
1334       Operands.push_back(MipsOperand::CreateImm(Res, S, E));
1335       return false;
1336     }
1337     // Look for the existing symbol, we should check if
1338     // we need to assign the proper RegisterKind.
1339     if (searchSymbolAlias(Operands, MipsOperand::Kind_None))
1340       return false;
1341   // Else drop to expression parsing.
1342   case AsmToken::LParen:
1343   case AsmToken::Minus:
1344   case AsmToken::Plus:
1345   case AsmToken::Integer:
1346   case AsmToken::String: {
1347     // Quoted label names.
1348     const MCExpr *IdVal;
1349     SMLoc S = Parser.getTok().getLoc();
1350     if (getParser().parseExpression(IdVal))
1351       return true;
1352     SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1353     Operands.push_back(MipsOperand::CreateImm(IdVal, S, E));
1354     return false;
1355   }
1356   case AsmToken::Percent: {
1357     // It is a symbol reference or constant expression.
1358     const MCExpr *IdVal;
1359     SMLoc S = Parser.getTok().getLoc(); // Start location of the operand.
1360     if (parseRelocOperand(IdVal))
1361       return true;
1362
1363     SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1364
1365     Operands.push_back(MipsOperand::CreateImm(IdVal, S, E));
1366     return false;
1367   } // case AsmToken::Percent
1368   } // switch(getLexer().getKind())
1369   return true;
1370 }
1371
1372 const MCExpr *MipsAsmParser::evaluateRelocExpr(const MCExpr *Expr,
1373                                                StringRef RelocStr) {
1374   const MCExpr *Res;
1375   // Check the type of the expression.
1376   if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Expr)) {
1377     // It's a constant, evaluate lo or hi value.
1378     if (RelocStr == "lo") {
1379       short Val = MCE->getValue();
1380       Res = MCConstantExpr::Create(Val, getContext());
1381     } else if (RelocStr == "hi") {
1382       int Val = MCE->getValue();
1383       int LoSign = Val & 0x8000;
1384       Val = (Val & 0xffff0000) >> 16;
1385       // Lower part is treated as a signed int, so if it is negative
1386       // we must add 1 to the hi part to compensate.
1387       if (LoSign)
1388         Val++;
1389       Res = MCConstantExpr::Create(Val, getContext());
1390     } else {
1391       llvm_unreachable("Invalid RelocStr value");
1392     }
1393     return Res;
1394   }
1395
1396   if (const MCSymbolRefExpr *MSRE = dyn_cast<MCSymbolRefExpr>(Expr)) {
1397     // It's a symbol, create a symbolic expression from the symbol.
1398     StringRef Symbol = MSRE->getSymbol().getName();
1399     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
1400     Res = MCSymbolRefExpr::Create(Symbol, VK, getContext());
1401     return Res;
1402   }
1403
1404   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
1405     MCSymbolRefExpr::VariantKind VK = getVariantKind(RelocStr);
1406
1407     // Check for %hi(sym1-sym2) and %lo(sym1-sym2) expressions.
1408     if (isa<MCSymbolRefExpr>(BE->getLHS()) && isa<MCSymbolRefExpr>(BE->getRHS())
1409         && (VK == MCSymbolRefExpr::VK_Mips_ABS_HI
1410             || VK == MCSymbolRefExpr::VK_Mips_ABS_LO)) {
1411       // Create target expression for %hi(sym1-sym2) and %lo(sym1-sym2).
1412       if (VK == MCSymbolRefExpr::VK_Mips_ABS_HI)
1413         return MipsMCExpr::CreateHi(Expr, getContext());
1414       return MipsMCExpr::CreateLo(Expr, getContext());
1415     }
1416
1417     const MCExpr *LExp = evaluateRelocExpr(BE->getLHS(), RelocStr);
1418     const MCExpr *RExp = evaluateRelocExpr(BE->getRHS(), RelocStr);
1419     Res = MCBinaryExpr::Create(BE->getOpcode(), LExp, RExp, getContext());
1420     return Res;
1421   }
1422
1423   if (const MCUnaryExpr *UN = dyn_cast<MCUnaryExpr>(Expr)) {
1424     const MCExpr *UnExp = evaluateRelocExpr(UN->getSubExpr(), RelocStr);
1425     Res = MCUnaryExpr::Create(UN->getOpcode(), UnExp, getContext());
1426     return Res;
1427   }
1428   // Just return the original expression.
1429   return Expr;
1430 }
1431
1432 bool MipsAsmParser::isEvaluated(const MCExpr *Expr) {
1433
1434   switch (Expr->getKind()) {
1435   case MCExpr::Constant:
1436     return true;
1437   case MCExpr::SymbolRef:
1438     return (cast<MCSymbolRefExpr>(Expr)->getKind() != MCSymbolRefExpr::VK_None);
1439   case MCExpr::Binary:
1440     if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(Expr)) {
1441       if (!isEvaluated(BE->getLHS()))
1442         return false;
1443       return isEvaluated(BE->getRHS());
1444     }
1445   case MCExpr::Unary:
1446     return isEvaluated(cast<MCUnaryExpr>(Expr)->getSubExpr());
1447   case MCExpr::Target:
1448     return true;
1449   }
1450   return false;
1451 }
1452
1453 bool MipsAsmParser::parseRelocOperand(const MCExpr *&Res) {
1454   Parser.Lex();                          // Eat the % token.
1455   const AsmToken &Tok = Parser.getTok(); // Get next token, operation.
1456   if (Tok.isNot(AsmToken::Identifier))
1457     return true;
1458
1459   std::string Str = Tok.getIdentifier().str();
1460
1461   Parser.Lex(); // Eat the identifier.
1462   // Now make an expression from the rest of the operand.
1463   const MCExpr *IdVal;
1464   SMLoc EndLoc;
1465
1466   if (getLexer().getKind() == AsmToken::LParen) {
1467     while (1) {
1468       Parser.Lex(); // Eat the '(' token.
1469       if (getLexer().getKind() == AsmToken::Percent) {
1470         Parser.Lex(); // Eat the % token.
1471         const AsmToken &nextTok = Parser.getTok();
1472         if (nextTok.isNot(AsmToken::Identifier))
1473           return true;
1474         Str += "(%";
1475         Str += nextTok.getIdentifier();
1476         Parser.Lex(); // Eat the identifier.
1477         if (getLexer().getKind() != AsmToken::LParen)
1478           return true;
1479       } else
1480         break;
1481     }
1482     if (getParser().parseParenExpression(IdVal, EndLoc))
1483       return true;
1484
1485     while (getLexer().getKind() == AsmToken::RParen)
1486       Parser.Lex(); // Eat the ')' token.
1487
1488   } else
1489     return true; // Parenthesis must follow the relocation operand.
1490
1491   Res = evaluateRelocExpr(IdVal, Str);
1492   return false;
1493 }
1494
1495 bool MipsAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
1496                                   SMLoc &EndLoc) {
1497   StartLoc = Parser.getTok().getLoc();
1498   RegNo = tryParseRegister(isGP64());
1499   EndLoc = Parser.getTok().getLoc();
1500   return (RegNo == (unsigned)-1);
1501 }
1502
1503 bool MipsAsmParser::parseMemOffset(const MCExpr *&Res, bool isParenExpr) {
1504   SMLoc S;
1505   bool Result = true;
1506
1507   while (getLexer().getKind() == AsmToken::LParen)
1508     Parser.Lex();
1509
1510   switch (getLexer().getKind()) {
1511   default:
1512     return true;
1513   case AsmToken::Identifier:
1514   case AsmToken::LParen:
1515   case AsmToken::Integer:
1516   case AsmToken::Minus:
1517   case AsmToken::Plus:
1518     if (isParenExpr)
1519       Result = getParser().parseParenExpression(Res, S);
1520     else
1521       Result = (getParser().parseExpression(Res));
1522     while (getLexer().getKind() == AsmToken::RParen)
1523       Parser.Lex();
1524     break;
1525   case AsmToken::Percent:
1526     Result = parseRelocOperand(Res);
1527   }
1528   return Result;
1529 }
1530
1531 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMemOperand(
1532     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1533
1534   const MCExpr *IdVal = 0;
1535   SMLoc S;
1536   bool isParenExpr = false;
1537   MipsAsmParser::OperandMatchResultTy Res = MatchOperand_NoMatch;
1538   // First operand is the offset.
1539   S = Parser.getTok().getLoc();
1540
1541   if (getLexer().getKind() == AsmToken::LParen) {
1542     Parser.Lex();
1543     isParenExpr = true;
1544   }
1545
1546   if (getLexer().getKind() != AsmToken::Dollar) {
1547     if (parseMemOffset(IdVal, isParenExpr))
1548       return MatchOperand_ParseFail;
1549
1550     const AsmToken &Tok = Parser.getTok(); // Get the next token.
1551     if (Tok.isNot(AsmToken::LParen)) {
1552       MipsOperand *Mnemonic = static_cast<MipsOperand *>(Operands[0]);
1553       if (Mnemonic->getToken() == "la") {
1554         SMLoc E =
1555             SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1556         Operands.push_back(MipsOperand::CreateImm(IdVal, S, E));
1557         return MatchOperand_Success;
1558       }
1559       if (Tok.is(AsmToken::EndOfStatement)) {
1560         SMLoc E =
1561             SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1562
1563         // Zero register assumed, add a memory operand with ZERO as its base.
1564         Operands.push_back(MipsOperand::CreateMem(
1565             isGP64() ? Mips::ZERO_64 : Mips::ZERO, IdVal, S, E));
1566         return MatchOperand_Success;
1567       }
1568       Error(Parser.getTok().getLoc(), "'(' expected");
1569       return MatchOperand_ParseFail;
1570     }
1571
1572     Parser.Lex(); // Eat the '(' token.
1573   }
1574
1575   Res = parseRegs(Operands, isGP64() ? (int)MipsOperand::Kind_GPR64
1576                                      : (int)MipsOperand::Kind_GPR32);
1577   if (Res != MatchOperand_Success)
1578     return Res;
1579
1580   if (Parser.getTok().isNot(AsmToken::RParen)) {
1581     Error(Parser.getTok().getLoc(), "')' expected");
1582     return MatchOperand_ParseFail;
1583   }
1584
1585   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1586
1587   Parser.Lex(); // Eat the ')' token.
1588
1589   if (IdVal == 0)
1590     IdVal = MCConstantExpr::Create(0, getContext());
1591
1592   // Replace the register operand with the memory operand.
1593   MipsOperand *op = static_cast<MipsOperand *>(Operands.back());
1594   int RegNo = op->getReg();
1595   // Remove the register from the operands.
1596   Operands.pop_back();
1597   // Add the memory operand.
1598   if (const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(IdVal)) {
1599     int64_t Imm;
1600     if (IdVal->EvaluateAsAbsolute(Imm))
1601       IdVal = MCConstantExpr::Create(Imm, getContext());
1602     else if (BE->getLHS()->getKind() != MCExpr::SymbolRef)
1603       IdVal = MCBinaryExpr::Create(BE->getOpcode(), BE->getRHS(), BE->getLHS(),
1604                                    getContext());
1605   }
1606
1607   Operands.push_back(MipsOperand::CreateMem(RegNo, IdVal, S, E));
1608   delete op;
1609   return MatchOperand_Success;
1610 }
1611
1612 bool MipsAsmParser::parsePtrReg(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
1613                                 int RegKind) {
1614   // If the first token is not '$' we have an error.
1615   if (Parser.getTok().isNot(AsmToken::Dollar))
1616     return false;
1617
1618   SMLoc S = Parser.getTok().getLoc();
1619   Parser.Lex();
1620   AsmToken::TokenKind TkKind = getLexer().getKind();
1621   int Reg;
1622
1623   if (TkKind == AsmToken::Integer) {
1624     Reg = matchRegisterByNumber(Parser.getTok().getIntVal(),
1625                                 regKindToRegClass(RegKind));
1626     if (Reg == -1)
1627       return false;
1628   } else if (TkKind == AsmToken::Identifier) {
1629     if ((Reg = matchCPURegisterName(Parser.getTok().getString().lower())) == -1)
1630       return false;
1631     Reg = getReg(regKindToRegClass(RegKind), Reg);
1632   } else {
1633     return false;
1634   }
1635
1636   MipsOperand *Op = MipsOperand::CreatePtrReg(Reg, S, Parser.getTok().getLoc());
1637   Op->setRegKind((MipsOperand::RegisterKind)RegKind);
1638   Operands.push_back(Op);
1639   Parser.Lex();
1640   return true;
1641 }
1642
1643 MipsAsmParser::OperandMatchResultTy
1644 MipsAsmParser::parsePtrReg(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1645   MipsOperand::RegisterKind RegKind =
1646       isN64() ? MipsOperand::Kind_GPR64 : MipsOperand::Kind_GPR32;
1647
1648   // Parse index register.
1649   if (!parsePtrReg(Operands, RegKind))
1650     return MatchOperand_NoMatch;
1651
1652   // Parse '('.
1653   if (Parser.getTok().isNot(AsmToken::LParen))
1654     return MatchOperand_NoMatch;
1655
1656   Operands.push_back(MipsOperand::CreateToken("(", getLexer().getLoc()));
1657   Parser.Lex();
1658
1659   // Parse base register.
1660   if (!parsePtrReg(Operands, RegKind))
1661     return MatchOperand_NoMatch;
1662
1663   // Parse ')'.
1664   if (Parser.getTok().isNot(AsmToken::RParen))
1665     return MatchOperand_NoMatch;
1666
1667   Operands.push_back(MipsOperand::CreateToken(")", getLexer().getLoc()));
1668   Parser.Lex();
1669
1670   return MatchOperand_Success;
1671 }
1672
1673 MipsAsmParser::OperandMatchResultTy
1674 MipsAsmParser::parseRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
1675                          int RegKind) {
1676   MipsOperand::RegisterKind Kind = (MipsOperand::RegisterKind)RegKind;
1677   if (getLexer().getKind() == AsmToken::Identifier && !hasConsumedDollar) {
1678     if (searchSymbolAlias(Operands, Kind))
1679       return MatchOperand_Success;
1680     return MatchOperand_NoMatch;
1681   }
1682   SMLoc S = Parser.getTok().getLoc();
1683   // If the first token is not '$', we have an error.
1684   if (Parser.getTok().isNot(AsmToken::Dollar) && !hasConsumedDollar)
1685     return MatchOperand_NoMatch;
1686   if (!hasConsumedDollar) {
1687     Parser.Lex(); // Eat the '$'
1688     hasConsumedDollar = true;
1689   }
1690   if (getLexer().getKind() == AsmToken::Identifier) {
1691     int RegNum = -1;
1692     std::string RegName = Parser.getTok().getString().lower();
1693     // Match register by name
1694     switch (RegKind) {
1695     case MipsOperand::Kind_GPR32:
1696     case MipsOperand::Kind_GPR64:
1697       RegNum = matchCPURegisterName(RegName);
1698       break;
1699     case MipsOperand::Kind_AFGR64Regs:
1700     case MipsOperand::Kind_FGR64Regs:
1701     case MipsOperand::Kind_FGR32Regs:
1702     case MipsOperand::Kind_FGRH32Regs:
1703       RegNum = matchFPURegisterName(RegName);
1704       if (RegKind == MipsOperand::Kind_AFGR64Regs)
1705         RegNum /= 2;
1706       else if (RegKind == MipsOperand::Kind_FGRH32Regs && !isFP64())
1707         if (RegNum != -1 && RegNum % 2 != 0)
1708           Warning(S, "Float register should be even.");
1709       break;
1710     case MipsOperand::Kind_FCCRegs:
1711       RegNum = matchFCCRegisterName(RegName);
1712       break;
1713     case MipsOperand::Kind_ACC64DSP:
1714       RegNum = matchACRegisterName(RegName);
1715       break;
1716     default:
1717       break; // No match, value is set to -1.
1718     }
1719     // No match found, return _NoMatch to give a chance to other round.
1720     if (RegNum < 0)
1721       return MatchOperand_NoMatch;
1722
1723     int RegVal = getReg(regKindToRegClass(Kind), RegNum);
1724     if (RegVal == -1)
1725       return MatchOperand_NoMatch;
1726
1727     MipsOperand *Op =
1728         MipsOperand::CreateReg(RegVal, S, Parser.getTok().getLoc());
1729     Op->setRegKind(Kind);
1730     Operands.push_back(Op);
1731     hasConsumedDollar = false;
1732     Parser.Lex(); // Eat the register name.
1733     return MatchOperand_Success;
1734   } else if (getLexer().getKind() == AsmToken::Integer) {
1735     unsigned RegNum = Parser.getTok().getIntVal();
1736     if (Kind == MipsOperand::Kind_HWRegs) {
1737       if (RegNum != 29)
1738         return MatchOperand_NoMatch;
1739       // Only hwreg 29 is supported, found at index 0.
1740       RegNum = 0;
1741     }
1742     int Reg = matchRegisterByNumber(RegNum, regKindToRegClass(Kind));
1743     if (Reg == -1)
1744       return MatchOperand_NoMatch;
1745     MipsOperand *Op = MipsOperand::CreateReg(Reg, S, Parser.getTok().getLoc());
1746     Op->setRegKind(Kind);
1747     Operands.push_back(Op);
1748     hasConsumedDollar = false;
1749     Parser.Lex(); // Eat the register number.
1750     if ((RegKind == MipsOperand::Kind_GPR32) &&
1751         (getLexer().is(AsmToken::LParen))) {
1752       // Check if it is indexed addressing operand.
1753       Operands.push_back(MipsOperand::CreateToken("(", getLexer().getLoc()));
1754       Parser.Lex(); // Eat the parenthesis.
1755       if (parseRegs(Operands, RegKind) != MatchOperand_Success)
1756         return MatchOperand_NoMatch;
1757       if (getLexer().isNot(AsmToken::RParen))
1758         return MatchOperand_NoMatch;
1759       Operands.push_back(MipsOperand::CreateToken(")", getLexer().getLoc()));
1760       Parser.Lex();
1761     }
1762     return MatchOperand_Success;
1763   }
1764   return MatchOperand_NoMatch;
1765 }
1766
1767 bool MipsAsmParser::validateMSAIndex(int Val, int RegKind) {
1768   MipsOperand::RegisterKind Kind = (MipsOperand::RegisterKind)RegKind;
1769
1770   if (Val < 0)
1771     return false;
1772
1773   switch (Kind) {
1774   default:
1775     return false;
1776   case MipsOperand::Kind_MSA128BRegs:
1777     return Val < 16;
1778   case MipsOperand::Kind_MSA128HRegs:
1779     return Val < 8;
1780   case MipsOperand::Kind_MSA128WRegs:
1781     return Val < 4;
1782   case MipsOperand::Kind_MSA128DRegs:
1783     return Val < 2;
1784   }
1785 }
1786
1787 MipsAsmParser::OperandMatchResultTy
1788 MipsAsmParser::parseMSARegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
1789                             int RegKind) {
1790   MipsOperand::RegisterKind Kind = (MipsOperand::RegisterKind)RegKind;
1791   SMLoc S = Parser.getTok().getLoc();
1792   std::string RegName;
1793
1794   if (Parser.getTok().isNot(AsmToken::Dollar))
1795     return MatchOperand_NoMatch;
1796
1797   switch (RegKind) {
1798   default:
1799     return MatchOperand_ParseFail;
1800   case MipsOperand::Kind_MSA128BRegs:
1801   case MipsOperand::Kind_MSA128HRegs:
1802   case MipsOperand::Kind_MSA128WRegs:
1803   case MipsOperand::Kind_MSA128DRegs:
1804     break;
1805   }
1806
1807   Parser.Lex(); // Eat the '$'.
1808   if (getLexer().getKind() == AsmToken::Identifier)
1809     RegName = Parser.getTok().getString().lower();
1810   else
1811     return MatchOperand_ParseFail;
1812
1813   int RegNum = matchMSA128RegisterName(RegName);
1814
1815   if (RegNum < 0 || RegNum > 31)
1816     return MatchOperand_ParseFail;
1817
1818   int RegVal = getReg(regKindToRegClass(Kind), RegNum);
1819   if (RegVal == -1)
1820     return MatchOperand_ParseFail;
1821
1822   MipsOperand *Op = MipsOperand::CreateReg(RegVal, S, Parser.getTok().getLoc());
1823   Op->setRegKind(Kind);
1824   Operands.push_back(Op);
1825
1826   Parser.Lex(); // Eat the register identifier.
1827
1828   // MSA registers may be suffixed with an index in the form of:
1829   // 1) Immediate expression.
1830   // 2) General Purpose Register.
1831   // Examples:
1832   //   1) copy_s.b $29,$w0[0]
1833   //   2) sld.b $w0,$w1[$1]
1834
1835   if (Parser.getTok().isNot(AsmToken::LBrac))
1836     return MatchOperand_Success;
1837
1838   MipsOperand *Mnemonic = static_cast<MipsOperand *>(Operands[0]);
1839
1840   Operands.push_back(MipsOperand::CreateToken("[", Parser.getTok().getLoc()));
1841   Parser.Lex(); // Parse the '[' token.
1842
1843   if (Parser.getTok().is(AsmToken::Dollar)) {
1844     // This must be a GPR.
1845     MipsOperand *RegOp;
1846     SMLoc VIdx = Parser.getTok().getLoc();
1847     Parser.Lex(); // Parse the '$' token.
1848
1849     // GPR have aliases and we must account for that. Example: $30 == $fp
1850     if (getLexer().getKind() == AsmToken::Integer) {
1851       unsigned RegNum = Parser.getTok().getIntVal();
1852       int Reg = matchRegisterByNumber(
1853           RegNum, regKindToRegClass(MipsOperand::Kind_GPR32));
1854       if (Reg == -1) {
1855         Error(VIdx, "invalid general purpose register");
1856         return MatchOperand_ParseFail;
1857       }
1858
1859       RegOp = MipsOperand::CreateReg(Reg, VIdx, Parser.getTok().getLoc());
1860     } else if (getLexer().getKind() == AsmToken::Identifier) {
1861       int RegNum = -1;
1862       std::string RegName = Parser.getTok().getString().lower();
1863
1864       RegNum = matchCPURegisterName(RegName);
1865       if (RegNum == -1) {
1866         Error(VIdx, "general purpose register expected");
1867         return MatchOperand_ParseFail;
1868       }
1869       RegNum = getReg(regKindToRegClass(MipsOperand::Kind_GPR32), RegNum);
1870       RegOp = MipsOperand::CreateReg(RegNum, VIdx, Parser.getTok().getLoc());
1871     } else
1872       return MatchOperand_ParseFail;
1873
1874     RegOp->setRegKind(MipsOperand::Kind_GPR32);
1875     Operands.push_back(RegOp);
1876     Parser.Lex(); // Eat the register identifier.
1877
1878     if (Parser.getTok().isNot(AsmToken::RBrac))
1879       return MatchOperand_ParseFail;
1880
1881     Operands.push_back(MipsOperand::CreateToken("]", Parser.getTok().getLoc()));
1882     Parser.Lex(); // Parse the ']' token.
1883
1884     return MatchOperand_Success;
1885   }
1886
1887   // The index must be a constant expression then.
1888   SMLoc VIdx = Parser.getTok().getLoc();
1889   const MCExpr *ImmVal;
1890
1891   if (getParser().parseExpression(ImmVal))
1892     return MatchOperand_ParseFail;
1893
1894   const MCConstantExpr *expr = dyn_cast<MCConstantExpr>(ImmVal);
1895   if (!expr || !validateMSAIndex((int)expr->getValue(), Kind)) {
1896     Error(VIdx, "invalid immediate value");
1897     return MatchOperand_ParseFail;
1898   }
1899
1900   SMLoc E = Parser.getTok().getEndLoc();
1901
1902   if (Parser.getTok().isNot(AsmToken::RBrac))
1903     return MatchOperand_ParseFail;
1904
1905   bool insve =
1906       Mnemonic->getToken() == "insve.b" || Mnemonic->getToken() == "insve.h" ||
1907       Mnemonic->getToken() == "insve.w" || Mnemonic->getToken() == "insve.d";
1908
1909   // The second vector index of insve instructions is always 0.
1910   if (insve && Operands.size() > 6) {
1911     if (expr->getValue() != 0) {
1912       Error(VIdx, "immediate value must be 0");
1913       return MatchOperand_ParseFail;
1914     }
1915     Operands.push_back(MipsOperand::CreateToken("0", VIdx));
1916   } else
1917     Operands.push_back(MipsOperand::CreateImm(expr, VIdx, E));
1918
1919   Operands.push_back(MipsOperand::CreateToken("]", Parser.getTok().getLoc()));
1920
1921   Parser.Lex(); // Parse the ']' token.
1922
1923   return MatchOperand_Success;
1924 }
1925
1926 MipsAsmParser::OperandMatchResultTy
1927 MipsAsmParser::parseMSACtrlRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands,
1928                                 int RegKind) {
1929   MipsOperand::RegisterKind Kind = (MipsOperand::RegisterKind)RegKind;
1930
1931   if (Kind != MipsOperand::Kind_MSA128CtrlRegs)
1932     return MatchOperand_NoMatch;
1933
1934   if (Parser.getTok().isNot(AsmToken::Dollar))
1935     return MatchOperand_ParseFail;
1936
1937   SMLoc S = Parser.getTok().getLoc();
1938
1939   Parser.Lex(); // Eat the '$' symbol.
1940
1941   int RegNum = -1;
1942   if (getLexer().getKind() == AsmToken::Identifier)
1943     RegNum = matchMSA128CtrlRegisterName(Parser.getTok().getString().lower());
1944   else if (getLexer().getKind() == AsmToken::Integer)
1945     RegNum = Parser.getTok().getIntVal();
1946   else
1947     return MatchOperand_ParseFail;
1948
1949   if (RegNum < 0 || RegNum > 7)
1950     return MatchOperand_ParseFail;
1951
1952   int RegVal = getReg(regKindToRegClass(Kind), RegNum);
1953   if (RegVal == -1)
1954     return MatchOperand_ParseFail;
1955
1956   MipsOperand *RegOp =
1957       MipsOperand::CreateReg(RegVal, S, Parser.getTok().getLoc());
1958   RegOp->setRegKind(MipsOperand::Kind_MSA128CtrlRegs);
1959   Operands.push_back(RegOp);
1960   Parser.Lex(); // Eat the register identifier.
1961
1962   return MatchOperand_Success;
1963 }
1964
1965 MipsAsmParser::OperandMatchResultTy
1966 MipsAsmParser::parseGPR64(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1967
1968   if (!isGP64())
1969     return MatchOperand_NoMatch;
1970   return parseRegs(Operands, (int)MipsOperand::Kind_GPR64);
1971 }
1972
1973 MipsAsmParser::OperandMatchResultTy
1974 MipsAsmParser::parseGPR32(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1975   return parseRegs(Operands, (int)MipsOperand::Kind_GPR32);
1976 }
1977
1978 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseAFGR64Regs(
1979     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1980
1981   if (isFP64())
1982     return MatchOperand_NoMatch;
1983   return parseRegs(Operands, (int)MipsOperand::Kind_AFGR64Regs);
1984 }
1985
1986 MipsAsmParser::OperandMatchResultTy
1987 MipsAsmParser::parseFGR64Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1988   if (!isFP64())
1989     return MatchOperand_NoMatch;
1990   return parseRegs(Operands, (int)MipsOperand::Kind_FGR64Regs);
1991 }
1992
1993 MipsAsmParser::OperandMatchResultTy
1994 MipsAsmParser::parseFGR32Regs(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
1995   return parseRegs(Operands, (int)MipsOperand::Kind_FGR32Regs);
1996 }
1997
1998 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseFGRH32Regs(
1999     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2000   return parseRegs(Operands, (int)MipsOperand::Kind_FGRH32Regs);
2001 }
2002
2003 MipsAsmParser::OperandMatchResultTy
2004 MipsAsmParser::parseFCCRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2005   return parseRegs(Operands, (int)MipsOperand::Kind_FCCRegs);
2006 }
2007
2008 MipsAsmParser::OperandMatchResultTy
2009 MipsAsmParser::parseACC64DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2010   return parseRegs(Operands, (int)MipsOperand::Kind_ACC64DSP);
2011 }
2012
2013 MipsAsmParser::OperandMatchResultTy
2014 MipsAsmParser::parseLO32DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2015   // If the first token is not '$' we have an error.
2016   if (Parser.getTok().isNot(AsmToken::Dollar))
2017     return MatchOperand_NoMatch;
2018
2019   SMLoc S = Parser.getTok().getLoc();
2020   Parser.Lex(); // Eat the '$'
2021
2022   const AsmToken &Tok = Parser.getTok(); // Get next token.
2023
2024   if (Tok.isNot(AsmToken::Identifier))
2025     return MatchOperand_NoMatch;
2026
2027   if (!Tok.getIdentifier().startswith("ac"))
2028     return MatchOperand_NoMatch;
2029
2030   StringRef NumString = Tok.getIdentifier().substr(2);
2031
2032   unsigned IntVal;
2033   if (NumString.getAsInteger(10, IntVal))
2034     return MatchOperand_NoMatch;
2035
2036   unsigned Reg = matchRegisterByNumber(IntVal, Mips::LO32DSPRegClassID);
2037
2038   MipsOperand *Op = MipsOperand::CreateReg(Reg, S, Parser.getTok().getLoc());
2039   Op->setRegKind(MipsOperand::Kind_LO32DSP);
2040   Operands.push_back(Op);
2041
2042   Parser.Lex(); // Eat the register number.
2043   return MatchOperand_Success;
2044 }
2045
2046 MipsAsmParser::OperandMatchResultTy
2047 MipsAsmParser::parseHI32DSP(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2048   // If the first token is not '$' we have an error.
2049   if (Parser.getTok().isNot(AsmToken::Dollar))
2050     return MatchOperand_NoMatch;
2051
2052   SMLoc S = Parser.getTok().getLoc();
2053   Parser.Lex(); // Eat the '$'
2054
2055   const AsmToken &Tok = Parser.getTok(); // Get next token.
2056
2057   if (Tok.isNot(AsmToken::Identifier))
2058     return MatchOperand_NoMatch;
2059
2060   if (!Tok.getIdentifier().startswith("ac"))
2061     return MatchOperand_NoMatch;
2062
2063   StringRef NumString = Tok.getIdentifier().substr(2);
2064
2065   unsigned IntVal;
2066   if (NumString.getAsInteger(10, IntVal))
2067     return MatchOperand_NoMatch;
2068
2069   unsigned Reg = matchRegisterByNumber(IntVal, Mips::HI32DSPRegClassID);
2070
2071   MipsOperand *Op = MipsOperand::CreateReg(Reg, S, Parser.getTok().getLoc());
2072   Op->setRegKind(MipsOperand::Kind_HI32DSP);
2073   Operands.push_back(Op);
2074
2075   Parser.Lex(); // Eat the register number.
2076   return MatchOperand_Success;
2077 }
2078
2079 MipsAsmParser::OperandMatchResultTy
2080 MipsAsmParser::parseCOP2(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2081   // If the first token is not '$' we have an error.
2082   if (Parser.getTok().isNot(AsmToken::Dollar))
2083     return MatchOperand_NoMatch;
2084
2085   SMLoc S = Parser.getTok().getLoc();
2086   Parser.Lex(); // Eat the '$'
2087
2088   const AsmToken &Tok = Parser.getTok(); // Get next token.
2089
2090   if (Tok.isNot(AsmToken::Integer))
2091     return MatchOperand_NoMatch;
2092
2093   unsigned IntVal = Tok.getIntVal();
2094
2095   unsigned Reg = matchRegisterByNumber(IntVal, Mips::COP2RegClassID);
2096
2097   MipsOperand *Op = MipsOperand::CreateReg(Reg, S, Parser.getTok().getLoc());
2098   Op->setRegKind(MipsOperand::Kind_COP2);
2099   Operands.push_back(Op);
2100
2101   Parser.Lex(); // Eat the register number.
2102   return MatchOperand_Success;
2103 }
2104
2105 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMSA128BRegs(
2106     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2107   return parseMSARegs(Operands, (int)MipsOperand::Kind_MSA128BRegs);
2108 }
2109
2110 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMSA128HRegs(
2111     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2112   return parseMSARegs(Operands, (int)MipsOperand::Kind_MSA128HRegs);
2113 }
2114
2115 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMSA128WRegs(
2116     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2117   return parseMSARegs(Operands, (int)MipsOperand::Kind_MSA128WRegs);
2118 }
2119
2120 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMSA128DRegs(
2121     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2122   return parseMSARegs(Operands, (int)MipsOperand::Kind_MSA128DRegs);
2123 }
2124
2125 MipsAsmParser::OperandMatchResultTy MipsAsmParser::parseMSA128CtrlRegs(
2126     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2127   return parseMSACtrlRegs(Operands, (int)MipsOperand::Kind_MSA128CtrlRegs);
2128 }
2129
2130 bool MipsAsmParser::searchSymbolAlias(
2131     SmallVectorImpl<MCParsedAsmOperand *> &Operands, unsigned RegKind) {
2132
2133   MCSymbol *Sym = getContext().LookupSymbol(Parser.getTok().getIdentifier());
2134   if (Sym) {
2135     SMLoc S = Parser.getTok().getLoc();
2136     const MCExpr *Expr;
2137     if (Sym->isVariable())
2138       Expr = Sym->getVariableValue();
2139     else
2140       return false;
2141     if (Expr->getKind() == MCExpr::SymbolRef) {
2142       MipsOperand::RegisterKind Kind = (MipsOperand::RegisterKind)RegKind;
2143       const MCSymbolRefExpr *Ref = static_cast<const MCSymbolRefExpr *>(Expr);
2144       const StringRef DefSymbol = Ref->getSymbol().getName();
2145       if (DefSymbol.startswith("$")) {
2146         int RegNum = -1;
2147         APInt IntVal(32, -1);
2148         if (!DefSymbol.substr(1).getAsInteger(10, IntVal))
2149           RegNum = matchRegisterByNumber(IntVal.getZExtValue(),
2150                                          isGP64() ? Mips::GPR64RegClassID
2151                                                   : Mips::GPR32RegClassID);
2152         else {
2153           // Lookup for the register with the corresponding name.
2154           switch (Kind) {
2155           case MipsOperand::Kind_AFGR64Regs:
2156           case MipsOperand::Kind_FGR64Regs:
2157             RegNum = matchFPURegisterName(DefSymbol.substr(1));
2158             break;
2159           case MipsOperand::Kind_FGR32Regs:
2160             RegNum = matchFPURegisterName(DefSymbol.substr(1));
2161             break;
2162           case MipsOperand::Kind_GPR64:
2163           case MipsOperand::Kind_GPR32:
2164           default:
2165             RegNum = matchCPURegisterName(DefSymbol.substr(1));
2166             break;
2167           }
2168           if (RegNum > -1)
2169             RegNum = getReg(regKindToRegClass(Kind), RegNum);
2170         }
2171         if (RegNum > -1) {
2172           Parser.Lex();
2173           MipsOperand *op =
2174               MipsOperand::CreateReg(RegNum, S, Parser.getTok().getLoc());
2175           op->setRegKind(Kind);
2176           Operands.push_back(op);
2177           return true;
2178         }
2179       }
2180     } else if (Expr->getKind() == MCExpr::Constant) {
2181       Parser.Lex();
2182       const MCConstantExpr *Const = static_cast<const MCConstantExpr *>(Expr);
2183       MipsOperand *op =
2184           MipsOperand::CreateImm(Const, S, Parser.getTok().getLoc());
2185       Operands.push_back(op);
2186       return true;
2187     }
2188   }
2189   return false;
2190 }
2191
2192 MipsAsmParser::OperandMatchResultTy
2193 MipsAsmParser::parseHWRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2194   return parseRegs(Operands, (int)MipsOperand::Kind_HWRegs);
2195 }
2196
2197 MipsAsmParser::OperandMatchResultTy
2198 MipsAsmParser::parseCCRRegs(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2199   return parseRegs(Operands, (int)MipsOperand::Kind_CCRRegs);
2200 }
2201
2202 MipsAsmParser::OperandMatchResultTy
2203 MipsAsmParser::parseInvNum(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2204   const MCExpr *IdVal;
2205   // If the first token is '$' we may have register operand.
2206   if (Parser.getTok().is(AsmToken::Dollar))
2207     return MatchOperand_NoMatch;
2208   SMLoc S = Parser.getTok().getLoc();
2209   if (getParser().parseExpression(IdVal))
2210     return MatchOperand_ParseFail;
2211   const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(IdVal);
2212   assert(MCE && "Unexpected MCExpr type.");
2213   int64_t Val = MCE->getValue();
2214   SMLoc E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
2215   Operands.push_back(MipsOperand::CreateImm(
2216       MCConstantExpr::Create(0 - Val, getContext()), S, E));
2217   return MatchOperand_Success;
2218 }
2219
2220 MipsAsmParser::OperandMatchResultTy
2221 MipsAsmParser::parseLSAImm(SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2222   switch (getLexer().getKind()) {
2223   default:
2224     return MatchOperand_NoMatch;
2225   case AsmToken::LParen:
2226   case AsmToken::Plus:
2227   case AsmToken::Minus:
2228   case AsmToken::Integer:
2229     break;
2230   }
2231
2232   const MCExpr *Expr;
2233   SMLoc S = Parser.getTok().getLoc();
2234
2235   if (getParser().parseExpression(Expr))
2236     return MatchOperand_ParseFail;
2237
2238   int64_t Val;
2239   if (!Expr->EvaluateAsAbsolute(Val)) {
2240     Error(S, "expected immediate value");
2241     return MatchOperand_ParseFail;
2242   }
2243
2244   // The LSA instruction allows a 2-bit unsigned immediate. For this reason
2245   // and because the CPU always adds one to the immediate field, the allowed
2246   // range becomes 1..4. We'll only check the range here and will deal
2247   // with the addition/subtraction when actually decoding/encoding
2248   // the instruction.
2249   if (Val < 1 || Val > 4) {
2250     Error(S, "immediate not in range (1..4)");
2251     return MatchOperand_ParseFail;
2252   }
2253
2254   Operands.push_back(
2255       MipsOperand::CreateLSAImm(Expr, S, Parser.getTok().getLoc()));
2256   return MatchOperand_Success;
2257 }
2258
2259 MCSymbolRefExpr::VariantKind MipsAsmParser::getVariantKind(StringRef Symbol) {
2260
2261   MCSymbolRefExpr::VariantKind VK =
2262       StringSwitch<MCSymbolRefExpr::VariantKind>(Symbol)
2263           .Case("hi", MCSymbolRefExpr::VK_Mips_ABS_HI)
2264           .Case("lo", MCSymbolRefExpr::VK_Mips_ABS_LO)
2265           .Case("gp_rel", MCSymbolRefExpr::VK_Mips_GPREL)
2266           .Case("call16", MCSymbolRefExpr::VK_Mips_GOT_CALL)
2267           .Case("got", MCSymbolRefExpr::VK_Mips_GOT)
2268           .Case("tlsgd", MCSymbolRefExpr::VK_Mips_TLSGD)
2269           .Case("tlsldm", MCSymbolRefExpr::VK_Mips_TLSLDM)
2270           .Case("dtprel_hi", MCSymbolRefExpr::VK_Mips_DTPREL_HI)
2271           .Case("dtprel_lo", MCSymbolRefExpr::VK_Mips_DTPREL_LO)
2272           .Case("gottprel", MCSymbolRefExpr::VK_Mips_GOTTPREL)
2273           .Case("tprel_hi", MCSymbolRefExpr::VK_Mips_TPREL_HI)
2274           .Case("tprel_lo", MCSymbolRefExpr::VK_Mips_TPREL_LO)
2275           .Case("got_disp", MCSymbolRefExpr::VK_Mips_GOT_DISP)
2276           .Case("got_page", MCSymbolRefExpr::VK_Mips_GOT_PAGE)
2277           .Case("got_ofst", MCSymbolRefExpr::VK_Mips_GOT_OFST)
2278           .Case("hi(%neg(%gp_rel", MCSymbolRefExpr::VK_Mips_GPOFF_HI)
2279           .Case("lo(%neg(%gp_rel", MCSymbolRefExpr::VK_Mips_GPOFF_LO)
2280           .Default(MCSymbolRefExpr::VK_None);
2281
2282   return VK;
2283 }
2284
2285 bool MipsAsmParser::ParseInstruction(
2286     ParseInstructionInfo &Info, StringRef Name, SMLoc NameLoc,
2287     SmallVectorImpl<MCParsedAsmOperand *> &Operands) {
2288   // Check if we have valid mnemonic
2289   if (!mnemonicIsValid(Name, 0)) {
2290     Parser.eatToEndOfStatement();
2291     return Error(NameLoc, "Unknown instruction");
2292   }
2293   // First operand in MCInst is instruction mnemonic.
2294   Operands.push_back(MipsOperand::CreateToken(Name, NameLoc));
2295
2296   // Read the remaining operands.
2297   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2298     // Read the first operand.
2299     if (ParseOperand(Operands, Name)) {
2300       SMLoc Loc = getLexer().getLoc();
2301       Parser.eatToEndOfStatement();
2302       return Error(Loc, "unexpected token in argument list");
2303     }
2304
2305     while (getLexer().is(AsmToken::Comma)) {
2306       Parser.Lex(); // Eat the comma.
2307       // Parse and remember the operand.
2308       if (ParseOperand(Operands, Name)) {
2309         SMLoc Loc = getLexer().getLoc();
2310         Parser.eatToEndOfStatement();
2311         return Error(Loc, "unexpected token in argument list");
2312       }
2313     }
2314   }
2315   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2316     SMLoc Loc = getLexer().getLoc();
2317     Parser.eatToEndOfStatement();
2318     return Error(Loc, "unexpected token in argument list");
2319   }
2320   Parser.Lex(); // Consume the EndOfStatement.
2321   return false;
2322 }
2323
2324 bool MipsAsmParser::reportParseError(StringRef ErrorMsg) {
2325   SMLoc Loc = getLexer().getLoc();
2326   Parser.eatToEndOfStatement();
2327   return Error(Loc, ErrorMsg);
2328 }
2329
2330 bool MipsAsmParser::parseSetNoAtDirective() {
2331   // Line should look like: ".set noat".
2332   // set at reg to 0.
2333   Options.setATReg(0);
2334   // eat noat
2335   Parser.Lex();
2336   // If this is not the end of the statement, report an error.
2337   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2338     reportParseError("unexpected token in statement");
2339     return false;
2340   }
2341   Parser.Lex(); // Consume the EndOfStatement.
2342   return false;
2343 }
2344
2345 bool MipsAsmParser::parseSetAtDirective() {
2346   // Line can be .set at - defaults to $1
2347   // or .set at=$reg
2348   int AtRegNo;
2349   getParser().Lex();
2350   if (getLexer().is(AsmToken::EndOfStatement)) {
2351     Options.setATReg(1);
2352     Parser.Lex(); // Consume the EndOfStatement.
2353     return false;
2354   } else if (getLexer().is(AsmToken::Equal)) {
2355     getParser().Lex(); // Eat the '='.
2356     if (getLexer().isNot(AsmToken::Dollar)) {
2357       reportParseError("unexpected token in statement");
2358       return false;
2359     }
2360     Parser.Lex(); // Eat the '$'.
2361     const AsmToken &Reg = Parser.getTok();
2362     if (Reg.is(AsmToken::Identifier)) {
2363       AtRegNo = matchCPURegisterName(Reg.getIdentifier());
2364     } else if (Reg.is(AsmToken::Integer)) {
2365       AtRegNo = Reg.getIntVal();
2366     } else {
2367       reportParseError("unexpected token in statement");
2368       return false;
2369     }
2370
2371     if (AtRegNo < 0 || AtRegNo > 31) {
2372       reportParseError("unexpected token in statement");
2373       return false;
2374     }
2375
2376     if (!Options.setATReg(AtRegNo)) {
2377       reportParseError("unexpected token in statement");
2378       return false;
2379     }
2380     getParser().Lex(); // Eat the register.
2381
2382     if (getLexer().isNot(AsmToken::EndOfStatement)) {
2383       reportParseError("unexpected token in statement");
2384       return false;
2385     }
2386     Parser.Lex(); // Consume the EndOfStatement.
2387     return false;
2388   } else {
2389     reportParseError("unexpected token in statement");
2390     return false;
2391   }
2392 }
2393
2394 bool MipsAsmParser::parseSetReorderDirective() {
2395   Parser.Lex();
2396   // If this is not the end of the statement, report an error.
2397   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2398     reportParseError("unexpected token in statement");
2399     return false;
2400   }
2401   Options.setReorder();
2402   getTargetStreamer().emitDirectiveSetReorder();
2403   Parser.Lex(); // Consume the EndOfStatement.
2404   return false;
2405 }
2406
2407 bool MipsAsmParser::parseSetNoReorderDirective() {
2408   Parser.Lex();
2409   // If this is not the end of the statement, report an error.
2410   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2411     reportParseError("unexpected token in statement");
2412     return false;
2413   }
2414   Options.setNoreorder();
2415   getTargetStreamer().emitDirectiveSetNoReorder();
2416   Parser.Lex(); // Consume the EndOfStatement.
2417   return false;
2418 }
2419
2420 bool MipsAsmParser::parseSetMacroDirective() {
2421   Parser.Lex();
2422   // If this is not the end of the statement, report an error.
2423   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2424     reportParseError("unexpected token in statement");
2425     return false;
2426   }
2427   Options.setMacro();
2428   Parser.Lex(); // Consume the EndOfStatement.
2429   return false;
2430 }
2431
2432 bool MipsAsmParser::parseSetNoMacroDirective() {
2433   Parser.Lex();
2434   // If this is not the end of the statement, report an error.
2435   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2436     reportParseError("`noreorder' must be set before `nomacro'");
2437     return false;
2438   }
2439   if (Options.isReorder()) {
2440     reportParseError("`noreorder' must be set before `nomacro'");
2441     return false;
2442   }
2443   Options.setNomacro();
2444   Parser.Lex(); // Consume the EndOfStatement.
2445   return false;
2446 }
2447
2448 bool MipsAsmParser::parseSetNoMips16Directive() {
2449   Parser.Lex();
2450   // If this is not the end of the statement, report an error.
2451   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2452     reportParseError("unexpected token in statement");
2453     return false;
2454   }
2455   // For now do nothing.
2456   Parser.Lex(); // Consume the EndOfStatement.
2457   return false;
2458 }
2459
2460 bool MipsAsmParser::parseSetAssignment() {
2461   StringRef Name;
2462   const MCExpr *Value;
2463
2464   if (Parser.parseIdentifier(Name))
2465     reportParseError("expected identifier after .set");
2466
2467   if (getLexer().isNot(AsmToken::Comma))
2468     return reportParseError("unexpected token in .set directive");
2469   Lex(); // Eat comma
2470
2471   if (Parser.parseExpression(Value))
2472     return reportParseError("expected valid expression after comma");
2473
2474   // Check if the Name already exists as a symbol.
2475   MCSymbol *Sym = getContext().LookupSymbol(Name);
2476   if (Sym)
2477     return reportParseError("symbol already defined");
2478   Sym = getContext().GetOrCreateSymbol(Name);
2479   Sym->setVariableValue(Value);
2480
2481   return false;
2482 }
2483
2484 bool MipsAsmParser::parseSetFeature(uint64_t Feature) {
2485   Parser.Lex();
2486   if (getLexer().isNot(AsmToken::EndOfStatement))
2487     return reportParseError("unexpected token in .set directive");
2488
2489   switch(Feature) {
2490     default: llvm_unreachable("Unimplemented feature");
2491     case Mips::FeatureDSP:
2492       setFeatureBits(Mips::FeatureDSP, "dsp");
2493       getTargetStreamer().emitDirectiveSetDsp();
2494     break;
2495     case Mips::FeatureMicroMips:
2496       getTargetStreamer().emitDirectiveSetMicroMips();
2497     break;
2498     case Mips::FeatureMips16:
2499       getTargetStreamer().emitDirectiveSetMips16();
2500     break;
2501     case Mips::FeatureMips32r2:
2502       setFeatureBits(Mips::FeatureMips32r2, "mips32r2");
2503       getTargetStreamer().emitDirectiveSetMips32R2();
2504     break;
2505     case Mips::FeatureMips64:
2506       setFeatureBits(Mips::FeatureMips64, "mips64");
2507       getTargetStreamer().emitDirectiveSetMips64();
2508     break;
2509     case Mips::FeatureMips64r2:
2510       setFeatureBits(Mips::FeatureMips64r2, "mips64r2");
2511       getTargetStreamer().emitDirectiveSetMips64R2();
2512     break;
2513   }
2514   return false;
2515 }
2516
2517 bool MipsAsmParser::parseRegister(unsigned &RegNum) {
2518   if (!getLexer().is(AsmToken::Dollar))
2519     return false;
2520
2521   Parser.Lex();
2522
2523   const AsmToken &Reg = Parser.getTok();
2524   if (Reg.is(AsmToken::Identifier)) {
2525     RegNum = matchCPURegisterName(Reg.getIdentifier());
2526   } else if (Reg.is(AsmToken::Integer)) {
2527     RegNum = Reg.getIntVal();
2528   } else {
2529     return false;
2530   }
2531
2532   Parser.Lex();
2533   return true;
2534 }
2535
2536 bool MipsAsmParser::eatComma(StringRef ErrorStr) {
2537   if (getLexer().isNot(AsmToken::Comma)) {
2538     SMLoc Loc = getLexer().getLoc();
2539     Parser.eatToEndOfStatement();
2540     return Error(Loc, ErrorStr);
2541   }
2542
2543   Parser.Lex();  // Eat the comma.
2544   return true;
2545 }
2546
2547 bool MipsAsmParser::parseDirectiveCPSetup() {
2548   unsigned FuncReg;
2549   unsigned Save;
2550   bool SaveIsReg = true;
2551
2552   if (!parseRegister(FuncReg))
2553     return reportParseError("expected register containing function address");
2554   FuncReg = getGPR(FuncReg);
2555
2556   if (!eatComma("expected comma parsing directive"))
2557     return true;
2558
2559   if (!parseRegister(Save)) {
2560     const AsmToken &Tok = Parser.getTok();
2561     if (Tok.is(AsmToken::Integer)) {
2562       Save = Tok.getIntVal();
2563       SaveIsReg = false;
2564       Parser.Lex();
2565     } else
2566       return reportParseError("expected save register or stack offset");
2567   } else
2568     Save = getGPR(Save);
2569
2570   if (!eatComma("expected comma parsing directive"))
2571     return true;
2572
2573   StringRef Name;
2574   if (Parser.parseIdentifier(Name))
2575     reportParseError("expected identifier");
2576   MCSymbol *Sym = getContext().GetOrCreateSymbol(Name);
2577   unsigned GPReg = getGPR(matchCPURegisterName("gp"));
2578
2579   // FIXME: The code below this point should be in the TargetStreamers.
2580   // Only N32 and N64 emit anything for .cpsetup
2581   // FIXME: We should only emit something for PIC mode too.
2582   if (!isN32() && !isN64())
2583     return false;
2584
2585   MCStreamer &TS = getStreamer();
2586   MCInst Inst;
2587   // Either store the old $gp in a register or on the stack
2588   if (SaveIsReg) {
2589     // move $save, $gpreg
2590     Inst.setOpcode(Mips::DADDu);
2591     Inst.addOperand(MCOperand::CreateReg(Save));
2592     Inst.addOperand(MCOperand::CreateReg(GPReg));
2593     Inst.addOperand(MCOperand::CreateReg(getGPR(0)));
2594   } else {
2595     // sd $gpreg, offset($sp)
2596     Inst.setOpcode(Mips::SD);
2597     Inst.addOperand(MCOperand::CreateReg(GPReg));
2598     Inst.addOperand(MCOperand::CreateReg(getGPR(matchCPURegisterName("sp"))));
2599     Inst.addOperand(MCOperand::CreateImm(Save));
2600   }
2601   TS.EmitInstruction(Inst, STI);
2602   Inst.clear();
2603
2604   const MCSymbolRefExpr *HiExpr = MCSymbolRefExpr::Create(
2605       Sym->getName(), MCSymbolRefExpr::VK_Mips_GPOFF_HI,
2606       getContext());
2607   const MCSymbolRefExpr *LoExpr = MCSymbolRefExpr::Create(
2608       Sym->getName(), MCSymbolRefExpr::VK_Mips_GPOFF_LO,
2609       getContext());
2610   // lui $gp, %hi(%neg(%gp_rel(funcSym)))
2611   Inst.setOpcode(Mips::LUi);
2612   Inst.addOperand(MCOperand::CreateReg(GPReg));
2613   Inst.addOperand(MCOperand::CreateExpr(HiExpr));
2614   TS.EmitInstruction(Inst, STI);
2615   Inst.clear();
2616
2617   // addiu  $gp, $gp, %lo(%neg(%gp_rel(funcSym)))
2618   Inst.setOpcode(Mips::ADDiu);
2619   Inst.addOperand(MCOperand::CreateReg(GPReg));
2620   Inst.addOperand(MCOperand::CreateReg(GPReg));
2621   Inst.addOperand(MCOperand::CreateExpr(LoExpr));
2622   TS.EmitInstruction(Inst, STI);
2623   Inst.clear();
2624
2625   // daddu  $gp, $gp, $funcreg
2626   Inst.setOpcode(Mips::DADDu);
2627   Inst.addOperand(MCOperand::CreateReg(GPReg));
2628   Inst.addOperand(MCOperand::CreateReg(GPReg));
2629   Inst.addOperand(MCOperand::CreateReg(FuncReg));
2630   TS.EmitInstruction(Inst, STI);
2631   return false;
2632 }
2633
2634 bool MipsAsmParser::parseDirectiveSet() {
2635
2636   // Get the next token.
2637   const AsmToken &Tok = Parser.getTok();
2638
2639   if (Tok.getString() == "noat") {
2640     return parseSetNoAtDirective();
2641   } else if (Tok.getString() == "at") {
2642     return parseSetAtDirective();
2643   } else if (Tok.getString() == "reorder") {
2644     return parseSetReorderDirective();
2645   } else if (Tok.getString() == "noreorder") {
2646     return parseSetNoReorderDirective();
2647   } else if (Tok.getString() == "macro") {
2648     return parseSetMacroDirective();
2649   } else if (Tok.getString() == "nomacro") {
2650     return parseSetNoMacroDirective();
2651   } else if (Tok.getString() == "mips16") {
2652     return parseSetFeature(Mips::FeatureMips16);
2653   } else if (Tok.getString() == "nomips16") {
2654     return parseSetNoMips16Directive();
2655   } else if (Tok.getString() == "nomicromips") {
2656     getTargetStreamer().emitDirectiveSetNoMicroMips();
2657     Parser.eatToEndOfStatement();
2658     return false;
2659   } else if (Tok.getString() == "micromips") {
2660       return parseSetFeature(Mips::FeatureMicroMips);
2661   } else if (Tok.getString() == "mips32r2") {
2662       return parseSetFeature(Mips::FeatureMips32r2);
2663   } else if (Tok.getString() == "mips64") {
2664       return parseSetFeature(Mips::FeatureMips64);
2665   } else if (Tok.getString() == "mips64r2") {
2666       return parseSetFeature(Mips::FeatureMips64r2);
2667   } else if (Tok.getString() == "dsp") {
2668       return parseSetFeature(Mips::FeatureDSP);
2669   } else {
2670     // It is just an identifier, look for an assignment.
2671     parseSetAssignment();
2672     return false;
2673   }
2674
2675   return true;
2676 }
2677
2678 /// parseDataDirective
2679 ///  ::= .word [ expression (, expression)* ]
2680 bool MipsAsmParser::parseDataDirective(unsigned Size, SMLoc L) {
2681   if (getLexer().isNot(AsmToken::EndOfStatement)) {
2682     for (;;) {
2683       const MCExpr *Value;
2684       if (getParser().parseExpression(Value))
2685         return true;
2686
2687       getParser().getStreamer().EmitValue(Value, Size);
2688
2689       if (getLexer().is(AsmToken::EndOfStatement))
2690         break;
2691
2692       // FIXME: Improve diagnostic.
2693       if (getLexer().isNot(AsmToken::Comma))
2694         return Error(L, "unexpected token in directive");
2695       Parser.Lex();
2696     }
2697   }
2698
2699   Parser.Lex();
2700   return false;
2701 }
2702
2703 /// parseDirectiveGpWord
2704 ///  ::= .gpword local_sym
2705 bool MipsAsmParser::parseDirectiveGpWord() {
2706   const MCExpr *Value;
2707   // EmitGPRel32Value requires an expression, so we are using base class
2708   // method to evaluate the expression.
2709   if (getParser().parseExpression(Value))
2710     return true;
2711   getParser().getStreamer().EmitGPRel32Value(Value);
2712
2713   if (getLexer().isNot(AsmToken::EndOfStatement))
2714     return Error(getLexer().getLoc(), "unexpected token in directive");
2715   Parser.Lex(); // Eat EndOfStatement token.
2716   return false;
2717 }
2718
2719 /// parseDirectiveGpdWord
2720 ///  ::= .gpdword local_sym
2721 bool MipsAsmParser::parseDirectiveGpdWord() {
2722   const MCExpr *Value;
2723   // EmitGPRel64Value requires an expression, so we are using base class
2724   // method to evaluate the expression.
2725   if (getParser().parseExpression(Value))
2726     return true;
2727   getParser().getStreamer().EmitGPRel64Value(Value);
2728
2729   if (getLexer().isNot(AsmToken::EndOfStatement))
2730     return Error(getLexer().getLoc(), "unexpected token in directive");
2731   Parser.Lex(); // Eat EndOfStatement token.
2732   return false;
2733 }
2734
2735 bool MipsAsmParser::parseDirectiveOption() {
2736   // Get the option token.
2737   AsmToken Tok = Parser.getTok();
2738   // At the moment only identifiers are supported.
2739   if (Tok.isNot(AsmToken::Identifier)) {
2740     Error(Parser.getTok().getLoc(), "unexpected token in .option directive");
2741     Parser.eatToEndOfStatement();
2742     return false;
2743   }
2744
2745   StringRef Option = Tok.getIdentifier();
2746
2747   if (Option == "pic0") {
2748     getTargetStreamer().emitDirectiveOptionPic0();
2749     Parser.Lex();
2750     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
2751       Error(Parser.getTok().getLoc(),
2752             "unexpected token in .option pic0 directive");
2753       Parser.eatToEndOfStatement();
2754     }
2755     return false;
2756   }
2757
2758   if (Option == "pic2") {
2759     getTargetStreamer().emitDirectiveOptionPic2();
2760     Parser.Lex();
2761     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
2762       Error(Parser.getTok().getLoc(),
2763             "unexpected token in .option pic2 directive");
2764       Parser.eatToEndOfStatement();
2765     }
2766     return false;
2767   }
2768
2769   // Unknown option.
2770   Warning(Parser.getTok().getLoc(), "unknown option in .option directive");
2771   Parser.eatToEndOfStatement();
2772   return false;
2773 }
2774
2775 bool MipsAsmParser::ParseDirective(AsmToken DirectiveID) {
2776   StringRef IDVal = DirectiveID.getString();
2777
2778   if (IDVal == ".dword") {
2779     parseDataDirective(8, DirectiveID.getLoc());
2780     return false;
2781   }
2782
2783   if (IDVal == ".ent") {
2784     // Ignore this directive for now.
2785     Parser.Lex();
2786     return false;
2787   }
2788
2789   if (IDVal == ".end") {
2790     // Ignore this directive for now.
2791     Parser.Lex();
2792     return false;
2793   }
2794
2795   if (IDVal == ".frame") {
2796     // Ignore this directive for now.
2797     Parser.eatToEndOfStatement();
2798     return false;
2799   }
2800
2801   if (IDVal == ".set") {
2802     return parseDirectiveSet();
2803   }
2804
2805   if (IDVal == ".fmask") {
2806     // Ignore this directive for now.
2807     Parser.eatToEndOfStatement();
2808     return false;
2809   }
2810
2811   if (IDVal == ".mask") {
2812     // Ignore this directive for now.
2813     Parser.eatToEndOfStatement();
2814     return false;
2815   }
2816
2817   if (IDVal == ".gpword") {
2818     parseDirectiveGpWord();
2819     return false;
2820   }
2821
2822   if (IDVal == ".gpdword") {
2823     parseDirectiveGpdWord();
2824     return false;
2825   }
2826
2827   if (IDVal == ".word") {
2828     parseDataDirective(4, DirectiveID.getLoc());
2829     return false;
2830   }
2831
2832   if (IDVal == ".option")
2833     return parseDirectiveOption();
2834
2835   if (IDVal == ".abicalls") {
2836     getTargetStreamer().emitDirectiveAbiCalls();
2837     if (Parser.getTok().isNot(AsmToken::EndOfStatement)) {
2838       Error(Parser.getTok().getLoc(), "unexpected token in directive");
2839       // Clear line
2840       Parser.eatToEndOfStatement();
2841     }
2842     return false;
2843   }
2844
2845   if (IDVal == ".cpsetup")
2846     return parseDirectiveCPSetup();
2847
2848   return true;
2849 }
2850
2851 extern "C" void LLVMInitializeMipsAsmParser() {
2852   RegisterMCAsmParser<MipsAsmParser> X(TheMipsTarget);
2853   RegisterMCAsmParser<MipsAsmParser> Y(TheMipselTarget);
2854   RegisterMCAsmParser<MipsAsmParser> A(TheMips64Target);
2855   RegisterMCAsmParser<MipsAsmParser> B(TheMips64elTarget);
2856 }
2857
2858 #define GET_REGISTER_MATCHER
2859 #define GET_MATCHER_IMPLEMENTATION
2860 #include "MipsGenAsmMatcher.inc"