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