lib/Target/Mips/AsmParser/MipsAsmParser.cpp

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