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