lib/Target/Mips/AsmParser/MipsAsmParser.cpp

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