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