Prune utf8 chars in comments.
[oota-llvm.git] / lib / Target / Mips / AsmParser / MipsAsmParser.cpp
1 //===-- MipsAsmParser.cpp - Parse Mips assembly to MCInst instructions ----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "MCTargetDesc/MipsABIInfo.h"
11 #include "MCTargetDesc/MipsMCExpr.h"
12 #include "MCTargetDesc/MipsMCTargetDesc.h"
13 #include "MipsRegisterInfo.h"
14 #include "MipsTargetObjectFile.h"
15 #include "MipsTargetStreamer.h"
16 #include "llvm/ADT/APInt.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCExpr.h"
21 #include "llvm/MC/MCInst.h"
22 #include "llvm/MC/MCInstBuilder.h"
23 #include "llvm/MC/MCParser/MCAsmLexer.h"
24 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
25 #include "llvm/MC/MCStreamer.h"
26 #include "llvm/MC/MCSubtargetInfo.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/MC/MCTargetAsmParser.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/MathExtras.h"
31 #include "llvm/Support/SourceMgr.h"
32 #include "llvm/Support/TargetRegistry.h"
33 #include "llvm/Support/raw_ostream.h"
34 #include <memory>
35
36 using namespace llvm;
37
38 #define DEBUG_TYPE "mips-asm-parser"
39
40 namespace llvm {
41 class MCInstrInfo;
42 }
43
44 namespace {
45 class MipsAssemblerOptions {
46 public:
47   MipsAssemblerOptions(const FeatureBitset &Features_) :
48     ATReg(1), Reorder(true), Macro(true), Features(Features_) {}
49
50   MipsAssemblerOptions(const MipsAssemblerOptions *Opts) {
51     ATReg = Opts->getATRegIndex();
52     Reorder = Opts->isReorder();
53     Macro = Opts->isMacro();
54     Features = Opts->getFeatures();
55   }
56
57   unsigned getATRegIndex() const { return ATReg; }
58   bool setATRegIndex(unsigned Reg) {
59     if (Reg > 31)
60       return false;
61
62     ATReg = Reg;
63     return true;
64   }
65
66   bool isReorder() const { return Reorder; }
67   void setReorder() { Reorder = true; }
68   void setNoReorder() { Reorder = false; }
69
70   bool isMacro() const { return Macro; }
71   void setMacro() { Macro = true; }
72   void setNoMacro() { Macro = false; }
73
74   const FeatureBitset &getFeatures() const { return Features; }
75   void setFeatures(const FeatureBitset &Features_) { Features = Features_; }
76
77   // Set of features that are either architecture features or referenced
78   // by them (e.g.: FeatureNaN2008 implied by FeatureMips32r6).
79   // The full table can be found in MipsGenSubtargetInfo.inc (MipsFeatureKV[]).
80   // The reason we need this mask is explained in the selectArch function.
81   // FIXME: Ideally we would like TableGen to generate this information.
82   static const FeatureBitset AllArchRelatedMask;
83
84 private:
85   unsigned ATReg;
86   bool Reorder;
87   bool Macro;
88   FeatureBitset Features;
89 };
90 }
91
92 const FeatureBitset MipsAssemblerOptions::AllArchRelatedMask = {
93     Mips::FeatureMips1, Mips::FeatureMips2, Mips::FeatureMips3,
94     Mips::FeatureMips3_32, Mips::FeatureMips3_32r2, Mips::FeatureMips4,
95     Mips::FeatureMips4_32, Mips::FeatureMips4_32r2, Mips::FeatureMips5,
96     Mips::FeatureMips5_32r2, Mips::FeatureMips32, Mips::FeatureMips32r2,
97     Mips::FeatureMips32r3, Mips::FeatureMips32r5, Mips::FeatureMips32r6,
98     Mips::FeatureMips64, Mips::FeatureMips64r2, Mips::FeatureMips64r3,
99     Mips::FeatureMips64r5, Mips::FeatureMips64r6, Mips::FeatureCnMips,
100     Mips::FeatureFP64Bit, Mips::FeatureGP64Bit, Mips::FeatureNaN2008
101 };
102
103 namespace {
104 class MipsAsmParser : public MCTargetAsmParser {
105   MipsTargetStreamer &getTargetStreamer() {
106     MCTargetStreamer &TS = *getParser().getStreamer().getTargetStreamer();
107     return static_cast<MipsTargetStreamer &>(TS);
108   }
109
110   MCSubtargetInfo &STI;
111   MipsABIInfo ABI;
112   SmallVector<std::unique_ptr<MipsAssemblerOptions>, 2> AssemblerOptions;
113   MCSymbol *CurrentFn; // Pointer to the function being parsed. It may be a
114                        // nullptr, which indicates that no function is currently
115                        // selected. This usually happens after an '.end func'
116                        // directive.
117   bool IsLittleEndian;
118   bool IsPicEnabled;
119
120   // Print a warning along with its fix-it message at the given range.
121   void printWarningWithFixIt(const Twine &Msg, const Twine &FixMsg,
122                              SMRange Range, bool ShowColors = true);
123
124 #define GET_ASSEMBLER_HEADER
125 #include "MipsGenAsmMatcher.inc"
126
127   unsigned checkTargetMatchPredicate(MCInst &Inst) override;
128
129   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
130                                OperandVector &Operands, MCStreamer &Out,
131                                uint64_t &ErrorInfo,
132                                bool MatchingInlineAsm) override;
133
134   /// Parse a register as used in CFI directives
135   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
136
137   bool parseParenSuffix(StringRef Name, OperandVector &Operands);
138
139   bool parseBracketSuffix(StringRef Name, OperandVector &Operands);
140
141   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
142                         SMLoc NameLoc, OperandVector &Operands) override;
143
144   bool ParseDirective(AsmToken DirectiveID) override;
145
146   MipsAsmParser::OperandMatchResultTy parseMemOperand(OperandVector &Operands);
147
148   MipsAsmParser::OperandMatchResultTy
149   matchAnyRegisterNameWithoutDollar(OperandVector &Operands,
150                                     StringRef Identifier, SMLoc S);
151
152   MipsAsmParser::OperandMatchResultTy
153   matchAnyRegisterWithoutDollar(OperandVector &Operands, SMLoc S);
154
155   MipsAsmParser::OperandMatchResultTy parseAnyRegister(OperandVector &Operands);
156
157   MipsAsmParser::OperandMatchResultTy parseImm(OperandVector &Operands);
158
159   MipsAsmParser::OperandMatchResultTy parseJumpTarget(OperandVector &Operands);
160
161   MipsAsmParser::OperandMatchResultTy parseInvNum(OperandVector &Operands);
162
163   MipsAsmParser::OperandMatchResultTy parseLSAImm(OperandVector &Operands);
164
165   MipsAsmParser::OperandMatchResultTy
166   parseRegisterPair (OperandVector &Operands);
167
168   MipsAsmParser::OperandMatchResultTy
169   parseMovePRegPair(OperandVector &Operands);
170
171   MipsAsmParser::OperandMatchResultTy
172   parseRegisterList (OperandVector  &Operands);
173
174   bool searchSymbolAlias(OperandVector &Operands);
175
176   bool parseOperand(OperandVector &, StringRef Mnemonic);
177
178   bool needsExpansion(MCInst &Inst);
179
180   // Expands assembly pseudo instructions.
181   // Returns false on success, true otherwise.
182   bool expandInstruction(MCInst &Inst, SMLoc IDLoc,
183                          SmallVectorImpl<MCInst> &Instructions);
184
185   bool expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
186                          SmallVectorImpl<MCInst> &Instructions);
187
188   bool loadImmediate(int64_t ImmValue, unsigned DstReg, unsigned SrcReg,
189                      bool Is32BitImm, bool IsAddress, SMLoc IDLoc,
190                      SmallVectorImpl<MCInst> &Instructions);
191
192   bool loadAndAddSymbolAddress(const MCExpr *SymExpr, unsigned DstReg,
193                                unsigned SrcReg, bool Is32BitSym, SMLoc IDLoc,
194                                SmallVectorImpl<MCInst> &Instructions);
195
196   bool expandLoadImm(MCInst &Inst, bool Is32BitImm, SMLoc IDLoc,
197                      SmallVectorImpl<MCInst> &Instructions);
198
199   bool expandLoadAddress(unsigned DstReg, unsigned BaseReg,
200                          const MCOperand &Offset, bool Is32BitAddress,
201                          SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions);
202
203   bool expandUncondBranchMMPseudo(MCInst &Inst, SMLoc IDLoc,
204                                   SmallVectorImpl<MCInst> &Instructions);
205
206   void expandMemInst(MCInst &Inst, SMLoc IDLoc,
207                      SmallVectorImpl<MCInst> &Instructions, bool isLoad,
208                      bool isImmOpnd);
209
210   bool expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc,
211                                SmallVectorImpl<MCInst> &Instructions);
212
213   bool expandBranchImm(MCInst &Inst, SMLoc IDLoc,
214                        SmallVectorImpl<MCInst> &Instructions);
215
216   bool expandCondBranches(MCInst &Inst, SMLoc IDLoc,
217                           SmallVectorImpl<MCInst> &Instructions);
218
219   bool expandDiv(MCInst &Inst, SMLoc IDLoc,
220                  SmallVectorImpl<MCInst> &Instructions, const bool IsMips64,
221                  const bool Signed);
222
223   bool expandUlhu(MCInst &Inst, SMLoc IDLoc,
224                   SmallVectorImpl<MCInst> &Instructions);
225
226   bool expandUlw(MCInst &Inst, SMLoc IDLoc,
227                  SmallVectorImpl<MCInst> &Instructions);
228
229   void createNop(bool hasShortDelaySlot, SMLoc IDLoc,
230                  SmallVectorImpl<MCInst> &Instructions);
231
232   void createAddu(unsigned DstReg, unsigned SrcReg, unsigned TrgReg,
233                   bool Is64Bit, SmallVectorImpl<MCInst> &Instructions);
234
235   bool reportParseError(Twine ErrorMsg);
236   bool reportParseError(SMLoc Loc, Twine ErrorMsg);
237
238   bool parseMemOffset(const MCExpr *&Res, bool isParenExpr);
239   bool parseRelocOperand(const MCExpr *&Res);
240
241   const MCExpr *evaluateRelocExpr(const MCExpr *Expr, StringRef RelocStr);
242
243   bool isEvaluated(const MCExpr *Expr);
244   bool parseSetMips0Directive();
245   bool parseSetArchDirective();
246   bool parseSetFeature(uint64_t Feature);
247   bool parseDirectiveCpLoad(SMLoc Loc);
248   bool parseDirectiveCPSetup();
249   bool parseDirectiveNaN();
250   bool parseDirectiveSet();
251   bool parseDirectiveOption();
252   bool parseInsnDirective();
253
254   bool parseSetAtDirective();
255   bool parseSetNoAtDirective();
256   bool parseSetMacroDirective();
257   bool parseSetNoMacroDirective();
258   bool parseSetMsaDirective();
259   bool parseSetNoMsaDirective();
260   bool parseSetNoDspDirective();
261   bool parseSetReorderDirective();
262   bool parseSetNoReorderDirective();
263   bool parseSetMips16Directive();
264   bool parseSetNoMips16Directive();
265   bool parseSetFpDirective();
266   bool parseSetOddSPRegDirective();
267   bool parseSetNoOddSPRegDirective();
268   bool parseSetPopDirective();
269   bool parseSetPushDirective();
270   bool parseSetSoftFloatDirective();
271   bool parseSetHardFloatDirective();
272
273   bool parseSetAssignment();
274
275   bool parseDataDirective(unsigned Size, SMLoc L);
276   bool parseDirectiveGpWord();
277   bool parseDirectiveGpDWord();
278   bool parseDirectiveModule();
279   bool parseDirectiveModuleFP();
280   bool parseFpABIValue(MipsABIFlagsSection::FpABIKind &FpABI,
281                        StringRef Directive);
282
283   bool parseInternalDirectiveReallowModule();
284
285   MCSymbolRefExpr::VariantKind getVariantKind(StringRef Symbol);
286
287   bool eatComma(StringRef ErrorStr);
288
289   int matchCPURegisterName(StringRef Symbol);
290
291   int matchHWRegsRegisterName(StringRef Symbol);
292
293   int matchRegisterByNumber(unsigned RegNum, unsigned RegClass);
294
295   int matchFPURegisterName(StringRef Name);
296
297   int matchFCCRegisterName(StringRef Name);
298
299   int matchACRegisterName(StringRef Name);
300
301   int matchMSA128RegisterName(StringRef Name);
302
303   int matchMSA128CtrlRegisterName(StringRef Name);
304
305   unsigned getReg(int RC, int RegNo);
306
307   unsigned getGPR(int RegNo);
308
309   /// Returns the internal register number for the current AT. Also checks if
310   /// the current AT is unavailable (set to $0) and gives an error if it is.
311   /// This should be used in pseudo-instruction expansions which need AT.
312   unsigned getATReg(SMLoc Loc);
313
314   bool processInstruction(MCInst &Inst, SMLoc IDLoc,
315                           SmallVectorImpl<MCInst> &Instructions);
316
317   // Helper function that checks if the value of a vector index is within the
318   // boundaries of accepted values for each RegisterKind
319   // Example: INSERT.B $w0[n], $1 => 16 > n >= 0
320   bool validateMSAIndex(int Val, int RegKind);
321
322   // Selects a new architecture by updating the FeatureBits with the necessary
323   // info including implied dependencies.
324   // Internally, it clears all the feature bits related to *any* architecture
325   // and selects the new one using the ToggleFeature functionality of the
326   // MCSubtargetInfo object that handles implied dependencies. The reason we
327   // clear all the arch related bits manually is because ToggleFeature only
328   // clears the features that imply the feature being cleared and not the
329   // features implied by the feature being cleared. This is easier to see
330   // with an example:
331   //  --------------------------------------------------
332   // | Feature         | Implies                        |
333   // | -------------------------------------------------|
334   // | FeatureMips1    | None                           |
335   // | FeatureMips2    | FeatureMips1                   |
336   // | FeatureMips3    | FeatureMips2 | FeatureMipsGP64 |
337   // | FeatureMips4    | FeatureMips3                   |
338   // | ...             |                                |
339   //  --------------------------------------------------
340   //
341   // Setting Mips3 is equivalent to set: (FeatureMips3 | FeatureMips2 |
342   // FeatureMipsGP64 | FeatureMips1)
343   // Clearing Mips3 is equivalent to clear (FeatureMips3 | FeatureMips4).
344   void selectArch(StringRef ArchFeature) {
345     FeatureBitset FeatureBits = STI.getFeatureBits();
346     FeatureBits &= ~MipsAssemblerOptions::AllArchRelatedMask;
347     STI.setFeatureBits(FeatureBits);
348     setAvailableFeatures(
349         ComputeAvailableFeatures(STI.ToggleFeature(ArchFeature)));
350     AssemblerOptions.back()->setFeatures(STI.getFeatureBits());
351   }
352
353   void setFeatureBits(uint64_t Feature, StringRef FeatureString) {
354     if (!(STI.getFeatureBits()[Feature])) {
355       setAvailableFeatures(
356           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
357       AssemblerOptions.back()->setFeatures(STI.getFeatureBits());
358     }
359   }
360
361   void clearFeatureBits(uint64_t Feature, StringRef FeatureString) {
362     if (STI.getFeatureBits()[Feature]) {
363       setAvailableFeatures(
364           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
365       AssemblerOptions.back()->setFeatures(STI.getFeatureBits());
366     }
367   }
368
369   void setModuleFeatureBits(uint64_t Feature, StringRef FeatureString) {
370     setFeatureBits(Feature, FeatureString);
371     AssemblerOptions.front()->setFeatures(STI.getFeatureBits());
372   }
373
374   void clearModuleFeatureBits(uint64_t Feature, StringRef FeatureString) {
375     clearFeatureBits(Feature, FeatureString);
376     AssemblerOptions.front()->setFeatures(STI.getFeatureBits());
377   }
378
379 public:
380   enum MipsMatchResultTy {
381     Match_RequiresDifferentSrcAndDst = FIRST_TARGET_MATCH_RESULT_TY
382 #define GET_OPERAND_DIAGNOSTIC_TYPES
383 #include "MipsGenAsmMatcher.inc"
384 #undef GET_OPERAND_DIAGNOSTIC_TYPES
385
386   };
387
388   MipsAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
389                 const MCInstrInfo &MII, const MCTargetOptions &Options)
390       : MCTargetAsmParser(Options), STI(sti),
391         ABI(MipsABIInfo::computeTargetABI(Triple(sti.getTargetTriple()),
392                                           sti.getCPU(), Options)) {
393     MCAsmParserExtension::Initialize(parser);
394
395     parser.addAliasForDirective(".asciiz", ".asciz");
396
397     // Initialize the set of available features.
398     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
399
400     // Remember the initial assembler options. The user can not modify these.
401     AssemblerOptions.push_back(
402         llvm::make_unique<MipsAssemblerOptions>(STI.getFeatureBits()));
403
404     // Create an assembler options environment for the user to modify.
405     AssemblerOptions.push_back(
406         llvm::make_unique<MipsAssemblerOptions>(STI.getFeatureBits()));
407
408     getTargetStreamer().updateABIInfo(*this);
409
410     if (!isABI_O32() && !useOddSPReg() != 0)
411       report_fatal_error("-mno-odd-spreg requires the O32 ABI");
412
413     CurrentFn = nullptr;
414
415     IsPicEnabled =
416         (getContext().getObjectFileInfo()->getRelocM() == Reloc::PIC_);
417
418     Triple TheTriple(sti.getTargetTriple());
419     if ((TheTriple.getArch() == Triple::mips) ||
420         (TheTriple.getArch() == Triple::mips64))
421       IsLittleEndian = false;
422     else
423       IsLittleEndian = true;
424   }
425
426   /// True if all of $fcc0 - $fcc7 exist for the current ISA.
427   bool hasEightFccRegisters() const { return hasMips4() || hasMips32(); }
428
429   bool isGP64bit() const { return STI.getFeatureBits()[Mips::FeatureGP64Bit]; }
430   bool isFP64bit() const { return STI.getFeatureBits()[Mips::FeatureFP64Bit]; }
431   const MipsABIInfo &getABI() const { return ABI; }
432   bool isABI_N32() const { return ABI.IsN32(); }
433   bool isABI_N64() const { return ABI.IsN64(); }
434   bool isABI_O32() const { return ABI.IsO32(); }
435   bool isABI_FPXX() const { return STI.getFeatureBits()[Mips::FeatureFPXX]; }
436
437   bool useOddSPReg() const {
438     return !(STI.getFeatureBits()[Mips::FeatureNoOddSPReg]);
439   }
440
441   bool inMicroMipsMode() const {
442     return STI.getFeatureBits()[Mips::FeatureMicroMips];
443   }
444   bool hasMips1() const { return STI.getFeatureBits()[Mips::FeatureMips1]; }
445   bool hasMips2() const { return STI.getFeatureBits()[Mips::FeatureMips2]; }
446   bool hasMips3() const { return STI.getFeatureBits()[Mips::FeatureMips3]; }
447   bool hasMips4() const { return STI.getFeatureBits()[Mips::FeatureMips4]; }
448   bool hasMips5() const { return STI.getFeatureBits()[Mips::FeatureMips5]; }
449   bool hasMips32() const {
450     return STI.getFeatureBits()[Mips::FeatureMips32];
451   }
452   bool hasMips64() const {
453     return STI.getFeatureBits()[Mips::FeatureMips64];
454   }
455   bool hasMips32r2() const {
456     return STI.getFeatureBits()[Mips::FeatureMips32r2];
457   }
458   bool hasMips64r2() const {
459     return STI.getFeatureBits()[Mips::FeatureMips64r2];
460   }
461   bool hasMips32r3() const {
462     return (STI.getFeatureBits()[Mips::FeatureMips32r3]);
463   }
464   bool hasMips64r3() const {
465     return (STI.getFeatureBits()[Mips::FeatureMips64r3]);
466   }
467   bool hasMips32r5() const {
468     return (STI.getFeatureBits()[Mips::FeatureMips32r5]);
469   }
470   bool hasMips64r5() const {
471     return (STI.getFeatureBits()[Mips::FeatureMips64r5]);
472   }
473   bool hasMips32r6() const {
474     return STI.getFeatureBits()[Mips::FeatureMips32r6];
475   }
476   bool hasMips64r6() const {
477     return STI.getFeatureBits()[Mips::FeatureMips64r6];
478   }
479
480   bool hasDSP() const { return STI.getFeatureBits()[Mips::FeatureDSP]; }
481   bool hasDSPR2() const { return STI.getFeatureBits()[Mips::FeatureDSPR2]; }
482   bool hasMSA() const { return STI.getFeatureBits()[Mips::FeatureMSA]; }
483   bool hasCnMips() const {
484     return (STI.getFeatureBits()[Mips::FeatureCnMips]);
485   }
486
487   bool inPicMode() {
488     return IsPicEnabled;
489   }
490
491   bool inMips16Mode() const {
492     return STI.getFeatureBits()[Mips::FeatureMips16];
493   }
494
495   bool useTraps() const {
496     return STI.getFeatureBits()[Mips::FeatureUseTCCInDIV];
497   }
498
499   bool useSoftFloat() const {
500     return STI.getFeatureBits()[Mips::FeatureSoftFloat];
501   }
502
503   /// Warn if RegIndex is the same as the current AT.
504   void warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc);
505
506   void warnIfNoMacro(SMLoc Loc);
507
508   bool isLittle() const { return IsLittleEndian; }
509 };
510 }
511
512 namespace {
513
514 /// MipsOperand - Instances of this class represent a parsed Mips machine
515 /// instruction.
516 class MipsOperand : public MCParsedAsmOperand {
517 public:
518   /// Broad categories of register classes
519   /// The exact class is finalized by the render method.
520   enum RegKind {
521     RegKind_GPR = 1,      /// GPR32 and GPR64 (depending on isGP64bit())
522     RegKind_FGR = 2,      /// FGR32, FGR64, AFGR64 (depending on context and
523                           /// isFP64bit())
524     RegKind_FCC = 4,      /// FCC
525     RegKind_MSA128 = 8,   /// MSA128[BHWD] (makes no difference which)
526     RegKind_MSACtrl = 16, /// MSA control registers
527     RegKind_COP2 = 32,    /// COP2
528     RegKind_ACC = 64,     /// HI32DSP, LO32DSP, and ACC64DSP (depending on
529                           /// context).
530     RegKind_CCR = 128,    /// CCR
531     RegKind_HWRegs = 256, /// HWRegs
532     RegKind_COP3 = 512,   /// COP3
533     RegKind_COP0 = 1024,  /// COP0
534     /// Potentially any (e.g. $1)
535     RegKind_Numeric = RegKind_GPR | RegKind_FGR | RegKind_FCC | RegKind_MSA128 |
536                       RegKind_MSACtrl | RegKind_COP2 | RegKind_ACC |
537                       RegKind_CCR | RegKind_HWRegs | RegKind_COP3 | RegKind_COP0
538   };
539
540 private:
541   enum KindTy {
542     k_Immediate,     /// An immediate (possibly involving symbol references)
543     k_Memory,        /// Base + Offset Memory Address
544     k_PhysRegister,  /// A physical register from the Mips namespace
545     k_RegisterIndex, /// A register index in one or more RegKind.
546     k_Token,         /// A simple token
547     k_RegList,       /// A physical register list
548     k_RegPair        /// A pair of physical register
549   } Kind;
550
551 public:
552   MipsOperand(KindTy K, MipsAsmParser &Parser)
553       : MCParsedAsmOperand(), Kind(K), AsmParser(Parser) {}
554
555 private:
556   /// For diagnostics, and checking the assembler temporary
557   MipsAsmParser &AsmParser;
558
559   struct Token {
560     const char *Data;
561     unsigned Length;
562   };
563
564   struct PhysRegOp {
565     unsigned Num; /// Register Number
566   };
567
568   struct RegIdxOp {
569     unsigned Index; /// Index into the register class
570     RegKind Kind;   /// Bitfield of the kinds it could possibly be
571     const MCRegisterInfo *RegInfo;
572   };
573
574   struct ImmOp {
575     const MCExpr *Val;
576   };
577
578   struct MemOp {
579     MipsOperand *Base;
580     const MCExpr *Off;
581   };
582
583   struct RegListOp {
584     SmallVector<unsigned, 10> *List;
585   };
586
587   union {
588     struct Token Tok;
589     struct PhysRegOp PhysReg;
590     struct RegIdxOp RegIdx;
591     struct ImmOp Imm;
592     struct MemOp Mem;
593     struct RegListOp RegList;
594   };
595
596   SMLoc StartLoc, EndLoc;
597
598   /// Internal constructor for register kinds
599   static std::unique_ptr<MipsOperand> CreateReg(unsigned Index, RegKind RegKind,
600                                                 const MCRegisterInfo *RegInfo,
601                                                 SMLoc S, SMLoc E,
602                                                 MipsAsmParser &Parser) {
603     auto Op = make_unique<MipsOperand>(k_RegisterIndex, Parser);
604     Op->RegIdx.Index = Index;
605     Op->RegIdx.RegInfo = RegInfo;
606     Op->RegIdx.Kind = RegKind;
607     Op->StartLoc = S;
608     Op->EndLoc = E;
609     return Op;
610   }
611
612 public:
613   /// Coerce the register to GPR32 and return the real register for the current
614   /// target.
615   unsigned getGPR32Reg() const {
616     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
617     AsmParser.warnIfRegIndexIsAT(RegIdx.Index, StartLoc);
618     unsigned ClassID = Mips::GPR32RegClassID;
619     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
620   }
621
622   /// Coerce the register to GPR32 and return the real register for the current
623   /// target.
624   unsigned getGPRMM16Reg() const {
625     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
626     unsigned ClassID = Mips::GPR32RegClassID;
627     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
628   }
629
630   /// Coerce the register to GPR64 and return the real register for the current
631   /// target.
632   unsigned getGPR64Reg() const {
633     assert(isRegIdx() && (RegIdx.Kind & RegKind_GPR) && "Invalid access!");
634     unsigned ClassID = Mips::GPR64RegClassID;
635     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
636   }
637
638 private:
639   /// Coerce the register to AFGR64 and return the real register for the current
640   /// target.
641   unsigned getAFGR64Reg() const {
642     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
643     if (RegIdx.Index % 2 != 0)
644       AsmParser.Warning(StartLoc, "Float register should be even.");
645     return RegIdx.RegInfo->getRegClass(Mips::AFGR64RegClassID)
646         .getRegister(RegIdx.Index / 2);
647   }
648
649   /// Coerce the register to FGR64 and return the real register for the current
650   /// target.
651   unsigned getFGR64Reg() const {
652     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
653     return RegIdx.RegInfo->getRegClass(Mips::FGR64RegClassID)
654         .getRegister(RegIdx.Index);
655   }
656
657   /// Coerce the register to FGR32 and return the real register for the current
658   /// target.
659   unsigned getFGR32Reg() const {
660     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
661     return RegIdx.RegInfo->getRegClass(Mips::FGR32RegClassID)
662         .getRegister(RegIdx.Index);
663   }
664
665   /// Coerce the register to FGRH32 and return the real register for the current
666   /// target.
667   unsigned getFGRH32Reg() const {
668     assert(isRegIdx() && (RegIdx.Kind & RegKind_FGR) && "Invalid access!");
669     return RegIdx.RegInfo->getRegClass(Mips::FGRH32RegClassID)
670         .getRegister(RegIdx.Index);
671   }
672
673   /// Coerce the register to FCC and return the real register for the current
674   /// target.
675   unsigned getFCCReg() const {
676     assert(isRegIdx() && (RegIdx.Kind & RegKind_FCC) && "Invalid access!");
677     return RegIdx.RegInfo->getRegClass(Mips::FCCRegClassID)
678         .getRegister(RegIdx.Index);
679   }
680
681   /// Coerce the register to MSA128 and return the real register for the current
682   /// target.
683   unsigned getMSA128Reg() const {
684     assert(isRegIdx() && (RegIdx.Kind & RegKind_MSA128) && "Invalid access!");
685     // It doesn't matter which of the MSA128[BHWD] classes we use. They are all
686     // identical
687     unsigned ClassID = Mips::MSA128BRegClassID;
688     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
689   }
690
691   /// Coerce the register to MSACtrl and return the real register for the
692   /// current target.
693   unsigned getMSACtrlReg() const {
694     assert(isRegIdx() && (RegIdx.Kind & RegKind_MSACtrl) && "Invalid access!");
695     unsigned ClassID = Mips::MSACtrlRegClassID;
696     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
697   }
698
699   /// Coerce the register to COP0 and return the real register for the
700   /// current target.
701   unsigned getCOP0Reg() const {
702     assert(isRegIdx() && (RegIdx.Kind & RegKind_COP0) && "Invalid access!");
703     unsigned ClassID = Mips::COP0RegClassID;
704     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
705   }
706
707   /// Coerce the register to COP2 and return the real register for the
708   /// current target.
709   unsigned getCOP2Reg() const {
710     assert(isRegIdx() && (RegIdx.Kind & RegKind_COP2) && "Invalid access!");
711     unsigned ClassID = Mips::COP2RegClassID;
712     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
713   }
714
715   /// Coerce the register to COP3 and return the real register for the
716   /// current target.
717   unsigned getCOP3Reg() const {
718     assert(isRegIdx() && (RegIdx.Kind & RegKind_COP3) && "Invalid access!");
719     unsigned ClassID = Mips::COP3RegClassID;
720     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
721   }
722
723   /// Coerce the register to ACC64DSP and return the real register for the
724   /// current target.
725   unsigned getACC64DSPReg() const {
726     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
727     unsigned ClassID = Mips::ACC64DSPRegClassID;
728     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
729   }
730
731   /// Coerce the register to HI32DSP and return the real register for the
732   /// current target.
733   unsigned getHI32DSPReg() const {
734     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
735     unsigned ClassID = Mips::HI32DSPRegClassID;
736     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
737   }
738
739   /// Coerce the register to LO32DSP and return the real register for the
740   /// current target.
741   unsigned getLO32DSPReg() const {
742     assert(isRegIdx() && (RegIdx.Kind & RegKind_ACC) && "Invalid access!");
743     unsigned ClassID = Mips::LO32DSPRegClassID;
744     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
745   }
746
747   /// Coerce the register to CCR and return the real register for the
748   /// current target.
749   unsigned getCCRReg() const {
750     assert(isRegIdx() && (RegIdx.Kind & RegKind_CCR) && "Invalid access!");
751     unsigned ClassID = Mips::CCRRegClassID;
752     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
753   }
754
755   /// Coerce the register to HWRegs and return the real register for the
756   /// current target.
757   unsigned getHWRegsReg() const {
758     assert(isRegIdx() && (RegIdx.Kind & RegKind_HWRegs) && "Invalid access!");
759     unsigned ClassID = Mips::HWRegsRegClassID;
760     return RegIdx.RegInfo->getRegClass(ClassID).getRegister(RegIdx.Index);
761   }
762
763 public:
764   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
765     // Add as immediate when possible.  Null MCExpr = 0.
766     if (!Expr)
767       Inst.addOperand(MCOperand::createImm(0));
768     else if (const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(Expr))
769       Inst.addOperand(MCOperand::createImm(CE->getValue()));
770     else
771       Inst.addOperand(MCOperand::createExpr(Expr));
772   }
773
774   void addRegOperands(MCInst &Inst, unsigned N) const {
775     llvm_unreachable("Use a custom parser instead");
776   }
777
778   /// Render the operand to an MCInst as a GPR32
779   /// Asserts if the wrong number of operands are requested, or the operand
780   /// is not a k_RegisterIndex compatible with RegKind_GPR
781   void addGPR32AsmRegOperands(MCInst &Inst, unsigned N) const {
782     assert(N == 1 && "Invalid number of operands!");
783     Inst.addOperand(MCOperand::createReg(getGPR32Reg()));
784   }
785
786   void addGPRMM16AsmRegOperands(MCInst &Inst, unsigned N) const {
787     assert(N == 1 && "Invalid number of operands!");
788     Inst.addOperand(MCOperand::createReg(getGPRMM16Reg()));
789   }
790
791   void addGPRMM16AsmRegZeroOperands(MCInst &Inst, unsigned N) const {
792     assert(N == 1 && "Invalid number of operands!");
793     Inst.addOperand(MCOperand::createReg(getGPRMM16Reg()));
794   }
795
796   void addGPRMM16AsmRegMovePOperands(MCInst &Inst, unsigned N) const {
797     assert(N == 1 && "Invalid number of operands!");
798     Inst.addOperand(MCOperand::createReg(getGPRMM16Reg()));
799   }
800
801   /// Render the operand to an MCInst as a GPR64
802   /// Asserts if the wrong number of operands are requested, or the operand
803   /// is not a k_RegisterIndex compatible with RegKind_GPR
804   void addGPR64AsmRegOperands(MCInst &Inst, unsigned N) const {
805     assert(N == 1 && "Invalid number of operands!");
806     Inst.addOperand(MCOperand::createReg(getGPR64Reg()));
807   }
808
809   void addAFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
810     assert(N == 1 && "Invalid number of operands!");
811     Inst.addOperand(MCOperand::createReg(getAFGR64Reg()));
812   }
813
814   void addFGR64AsmRegOperands(MCInst &Inst, unsigned N) const {
815     assert(N == 1 && "Invalid number of operands!");
816     Inst.addOperand(MCOperand::createReg(getFGR64Reg()));
817   }
818
819   void addFGR32AsmRegOperands(MCInst &Inst, unsigned N) const {
820     assert(N == 1 && "Invalid number of operands!");
821     Inst.addOperand(MCOperand::createReg(getFGR32Reg()));
822     // FIXME: We ought to do this for -integrated-as without -via-file-asm too.
823     if (!AsmParser.useOddSPReg() && RegIdx.Index & 1)
824       AsmParser.Error(StartLoc, "-mno-odd-spreg prohibits the use of odd FPU "
825                                 "registers");
826   }
827
828   void addFGRH32AsmRegOperands(MCInst &Inst, unsigned N) const {
829     assert(N == 1 && "Invalid number of operands!");
830     Inst.addOperand(MCOperand::createReg(getFGRH32Reg()));
831   }
832
833   void addFCCAsmRegOperands(MCInst &Inst, unsigned N) const {
834     assert(N == 1 && "Invalid number of operands!");
835     Inst.addOperand(MCOperand::createReg(getFCCReg()));
836   }
837
838   void addMSA128AsmRegOperands(MCInst &Inst, unsigned N) const {
839     assert(N == 1 && "Invalid number of operands!");
840     Inst.addOperand(MCOperand::createReg(getMSA128Reg()));
841   }
842
843   void addMSACtrlAsmRegOperands(MCInst &Inst, unsigned N) const {
844     assert(N == 1 && "Invalid number of operands!");
845     Inst.addOperand(MCOperand::createReg(getMSACtrlReg()));
846   }
847
848   void addCOP0AsmRegOperands(MCInst &Inst, unsigned N) const {
849     assert(N == 1 && "Invalid number of operands!");
850     Inst.addOperand(MCOperand::createReg(getCOP0Reg()));
851   }
852
853   void addCOP2AsmRegOperands(MCInst &Inst, unsigned N) const {
854     assert(N == 1 && "Invalid number of operands!");
855     Inst.addOperand(MCOperand::createReg(getCOP2Reg()));
856   }
857
858   void addCOP3AsmRegOperands(MCInst &Inst, unsigned N) const {
859     assert(N == 1 && "Invalid number of operands!");
860     Inst.addOperand(MCOperand::createReg(getCOP3Reg()));
861   }
862
863   void addACC64DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
864     assert(N == 1 && "Invalid number of operands!");
865     Inst.addOperand(MCOperand::createReg(getACC64DSPReg()));
866   }
867
868   void addHI32DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
869     assert(N == 1 && "Invalid number of operands!");
870     Inst.addOperand(MCOperand::createReg(getHI32DSPReg()));
871   }
872
873   void addLO32DSPAsmRegOperands(MCInst &Inst, unsigned N) const {
874     assert(N == 1 && "Invalid number of operands!");
875     Inst.addOperand(MCOperand::createReg(getLO32DSPReg()));
876   }
877
878   void addCCRAsmRegOperands(MCInst &Inst, unsigned N) const {
879     assert(N == 1 && "Invalid number of operands!");
880     Inst.addOperand(MCOperand::createReg(getCCRReg()));
881   }
882
883   void addHWRegsAsmRegOperands(MCInst &Inst, unsigned N) const {
884     assert(N == 1 && "Invalid number of operands!");
885     Inst.addOperand(MCOperand::createReg(getHWRegsReg()));
886   }
887
888   void addImmOperands(MCInst &Inst, unsigned N) const {
889     assert(N == 1 && "Invalid number of operands!");
890     const MCExpr *Expr = getImm();
891     addExpr(Inst, Expr);
892   }
893
894   void addMemOperands(MCInst &Inst, unsigned N) const {
895     assert(N == 2 && "Invalid number of operands!");
896
897     Inst.addOperand(MCOperand::createReg(AsmParser.getABI().ArePtrs64bit()
898                                              ? getMemBase()->getGPR64Reg()
899                                              : getMemBase()->getGPR32Reg()));
900
901     const MCExpr *Expr = getMemOff();
902     addExpr(Inst, Expr);
903   }
904
905   void addMicroMipsMemOperands(MCInst &Inst, unsigned N) const {
906     assert(N == 2 && "Invalid number of operands!");
907
908     Inst.addOperand(MCOperand::createReg(getMemBase()->getGPRMM16Reg()));
909
910     const MCExpr *Expr = getMemOff();
911     addExpr(Inst, Expr);
912   }
913
914   void addRegListOperands(MCInst &Inst, unsigned N) const {
915     assert(N == 1 && "Invalid number of operands!");
916
917     for (auto RegNo : getRegList())
918       Inst.addOperand(MCOperand::createReg(RegNo));
919   }
920
921   void addRegPairOperands(MCInst &Inst, unsigned N) const {
922     assert(N == 2 && "Invalid number of operands!");
923     unsigned RegNo = getRegPair();
924     Inst.addOperand(MCOperand::createReg(RegNo++));
925     Inst.addOperand(MCOperand::createReg(RegNo));
926   }
927
928   void addMovePRegPairOperands(MCInst &Inst, unsigned N) const {
929     assert(N == 2 && "Invalid number of operands!");
930     for (auto RegNo : getRegList())
931       Inst.addOperand(MCOperand::createReg(RegNo));
932   }
933
934   bool isReg() const override {
935     // As a special case until we sort out the definition of div/divu, pretend
936     // that $0/$zero are k_PhysRegister so that MCK_ZERO works correctly.
937     if (isGPRAsmReg() && RegIdx.Index == 0)
938       return true;
939
940     return Kind == k_PhysRegister;
941   }
942   bool isRegIdx() const { return Kind == k_RegisterIndex; }
943   bool isImm() const override { return Kind == k_Immediate; }
944   bool isConstantImm() const {
945     return isImm() && dyn_cast<MCConstantExpr>(getImm());
946   }
947   template <unsigned Bits> bool isUImm() const {
948     return isImm() && isConstantImm() && isUInt<Bits>(getConstantImm());
949   }
950   bool isToken() const override {
951     // Note: It's not possible to pretend that other operand kinds are tokens.
952     // The matcher emitter checks tokens first.
953     return Kind == k_Token;
954   }
955   bool isMem() const override { return Kind == k_Memory; }
956   bool isConstantMemOff() const {
957     return isMem() && dyn_cast<MCConstantExpr>(getMemOff());
958   }
959   template <unsigned Bits> bool isMemWithSimmOffset() const {
960     return isMem() && isConstantMemOff() && isInt<Bits>(getConstantMemOff());
961   }
962   template <unsigned Bits> bool isMemWithSimmOffsetGPR() const {
963     return isMem() && isConstantMemOff() && isInt<Bits>(getConstantMemOff())
964       && getMemBase()->isGPRAsmReg();
965   }
966   bool isMemWithGRPMM16Base() const {
967     return isMem() && getMemBase()->isMM16AsmReg();
968   }
969   template <unsigned Bits> bool isMemWithUimmOffsetSP() const {
970     return isMem() && isConstantMemOff() && isUInt<Bits>(getConstantMemOff())
971       && getMemBase()->isRegIdx() && (getMemBase()->getGPR32Reg() == Mips::SP);
972   }
973   template <unsigned Bits> bool isMemWithUimmWordAlignedOffsetSP() const {
974     return isMem() && isConstantMemOff() && isUInt<Bits>(getConstantMemOff())
975       && (getConstantMemOff() % 4 == 0) && getMemBase()->isRegIdx()
976       && (getMemBase()->getGPR32Reg() == Mips::SP);
977   }
978   bool isRegList16() const {
979     if (!isRegList())
980       return false;
981
982     int Size = RegList.List->size();
983     if (Size < 2 || Size > 5 || *RegList.List->begin() != Mips::S0 ||
984         RegList.List->back() != Mips::RA)
985       return false;
986
987     int PrevReg = *RegList.List->begin();
988     for (int i = 1; i < Size - 1; i++) {
989       int Reg = (*(RegList.List))[i];
990       if ( Reg != PrevReg + 1)
991         return false;
992       PrevReg = Reg;
993     }
994
995     return true;
996   }
997   bool isInvNum() const { return Kind == k_Immediate; }
998   bool isLSAImm() const {
999     if (!isConstantImm())
1000       return false;
1001     int64_t Val = getConstantImm();
1002     return 1 <= Val && Val <= 4;
1003   }
1004   bool isRegList() const { return Kind == k_RegList; }
1005   bool isMovePRegPair() const {
1006     if (Kind != k_RegList || RegList.List->size() != 2)
1007       return false;
1008
1009     unsigned R0 = RegList.List->front();
1010     unsigned R1 = RegList.List->back();
1011
1012     if ((R0 == Mips::A1 && R1 == Mips::A2) ||
1013         (R0 == Mips::A1 && R1 == Mips::A3) ||
1014         (R0 == Mips::A2 && R1 == Mips::A3) ||
1015         (R0 == Mips::A0 && R1 == Mips::S5) ||
1016         (R0 == Mips::A0 && R1 == Mips::S6) ||
1017         (R0 == Mips::A0 && R1 == Mips::A1) ||
1018         (R0 == Mips::A0 && R1 == Mips::A2) ||
1019         (R0 == Mips::A0 && R1 == Mips::A3))
1020       return true;
1021
1022     return false;
1023   }
1024
1025   StringRef getToken() const {
1026     assert(Kind == k_Token && "Invalid access!");
1027     return StringRef(Tok.Data, Tok.Length);
1028   }
1029   bool isRegPair() const { return Kind == k_RegPair; }
1030
1031   unsigned getReg() const override {
1032     // As a special case until we sort out the definition of div/divu, pretend
1033     // that $0/$zero are k_PhysRegister so that MCK_ZERO works correctly.
1034     if (Kind == k_RegisterIndex && RegIdx.Index == 0 &&
1035         RegIdx.Kind & RegKind_GPR)
1036       return getGPR32Reg(); // FIXME: GPR64 too
1037
1038     assert(Kind == k_PhysRegister && "Invalid access!");
1039     return PhysReg.Num;
1040   }
1041
1042   const MCExpr *getImm() const {
1043     assert((Kind == k_Immediate) && "Invalid access!");
1044     return Imm.Val;
1045   }
1046
1047   int64_t getConstantImm() const {
1048     const MCExpr *Val = getImm();
1049     return static_cast<const MCConstantExpr *>(Val)->getValue();
1050   }
1051
1052   MipsOperand *getMemBase() const {
1053     assert((Kind == k_Memory) && "Invalid access!");
1054     return Mem.Base;
1055   }
1056
1057   const MCExpr *getMemOff() const {
1058     assert((Kind == k_Memory) && "Invalid access!");
1059     return Mem.Off;
1060   }
1061
1062   int64_t getConstantMemOff() const {
1063     return static_cast<const MCConstantExpr *>(getMemOff())->getValue();
1064   }
1065
1066   const SmallVectorImpl<unsigned> &getRegList() const {
1067     assert((Kind == k_RegList) && "Invalid access!");
1068     return *(RegList.List);
1069   }
1070
1071   unsigned getRegPair() const {
1072     assert((Kind == k_RegPair) && "Invalid access!");
1073     return RegIdx.Index;
1074   }
1075
1076   static std::unique_ptr<MipsOperand> CreateToken(StringRef Str, SMLoc S,
1077                                                   MipsAsmParser &Parser) {
1078     auto Op = make_unique<MipsOperand>(k_Token, Parser);
1079     Op->Tok.Data = Str.data();
1080     Op->Tok.Length = Str.size();
1081     Op->StartLoc = S;
1082     Op->EndLoc = S;
1083     return Op;
1084   }
1085
1086   /// Create a numeric register (e.g. $1). The exact register remains
1087   /// unresolved until an instruction successfully matches
1088   static std::unique_ptr<MipsOperand>
1089   createNumericReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1090                    SMLoc E, MipsAsmParser &Parser) {
1091     DEBUG(dbgs() << "createNumericReg(" << Index << ", ...)\n");
1092     return CreateReg(Index, RegKind_Numeric, RegInfo, S, E, Parser);
1093   }
1094
1095   /// Create a register that is definitely a GPR.
1096   /// This is typically only used for named registers such as $gp.
1097   static std::unique_ptr<MipsOperand>
1098   createGPRReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1099                MipsAsmParser &Parser) {
1100     return CreateReg(Index, RegKind_GPR, RegInfo, S, E, Parser);
1101   }
1102
1103   /// Create a register that is definitely a FGR.
1104   /// This is typically only used for named registers such as $f0.
1105   static std::unique_ptr<MipsOperand>
1106   createFGRReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1107                MipsAsmParser &Parser) {
1108     return CreateReg(Index, RegKind_FGR, RegInfo, S, E, Parser);
1109   }
1110
1111   /// Create a register that is definitely a HWReg.
1112   /// This is typically only used for named registers such as $hwr_cpunum.
1113   static std::unique_ptr<MipsOperand>
1114   createHWRegsReg(unsigned Index, const MCRegisterInfo *RegInfo,
1115                   SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1116     return CreateReg(Index, RegKind_HWRegs, RegInfo, S, E, Parser);
1117   }
1118
1119   /// Create a register that is definitely an FCC.
1120   /// This is typically only used for named registers such as $fcc0.
1121   static std::unique_ptr<MipsOperand>
1122   createFCCReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1123                MipsAsmParser &Parser) {
1124     return CreateReg(Index, RegKind_FCC, RegInfo, S, E, Parser);
1125   }
1126
1127   /// Create a register that is definitely an ACC.
1128   /// This is typically only used for named registers such as $ac0.
1129   static std::unique_ptr<MipsOperand>
1130   createACCReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S, SMLoc E,
1131                MipsAsmParser &Parser) {
1132     return CreateReg(Index, RegKind_ACC, RegInfo, S, E, Parser);
1133   }
1134
1135   /// Create a register that is definitely an MSA128.
1136   /// This is typically only used for named registers such as $w0.
1137   static std::unique_ptr<MipsOperand>
1138   createMSA128Reg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1139                   SMLoc E, MipsAsmParser &Parser) {
1140     return CreateReg(Index, RegKind_MSA128, RegInfo, S, E, Parser);
1141   }
1142
1143   /// Create a register that is definitely an MSACtrl.
1144   /// This is typically only used for named registers such as $msaaccess.
1145   static std::unique_ptr<MipsOperand>
1146   createMSACtrlReg(unsigned Index, const MCRegisterInfo *RegInfo, SMLoc S,
1147                    SMLoc E, MipsAsmParser &Parser) {
1148     return CreateReg(Index, RegKind_MSACtrl, RegInfo, S, E, Parser);
1149   }
1150
1151   static std::unique_ptr<MipsOperand>
1152   CreateImm(const MCExpr *Val, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1153     auto Op = make_unique<MipsOperand>(k_Immediate, Parser);
1154     Op->Imm.Val = Val;
1155     Op->StartLoc = S;
1156     Op->EndLoc = E;
1157     return Op;
1158   }
1159
1160   static std::unique_ptr<MipsOperand>
1161   CreateMem(std::unique_ptr<MipsOperand> Base, const MCExpr *Off, SMLoc S,
1162             SMLoc E, MipsAsmParser &Parser) {
1163     auto Op = make_unique<MipsOperand>(k_Memory, Parser);
1164     Op->Mem.Base = Base.release();
1165     Op->Mem.Off = Off;
1166     Op->StartLoc = S;
1167     Op->EndLoc = E;
1168     return Op;
1169   }
1170
1171   static std::unique_ptr<MipsOperand>
1172   CreateRegList(SmallVectorImpl<unsigned> &Regs, SMLoc StartLoc, SMLoc EndLoc,
1173                 MipsAsmParser &Parser) {
1174     assert (Regs.size() > 0 && "Empty list not allowed");
1175
1176     auto Op = make_unique<MipsOperand>(k_RegList, Parser);
1177     Op->RegList.List = new SmallVector<unsigned, 10>(Regs.begin(), Regs.end());
1178     Op->StartLoc = StartLoc;
1179     Op->EndLoc = EndLoc;
1180     return Op;
1181   }
1182
1183   static std::unique_ptr<MipsOperand>
1184   CreateRegPair(unsigned RegNo, SMLoc S, SMLoc E, MipsAsmParser &Parser) {
1185     auto Op = make_unique<MipsOperand>(k_RegPair, Parser);
1186     Op->RegIdx.Index = RegNo;
1187     Op->StartLoc = S;
1188     Op->EndLoc = E;
1189     return Op;
1190   }
1191
1192   bool isGPRAsmReg() const {
1193     return isRegIdx() && RegIdx.Kind & RegKind_GPR && RegIdx.Index <= 31;
1194   }
1195   bool isMM16AsmReg() const {
1196     if (!(isRegIdx() && RegIdx.Kind))
1197       return false;
1198     return ((RegIdx.Index >= 2 && RegIdx.Index <= 7)
1199             || RegIdx.Index == 16 || RegIdx.Index == 17);
1200   }
1201   bool isMM16AsmRegZero() const {
1202     if (!(isRegIdx() && RegIdx.Kind))
1203       return false;
1204     return (RegIdx.Index == 0 ||
1205             (RegIdx.Index >= 2 && RegIdx.Index <= 7) ||
1206             RegIdx.Index == 17);
1207   }
1208   bool isMM16AsmRegMoveP() const {
1209     if (!(isRegIdx() && RegIdx.Kind))
1210       return false;
1211     return (RegIdx.Index == 0 || (RegIdx.Index >= 2 && RegIdx.Index <= 3) ||
1212       (RegIdx.Index >= 16 && RegIdx.Index <= 20));
1213   }
1214   bool isFGRAsmReg() const {
1215     // AFGR64 is $0-$15 but we handle this in getAFGR64()
1216     return isRegIdx() && RegIdx.Kind & RegKind_FGR && RegIdx.Index <= 31;
1217   }
1218   bool isHWRegsAsmReg() const {
1219     return isRegIdx() && RegIdx.Kind & RegKind_HWRegs && RegIdx.Index <= 31;
1220   }
1221   bool isCCRAsmReg() const {
1222     return isRegIdx() && RegIdx.Kind & RegKind_CCR && RegIdx.Index <= 31;
1223   }
1224   bool isFCCAsmReg() const {
1225     if (!(isRegIdx() && RegIdx.Kind & RegKind_FCC))
1226       return false;
1227     if (!AsmParser.hasEightFccRegisters())
1228       return RegIdx.Index == 0;
1229     return RegIdx.Index <= 7;
1230   }
1231   bool isACCAsmReg() const {
1232     return isRegIdx() && RegIdx.Kind & RegKind_ACC && RegIdx.Index <= 3;
1233   }
1234   bool isCOP0AsmReg() const {
1235     return isRegIdx() && RegIdx.Kind & RegKind_COP0 && RegIdx.Index <= 31;
1236   }
1237   bool isCOP2AsmReg() const {
1238     return isRegIdx() && RegIdx.Kind & RegKind_COP2 && RegIdx.Index <= 31;
1239   }
1240   bool isCOP3AsmReg() const {
1241     return isRegIdx() && RegIdx.Kind & RegKind_COP3 && RegIdx.Index <= 31;
1242   }
1243   bool isMSA128AsmReg() const {
1244     return isRegIdx() && RegIdx.Kind & RegKind_MSA128 && RegIdx.Index <= 31;
1245   }
1246   bool isMSACtrlAsmReg() const {
1247     return isRegIdx() && RegIdx.Kind & RegKind_MSACtrl && RegIdx.Index <= 7;
1248   }
1249
1250   /// getStartLoc - Get the location of the first token of this operand.
1251   SMLoc getStartLoc() const override { return StartLoc; }
1252   /// getEndLoc - Get the location of the last token of this operand.
1253   SMLoc getEndLoc() const override { return EndLoc; }
1254
1255   virtual ~MipsOperand() {
1256     switch (Kind) {
1257     case k_Immediate:
1258       break;
1259     case k_Memory:
1260       delete Mem.Base;
1261       break;
1262     case k_RegList:
1263       delete RegList.List;
1264     case k_PhysRegister:
1265     case k_RegisterIndex:
1266     case k_Token:
1267     case k_RegPair:
1268       break;
1269     }
1270   }
1271
1272   void print(raw_ostream &OS) const override {
1273     switch (Kind) {
1274     case k_Immediate:
1275       OS << "Imm<";
1276       OS << *Imm.Val;
1277       OS << ">";
1278       break;
1279     case k_Memory:
1280       OS << "Mem<";
1281       Mem.Base->print(OS);
1282       OS << ", ";
1283       OS << *Mem.Off;
1284       OS << ">";
1285       break;
1286     case k_PhysRegister:
1287       OS << "PhysReg<" << PhysReg.Num << ">";
1288       break;
1289     case k_RegisterIndex:
1290       OS << "RegIdx<" << RegIdx.Index << ":" << RegIdx.Kind << ">";
1291       break;
1292     case k_Token:
1293       OS << Tok.Data;
1294       break;
1295     case k_RegList:
1296       OS << "RegList< ";
1297       for (auto Reg : (*RegList.List))
1298         OS << Reg << " ";
1299       OS <<  ">";
1300       break;
1301     case k_RegPair:
1302       OS << "RegPair<" << RegIdx.Index << "," << RegIdx.Index + 1 << ">";
1303       break;
1304     }
1305   }
1306 }; // class MipsOperand
1307 } // namespace
1308
1309 namespace llvm {
1310 extern const MCInstrDesc MipsInsts[];
1311 }
1312 static const MCInstrDesc &getInstDesc(unsigned Opcode) {
1313   return MipsInsts[Opcode];
1314 }
1315
1316 static bool hasShortDelaySlot(unsigned Opcode) {
1317   switch (Opcode) {
1318     case Mips::JALS_MM:
1319     case Mips::JALRS_MM:
1320     case Mips::JALRS16_MM:
1321     case Mips::BGEZALS_MM:
1322     case Mips::BLTZALS_MM:
1323       return true;
1324     default:
1325       return false;
1326   }
1327 }
1328
1329 static const MCSymbol *getSingleMCSymbol(const MCExpr *Expr) {
1330   if (const MCSymbolRefExpr *SRExpr = dyn_cast<MCSymbolRefExpr>(Expr)) {
1331     return &SRExpr->getSymbol();
1332   }
1333
1334   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr)) {
1335     const MCSymbol *LHSSym = getSingleMCSymbol(BExpr->getLHS());
1336     const MCSymbol *RHSSym = getSingleMCSymbol(BExpr->getRHS());
1337
1338     if (LHSSym)
1339       return LHSSym;
1340
1341     if (RHSSym)
1342       return RHSSym;
1343
1344     return nullptr;
1345   }
1346
1347   if (const MCUnaryExpr *UExpr = dyn_cast<MCUnaryExpr>(Expr))
1348     return getSingleMCSymbol(UExpr->getSubExpr());
1349
1350   return nullptr;
1351 }
1352
1353 static unsigned countMCSymbolRefExpr(const MCExpr *Expr) {
1354   if (isa<MCSymbolRefExpr>(Expr))
1355     return 1;
1356
1357   if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(Expr))
1358     return countMCSymbolRefExpr(BExpr->getLHS()) +
1359            countMCSymbolRefExpr(BExpr->getRHS());
1360
1361   if (const MCUnaryExpr *UExpr = dyn_cast<MCUnaryExpr>(Expr))
1362     return countMCSymbolRefExpr(UExpr->getSubExpr());
1363
1364   return 0;
1365 }
1366
1367 bool MipsAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc,
1368                                        SmallVectorImpl<MCInst> &Instructions) {
1369   const MCInstrDesc &MCID = getInstDesc(Inst.getOpcode());
1370
1371   Inst.setLoc(IDLoc);
1372
1373   if (MCID.isBranch() || MCID.isCall()) {
1374     const unsigned Opcode = Inst.getOpcode();
1375     MCOperand Offset;
1376
1377     switch (Opcode) {
1378     default:
1379       break;
1380     case Mips::BBIT0:
1381     case Mips::BBIT032:
1382     case Mips::BBIT1:
1383     case Mips::BBIT132:
1384       assert(hasCnMips() && "instruction only valid for octeon cpus");
1385       // Fall through
1386
1387     case Mips::BEQ:
1388     case Mips::BNE:
1389     case Mips::BEQ_MM:
1390     case Mips::BNE_MM:
1391       assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1392       Offset = Inst.getOperand(2);
1393       if (!Offset.isImm())
1394         break; // We'll deal with this situation later on when applying fixups.
1395       if (!isIntN(inMicroMipsMode() ? 17 : 18, Offset.getImm()))
1396         return Error(IDLoc, "branch target out of range");
1397       if (OffsetToAlignment(Offset.getImm(),
1398                             1LL << (inMicroMipsMode() ? 1 : 2)))
1399         return Error(IDLoc, "branch to misaligned address");
1400       break;
1401     case Mips::BGEZ:
1402     case Mips::BGTZ:
1403     case Mips::BLEZ:
1404     case Mips::BLTZ:
1405     case Mips::BGEZAL:
1406     case Mips::BLTZAL:
1407     case Mips::BC1F:
1408     case Mips::BC1T:
1409     case Mips::BGEZ_MM:
1410     case Mips::BGTZ_MM:
1411     case Mips::BLEZ_MM:
1412     case Mips::BLTZ_MM:
1413     case Mips::BGEZAL_MM:
1414     case Mips::BLTZAL_MM:
1415     case Mips::BC1F_MM:
1416     case Mips::BC1T_MM:
1417       assert(MCID.getNumOperands() == 2 && "unexpected number of operands");
1418       Offset = Inst.getOperand(1);
1419       if (!Offset.isImm())
1420         break; // We'll deal with this situation later on when applying fixups.
1421       if (!isIntN(inMicroMipsMode() ? 17 : 18, Offset.getImm()))
1422         return Error(IDLoc, "branch target out of range");
1423       if (OffsetToAlignment(Offset.getImm(),
1424                             1LL << (inMicroMipsMode() ? 1 : 2)))
1425         return Error(IDLoc, "branch to misaligned address");
1426       break;
1427     case Mips::BEQZ16_MM:
1428     case Mips::BNEZ16_MM:
1429       assert(MCID.getNumOperands() == 2 && "unexpected number of operands");
1430       Offset = Inst.getOperand(1);
1431       if (!Offset.isImm())
1432         break; // We'll deal with this situation later on when applying fixups.
1433       if (!isIntN(8, Offset.getImm()))
1434         return Error(IDLoc, "branch target out of range");
1435       if (OffsetToAlignment(Offset.getImm(), 2LL))
1436         return Error(IDLoc, "branch to misaligned address");
1437       break;
1438     }
1439   }
1440
1441   // SSNOP is deprecated on MIPS32r6/MIPS64r6
1442   // We still accept it but it is a normal nop.
1443   if (hasMips32r6() && Inst.getOpcode() == Mips::SSNOP) {
1444     std::string ISA = hasMips64r6() ? "MIPS64r6" : "MIPS32r6";
1445     Warning(IDLoc, "ssnop is deprecated for " + ISA + " and is equivalent to a "
1446                                                       "nop instruction");
1447   }
1448
1449   if (hasCnMips()) {
1450     const unsigned Opcode = Inst.getOpcode();
1451     MCOperand Opnd;
1452     int Imm;
1453
1454     switch (Opcode) {
1455       default:
1456         break;
1457
1458       case Mips::BBIT0:
1459       case Mips::BBIT032:
1460       case Mips::BBIT1:
1461       case Mips::BBIT132:
1462         assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1463         // The offset is handled above
1464         Opnd = Inst.getOperand(1);
1465         if (!Opnd.isImm())
1466           return Error(IDLoc, "expected immediate operand kind");
1467         Imm = Opnd.getImm();
1468         if (Imm < 0 || Imm > (Opcode == Mips::BBIT0 ||
1469                               Opcode == Mips::BBIT1 ? 63 : 31))
1470           return Error(IDLoc, "immediate operand value out of range");
1471         if (Imm > 31) {
1472           Inst.setOpcode(Opcode == Mips::BBIT0 ? Mips::BBIT032
1473                                                : Mips::BBIT132);
1474           Inst.getOperand(1).setImm(Imm - 32);
1475         }
1476         break;
1477
1478       case Mips::CINS:
1479       case Mips::CINS32:
1480       case Mips::EXTS:
1481       case Mips::EXTS32:
1482         assert(MCID.getNumOperands() == 4 && "unexpected number of operands");
1483         // Check length
1484         Opnd = Inst.getOperand(3);
1485         if (!Opnd.isImm())
1486           return Error(IDLoc, "expected immediate operand kind");
1487         Imm = Opnd.getImm();
1488         if (Imm < 0 || Imm > 31)
1489           return Error(IDLoc, "immediate operand value out of range");
1490         // Check position
1491         Opnd = Inst.getOperand(2);
1492         if (!Opnd.isImm())
1493           return Error(IDLoc, "expected immediate operand kind");
1494         Imm = Opnd.getImm();
1495         if (Imm < 0 || Imm > (Opcode == Mips::CINS ||
1496                               Opcode == Mips::EXTS ? 63 : 31))
1497           return Error(IDLoc, "immediate operand value out of range");
1498         if (Imm > 31) {
1499           Inst.setOpcode(Opcode == Mips::CINS ? Mips::CINS32 : Mips::EXTS32);
1500           Inst.getOperand(2).setImm(Imm - 32);
1501         }
1502         break;
1503
1504       case Mips::SEQi:
1505       case Mips::SNEi:
1506         assert(MCID.getNumOperands() == 3 && "unexpected number of operands");
1507         Opnd = Inst.getOperand(2);
1508         if (!Opnd.isImm())
1509           return Error(IDLoc, "expected immediate operand kind");
1510         Imm = Opnd.getImm();
1511         if (!isInt<10>(Imm))
1512           return Error(IDLoc, "immediate operand value out of range");
1513         break;
1514     }
1515   }
1516
1517   // This expansion is not in a function called by expandInstruction() because
1518   // the pseudo-instruction doesn't have a distinct opcode.
1519   if ((Inst.getOpcode() == Mips::JAL || Inst.getOpcode() == Mips::JAL_MM) &&
1520       inPicMode()) {
1521     warnIfNoMacro(IDLoc);
1522
1523     const MCExpr *JalExpr = Inst.getOperand(0).getExpr();
1524
1525     // We can do this expansion if there's only 1 symbol in the argument
1526     // expression.
1527     if (countMCSymbolRefExpr(JalExpr) > 1)
1528       return Error(IDLoc, "jal doesn't support multiple symbols in PIC mode");
1529
1530     // FIXME: This is checking the expression can be handled by the later stages
1531     //        of the assembler. We ought to leave it to those later stages but
1532     //        we can't do that until we stop evaluateRelocExpr() rewriting the
1533     //        expressions into non-equivalent forms.
1534     const MCSymbol *JalSym = getSingleMCSymbol(JalExpr);
1535
1536     // FIXME: Add support for label+offset operands (currently causes an error).
1537     // FIXME: Add support for forward-declared local symbols.
1538     // FIXME: Add expansion for when the LargeGOT option is enabled.
1539     if (JalSym->isInSection() || JalSym->isTemporary()) {
1540       if (isABI_O32()) {
1541         // If it's a local symbol and the O32 ABI is being used, we expand to:
1542         //  lw $25, 0($gp)
1543         //    R_(MICRO)MIPS_GOT16  label
1544         //  addiu $25, $25, 0
1545         //    R_(MICRO)MIPS_LO16   label
1546         //  jalr  $25
1547         const MCExpr *Got16RelocExpr = evaluateRelocExpr(JalExpr, "got");
1548         const MCExpr *Lo16RelocExpr = evaluateRelocExpr(JalExpr, "lo");
1549
1550         MCInst LwInst;
1551         LwInst.setOpcode(Mips::LW);
1552         LwInst.addOperand(MCOperand::createReg(Mips::T9));
1553         LwInst.addOperand(MCOperand::createReg(Mips::GP));
1554         LwInst.addOperand(MCOperand::createExpr(Got16RelocExpr));
1555         Instructions.push_back(LwInst);
1556
1557         MCInst AddiuInst;
1558         AddiuInst.setOpcode(Mips::ADDiu);
1559         AddiuInst.addOperand(MCOperand::createReg(Mips::T9));
1560         AddiuInst.addOperand(MCOperand::createReg(Mips::T9));
1561         AddiuInst.addOperand(MCOperand::createExpr(Lo16RelocExpr));
1562         Instructions.push_back(AddiuInst);
1563       } else if (isABI_N32() || isABI_N64()) {
1564         // If it's a local symbol and the N32/N64 ABIs are being used,
1565         // we expand to:
1566         //  lw/ld $25, 0($gp)
1567         //    R_(MICRO)MIPS_GOT_DISP  label
1568         //  jalr  $25
1569         const MCExpr *GotDispRelocExpr = evaluateRelocExpr(JalExpr, "got_disp");
1570
1571         MCInst LoadInst;
1572         LoadInst.setOpcode(ABI.ArePtrs64bit() ? Mips::LD : Mips::LW);
1573         LoadInst.addOperand(MCOperand::createReg(Mips::T9));
1574         LoadInst.addOperand(MCOperand::createReg(Mips::GP));
1575         LoadInst.addOperand(MCOperand::createExpr(GotDispRelocExpr));
1576         Instructions.push_back(LoadInst);
1577       }
1578     } else {
1579       // If it's an external/weak symbol, we expand to:
1580       //  lw/ld    $25, 0($gp)
1581       //    R_(MICRO)MIPS_CALL16  label
1582       //  jalr  $25
1583       const MCExpr *Call16RelocExpr = evaluateRelocExpr(JalExpr, "call16");
1584
1585       MCInst LoadInst;
1586       LoadInst.setOpcode(ABI.ArePtrs64bit() ? Mips::LD : Mips::LW);
1587       LoadInst.addOperand(MCOperand::createReg(Mips::T9));
1588       LoadInst.addOperand(MCOperand::createReg(Mips::GP));
1589       LoadInst.addOperand(MCOperand::createExpr(Call16RelocExpr));
1590       Instructions.push_back(LoadInst);
1591     }
1592
1593     MCInst JalrInst;
1594     JalrInst.setOpcode(inMicroMipsMode() ? Mips::JALR_MM : Mips::JALR);
1595     JalrInst.addOperand(MCOperand::createReg(Mips::RA));
1596     JalrInst.addOperand(MCOperand::createReg(Mips::T9));
1597
1598     // FIXME: Add an R_(MICRO)MIPS_JALR relocation after the JALR.
1599     // This relocation is supposed to be an optimization hint for the linker
1600     // and is not necessary for correctness.
1601
1602     Inst = JalrInst;
1603   }
1604
1605   if (MCID.mayLoad() || MCID.mayStore()) {
1606     // Check the offset of memory operand, if it is a symbol
1607     // reference or immediate we may have to expand instructions.
1608     for (unsigned i = 0; i < MCID.getNumOperands(); i++) {
1609       const MCOperandInfo &OpInfo = MCID.OpInfo[i];
1610       if ((OpInfo.OperandType == MCOI::OPERAND_MEMORY) ||
1611           (OpInfo.OperandType == MCOI::OPERAND_UNKNOWN)) {
1612         MCOperand &Op = Inst.getOperand(i);
1613         if (Op.isImm()) {
1614           int MemOffset = Op.getImm();
1615           if (MemOffset < -32768 || MemOffset > 32767) {
1616             // Offset can't exceed 16bit value.
1617             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), true);
1618             return false;
1619           }
1620         } else if (Op.isExpr()) {
1621           const MCExpr *Expr = Op.getExpr();
1622           if (Expr->getKind() == MCExpr::SymbolRef) {
1623             const MCSymbolRefExpr *SR =
1624                 static_cast<const MCSymbolRefExpr *>(Expr);
1625             if (SR->getKind() == MCSymbolRefExpr::VK_None) {
1626               // Expand symbol.
1627               expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
1628               return false;
1629             }
1630           } else if (!isEvaluated(Expr)) {
1631             expandMemInst(Inst, IDLoc, Instructions, MCID.mayLoad(), false);
1632             return false;
1633           }
1634         }
1635       }
1636     } // for
1637   }   // if load/store
1638
1639   if (inMicroMipsMode()) {
1640     if (MCID.mayLoad()) {
1641       // Try to create 16-bit GP relative load instruction.
1642       for (unsigned i = 0; i < MCID.getNumOperands(); i++) {
1643         const MCOperandInfo &OpInfo = MCID.OpInfo[i];
1644         if ((OpInfo.OperandType == MCOI::OPERAND_MEMORY) ||
1645             (OpInfo.OperandType == MCOI::OPERAND_UNKNOWN)) {
1646           MCOperand &Op = Inst.getOperand(i);
1647           if (Op.isImm()) {
1648             int MemOffset = Op.getImm();
1649             MCOperand &DstReg = Inst.getOperand(0);
1650             MCOperand &BaseReg = Inst.getOperand(1);
1651             if (isIntN(9, MemOffset) && (MemOffset % 4 == 0) &&
1652                 getContext().getRegisterInfo()->getRegClass(
1653                   Mips::GPRMM16RegClassID).contains(DstReg.getReg()) &&
1654                 BaseReg.getReg() == Mips::GP) {
1655               MCInst TmpInst;
1656               TmpInst.setLoc(IDLoc);
1657               TmpInst.setOpcode(Mips::LWGP_MM);
1658               TmpInst.addOperand(MCOperand::createReg(DstReg.getReg()));
1659               TmpInst.addOperand(MCOperand::createReg(Mips::GP));
1660               TmpInst.addOperand(MCOperand::createImm(MemOffset));
1661               Instructions.push_back(TmpInst);
1662               return false;
1663             }
1664           }
1665         }
1666       } // for
1667     }   // if load
1668
1669     // TODO: Handle this with the AsmOperandClass.PredicateMethod.
1670
1671     MCOperand Opnd;
1672     int Imm;
1673
1674     switch (Inst.getOpcode()) {
1675       default:
1676         break;
1677       case Mips::ADDIUS5_MM:
1678         Opnd = Inst.getOperand(2);
1679         if (!Opnd.isImm())
1680           return Error(IDLoc, "expected immediate operand kind");
1681         Imm = Opnd.getImm();
1682         if (Imm < -8 || Imm > 7)
1683           return Error(IDLoc, "immediate operand value out of range");
1684         break;
1685       case Mips::ADDIUSP_MM:
1686         Opnd = Inst.getOperand(0);
1687         if (!Opnd.isImm())
1688           return Error(IDLoc, "expected immediate operand kind");
1689         Imm = Opnd.getImm();
1690         if (Imm < -1032 || Imm > 1028 || (Imm < 8 && Imm > -12) ||
1691             Imm % 4 != 0)
1692           return Error(IDLoc, "immediate operand value out of range");
1693         break;
1694       case Mips::SLL16_MM:
1695       case Mips::SRL16_MM:
1696         Opnd = Inst.getOperand(2);
1697         if (!Opnd.isImm())
1698           return Error(IDLoc, "expected immediate operand kind");
1699         Imm = Opnd.getImm();
1700         if (Imm < 1 || Imm > 8)
1701           return Error(IDLoc, "immediate operand value out of range");
1702         break;
1703       case Mips::LI16_MM:
1704         Opnd = Inst.getOperand(1);
1705         if (!Opnd.isImm())
1706           return Error(IDLoc, "expected immediate operand kind");
1707         Imm = Opnd.getImm();
1708         if (Imm < -1 || Imm > 126)
1709           return Error(IDLoc, "immediate operand value out of range");
1710         break;
1711       case Mips::ADDIUR2_MM:
1712         Opnd = Inst.getOperand(2);
1713         if (!Opnd.isImm())
1714           return Error(IDLoc, "expected immediate operand kind");
1715         Imm = Opnd.getImm();
1716         if (!(Imm == 1 || Imm == -1 ||
1717               ((Imm % 4 == 0) && Imm < 28 && Imm > 0)))
1718           return Error(IDLoc, "immediate operand value out of range");
1719         break;
1720       case Mips::ADDIUR1SP_MM:
1721         Opnd = Inst.getOperand(1);
1722         if (!Opnd.isImm())
1723           return Error(IDLoc, "expected immediate operand kind");
1724         Imm = Opnd.getImm();
1725         if (OffsetToAlignment(Imm, 4LL))
1726           return Error(IDLoc, "misaligned immediate operand value");
1727         if (Imm < 0 || Imm > 255)
1728           return Error(IDLoc, "immediate operand value out of range");
1729         break;
1730       case Mips::ANDI16_MM:
1731         Opnd = Inst.getOperand(2);
1732         if (!Opnd.isImm())
1733           return Error(IDLoc, "expected immediate operand kind");
1734         Imm = Opnd.getImm();
1735         if (!(Imm == 128 || (Imm >= 1 && Imm <= 4) || Imm == 7 || Imm == 8 ||
1736               Imm == 15 || Imm == 16 || Imm == 31 || Imm == 32 || Imm == 63 ||
1737               Imm == 64 || Imm == 255 || Imm == 32768 || Imm == 65535))
1738           return Error(IDLoc, "immediate operand value out of range");
1739         break;
1740       case Mips::LBU16_MM:
1741         Opnd = Inst.getOperand(2);
1742         if (!Opnd.isImm())
1743           return Error(IDLoc, "expected immediate operand kind");
1744         Imm = Opnd.getImm();
1745         if (Imm < -1 || Imm > 14)
1746           return Error(IDLoc, "immediate operand value out of range");
1747         break;
1748       case Mips::SB16_MM:
1749         Opnd = Inst.getOperand(2);
1750         if (!Opnd.isImm())
1751           return Error(IDLoc, "expected immediate operand kind");
1752         Imm = Opnd.getImm();
1753         if (Imm < 0 || Imm > 15)
1754           return Error(IDLoc, "immediate operand value out of range");
1755         break;
1756       case Mips::LHU16_MM:
1757       case Mips::SH16_MM:
1758         Opnd = Inst.getOperand(2);
1759         if (!Opnd.isImm())
1760           return Error(IDLoc, "expected immediate operand kind");
1761         Imm = Opnd.getImm();
1762         if (Imm < 0 || Imm > 30 || (Imm % 2 != 0))
1763           return Error(IDLoc, "immediate operand value out of range");
1764         break;
1765       case Mips::LW16_MM:
1766       case Mips::SW16_MM:
1767         Opnd = Inst.getOperand(2);
1768         if (!Opnd.isImm())
1769           return Error(IDLoc, "expected immediate operand kind");
1770         Imm = Opnd.getImm();
1771         if (Imm < 0 || Imm > 60 || (Imm % 4 != 0))
1772           return Error(IDLoc, "immediate operand value out of range");
1773         break;
1774       case Mips::CACHE:
1775       case Mips::PREF:
1776         Opnd = Inst.getOperand(2);
1777         if (!Opnd.isImm())
1778           return Error(IDLoc, "expected immediate operand kind");
1779         Imm = Opnd.getImm();
1780         if (!isUInt<5>(Imm))
1781           return Error(IDLoc, "immediate operand value out of range");
1782         break;
1783       case Mips::ADDIUPC_MM:
1784         MCOperand Opnd = Inst.getOperand(1);
1785         if (!Opnd.isImm())
1786           return Error(IDLoc, "expected immediate operand kind");
1787         int Imm = Opnd.getImm();
1788         if ((Imm % 4 != 0) || !isIntN(25, Imm))
1789           return Error(IDLoc, "immediate operand value out of range");
1790         break;
1791     }
1792   }
1793
1794   if (needsExpansion(Inst)) {
1795     if (expandInstruction(Inst, IDLoc, Instructions))
1796       return true;
1797   } else
1798     Instructions.push_back(Inst);
1799
1800   // If this instruction has a delay slot and .set reorder is active,
1801   // emit a NOP after it.
1802   if (MCID.hasDelaySlot() && AssemblerOptions.back()->isReorder())
1803     createNop(hasShortDelaySlot(Inst.getOpcode()), IDLoc, Instructions);
1804
1805   return false;
1806 }
1807
1808 bool MipsAsmParser::needsExpansion(MCInst &Inst) {
1809
1810   switch (Inst.getOpcode()) {
1811   case Mips::LoadImm32:
1812   case Mips::LoadImm64:
1813   case Mips::LoadAddrImm32:
1814   case Mips::LoadAddrImm64:
1815   case Mips::LoadAddrReg32:
1816   case Mips::LoadAddrReg64:
1817   case Mips::B_MM_Pseudo:
1818   case Mips::LWM_MM:
1819   case Mips::SWM_MM:
1820   case Mips::JalOneReg:
1821   case Mips::JalTwoReg:
1822   case Mips::BneImm:
1823   case Mips::BeqImm:
1824   case Mips::BLT:
1825   case Mips::BLE:
1826   case Mips::BGE:
1827   case Mips::BGT:
1828   case Mips::BLTU:
1829   case Mips::BLEU:
1830   case Mips::BGEU:
1831   case Mips::BGTU:
1832   case Mips::SDivMacro:
1833   case Mips::UDivMacro:
1834   case Mips::DSDivMacro:
1835   case Mips::DUDivMacro:
1836   case Mips::Ulhu:
1837   case Mips::Ulw:
1838     return true;
1839   default:
1840     return false;
1841   }
1842 }
1843
1844 bool MipsAsmParser::expandInstruction(MCInst &Inst, SMLoc IDLoc,
1845                                       SmallVectorImpl<MCInst> &Instructions) {
1846   switch (Inst.getOpcode()) {
1847   default: llvm_unreachable("unimplemented expansion");
1848   case Mips::LoadImm32:
1849     return expandLoadImm(Inst, true, IDLoc, Instructions);
1850   case Mips::LoadImm64:
1851     return expandLoadImm(Inst, false, IDLoc, Instructions);
1852   case Mips::LoadAddrImm32:
1853   case Mips::LoadAddrImm64:
1854     assert(Inst.getOperand(0).isReg() && "expected register operand kind");
1855     assert((Inst.getOperand(1).isImm() || Inst.getOperand(1).isExpr()) &&
1856            "expected immediate operand kind");
1857
1858     return expandLoadAddress(
1859         Inst.getOperand(0).getReg(), Mips::NoRegister, Inst.getOperand(1),
1860         Inst.getOpcode() == Mips::LoadAddrImm32, IDLoc, Instructions);
1861   case Mips::LoadAddrReg32:
1862   case Mips::LoadAddrReg64:
1863     assert(Inst.getOperand(0).isReg() && "expected register operand kind");
1864     assert(Inst.getOperand(1).isReg() && "expected register operand kind");
1865     assert((Inst.getOperand(2).isImm() || Inst.getOperand(2).isExpr()) &&
1866            "expected immediate operand kind");
1867
1868     return expandLoadAddress(
1869         Inst.getOperand(0).getReg(), Inst.getOperand(1).getReg(), Inst.getOperand(2),
1870         Inst.getOpcode() == Mips::LoadAddrReg32, IDLoc, Instructions);
1871   case Mips::B_MM_Pseudo:
1872     return expandUncondBranchMMPseudo(Inst, IDLoc, Instructions);
1873   case Mips::SWM_MM:
1874   case Mips::LWM_MM:
1875     return expandLoadStoreMultiple(Inst, IDLoc, Instructions);
1876   case Mips::JalOneReg:
1877   case Mips::JalTwoReg:
1878     return expandJalWithRegs(Inst, IDLoc, Instructions);
1879   case Mips::BneImm:
1880   case Mips::BeqImm:
1881     return expandBranchImm(Inst, IDLoc, Instructions);
1882   case Mips::BLT:
1883   case Mips::BLE:
1884   case Mips::BGE:
1885   case Mips::BGT:
1886   case Mips::BLTU:
1887   case Mips::BLEU:
1888   case Mips::BGEU:
1889   case Mips::BGTU:
1890     return expandCondBranches(Inst, IDLoc, Instructions);
1891   case Mips::SDivMacro:
1892     return expandDiv(Inst, IDLoc, Instructions, false, true);
1893   case Mips::DSDivMacro:
1894     return expandDiv(Inst, IDLoc, Instructions, true, true);
1895   case Mips::UDivMacro:
1896     return expandDiv(Inst, IDLoc, Instructions, false, false);
1897   case Mips::DUDivMacro:
1898     return expandDiv(Inst, IDLoc, Instructions, true, false);
1899   case Mips::Ulhu:
1900     return expandUlhu(Inst, IDLoc, Instructions);
1901   case Mips::Ulw:
1902     return expandUlw(Inst, IDLoc, Instructions);
1903   }
1904 }
1905
1906 namespace {
1907 void emitRX(unsigned Opcode, unsigned Reg0, MCOperand Op1, SMLoc IDLoc,
1908             SmallVectorImpl<MCInst> &Instructions) {
1909   MCInst tmpInst;
1910   tmpInst.setOpcode(Opcode);
1911   tmpInst.addOperand(MCOperand::createReg(Reg0));
1912   tmpInst.addOperand(Op1);
1913   tmpInst.setLoc(IDLoc);
1914   Instructions.push_back(tmpInst);
1915 }
1916
1917 void emitRI(unsigned Opcode, unsigned Reg0, int32_t Imm, SMLoc IDLoc,
1918             SmallVectorImpl<MCInst> &Instructions) {
1919   emitRX(Opcode, Reg0, MCOperand::createImm(Imm), IDLoc, Instructions);
1920 }
1921
1922 void emitRR(unsigned Opcode, unsigned Reg0, unsigned Reg1, SMLoc IDLoc,
1923             SmallVectorImpl<MCInst> &Instructions) {
1924   emitRX(Opcode, Reg0, MCOperand::createReg(Reg1), IDLoc, Instructions);
1925 }
1926
1927 void emitII(unsigned Opcode, int16_t Imm1, int16_t Imm2, SMLoc IDLoc,
1928             SmallVectorImpl<MCInst> &Instructions) {
1929   MCInst tmpInst;
1930   tmpInst.setOpcode(Opcode);
1931   tmpInst.addOperand(MCOperand::createImm(Imm1));
1932   tmpInst.addOperand(MCOperand::createImm(Imm2));
1933   tmpInst.setLoc(IDLoc);
1934   Instructions.push_back(tmpInst);
1935 }
1936
1937 void emitR(unsigned Opcode, unsigned Reg0, SMLoc IDLoc,
1938            SmallVectorImpl<MCInst> &Instructions) {
1939   MCInst tmpInst;
1940   tmpInst.setOpcode(Opcode);
1941   tmpInst.addOperand(MCOperand::createReg(Reg0));
1942   tmpInst.setLoc(IDLoc);
1943   Instructions.push_back(tmpInst);
1944 }
1945
1946 void emitRRX(unsigned Opcode, unsigned Reg0, unsigned Reg1, MCOperand Op2,
1947              SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
1948   MCInst tmpInst;
1949   tmpInst.setOpcode(Opcode);
1950   tmpInst.addOperand(MCOperand::createReg(Reg0));
1951   tmpInst.addOperand(MCOperand::createReg(Reg1));
1952   tmpInst.addOperand(Op2);
1953   tmpInst.setLoc(IDLoc);
1954   Instructions.push_back(tmpInst);
1955 }
1956
1957 void emitRRR(unsigned Opcode, unsigned Reg0, unsigned Reg1, unsigned Reg2,
1958              SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
1959   emitRRX(Opcode, Reg0, Reg1, MCOperand::createReg(Reg2), IDLoc,
1960           Instructions);
1961 }
1962
1963 void emitRRI(unsigned Opcode, unsigned Reg0, unsigned Reg1, int16_t Imm,
1964              SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
1965   emitRRX(Opcode, Reg0, Reg1, MCOperand::createImm(Imm), IDLoc,
1966           Instructions);
1967 }
1968
1969 void emitAppropriateDSLL(unsigned DstReg, unsigned SrcReg, int16_t ShiftAmount,
1970                          SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
1971   if (ShiftAmount >= 32) {
1972     emitRRI(Mips::DSLL32, DstReg, SrcReg, ShiftAmount - 32, IDLoc,
1973             Instructions);
1974     return;
1975   }
1976
1977   emitRRI(Mips::DSLL, DstReg, SrcReg, ShiftAmount, IDLoc, Instructions);
1978 }
1979 } // end anonymous namespace.
1980
1981 bool MipsAsmParser::expandJalWithRegs(MCInst &Inst, SMLoc IDLoc,
1982                                       SmallVectorImpl<MCInst> &Instructions) {
1983   // Create a JALR instruction which is going to replace the pseudo-JAL.
1984   MCInst JalrInst;
1985   JalrInst.setLoc(IDLoc);
1986   const MCOperand FirstRegOp = Inst.getOperand(0);
1987   const unsigned Opcode = Inst.getOpcode();
1988
1989   if (Opcode == Mips::JalOneReg) {
1990     // jal $rs => jalr $rs
1991     if (inMicroMipsMode()) {
1992       JalrInst.setOpcode(Mips::JALR16_MM);
1993       JalrInst.addOperand(FirstRegOp);
1994     } else {
1995       JalrInst.setOpcode(Mips::JALR);
1996       JalrInst.addOperand(MCOperand::createReg(Mips::RA));
1997       JalrInst.addOperand(FirstRegOp);
1998     }
1999   } else if (Opcode == Mips::JalTwoReg) {
2000     // jal $rd, $rs => jalr $rd, $rs
2001     JalrInst.setOpcode(inMicroMipsMode() ? Mips::JALR_MM : Mips::JALR);
2002     JalrInst.addOperand(FirstRegOp);
2003     const MCOperand SecondRegOp = Inst.getOperand(1);
2004     JalrInst.addOperand(SecondRegOp);
2005   }
2006   Instructions.push_back(JalrInst);
2007
2008   // If .set reorder is active, emit a NOP after it.
2009   if (AssemblerOptions.back()->isReorder()) {
2010     // This is a 32-bit NOP because these 2 pseudo-instructions
2011     // do not have a short delay slot.
2012     MCInst NopInst;
2013     NopInst.setOpcode(Mips::SLL);
2014     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
2015     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
2016     NopInst.addOperand(MCOperand::createImm(0));
2017     Instructions.push_back(NopInst);
2018   }
2019
2020   return false;
2021 }
2022
2023 /// Can the value be represented by a unsigned N-bit value and a shift left?
2024 template<unsigned N>
2025 bool isShiftedUIntAtAnyPosition(uint64_t x) {
2026   unsigned BitNum = findFirstSet(x);
2027
2028   return (x == x >> BitNum << BitNum) && isUInt<N>(x >> BitNum);
2029 }
2030
2031 /// Load (or add) an immediate into a register.
2032 ///
2033 /// @param ImmValue     The immediate to load.
2034 /// @param DstReg       The register that will hold the immediate.
2035 /// @param SrcReg       A register to add to the immediate or Mips::NoRegister
2036 ///                     for a simple initialization.
2037 /// @param Is32BitImm   Is ImmValue 32-bit or 64-bit?
2038 /// @param IsAddress    True if the immediate represents an address. False if it
2039 ///                     is an integer.
2040 /// @param IDLoc        Location of the immediate in the source file.
2041 /// @param Instructions The instructions emitted by this expansion.
2042 bool MipsAsmParser::loadImmediate(int64_t ImmValue, unsigned DstReg,
2043                                   unsigned SrcReg, bool Is32BitImm,
2044                                   bool IsAddress, SMLoc IDLoc,
2045                                   SmallVectorImpl<MCInst> &Instructions) {
2046   if (!Is32BitImm && !isGP64bit()) {
2047     Error(IDLoc, "instruction requires a 64-bit architecture");
2048     return true;
2049   }
2050
2051   if (Is32BitImm) {
2052     if (isInt<32>(ImmValue) || isUInt<32>(ImmValue)) {
2053       // Sign extend up to 64-bit so that the predicates match the hardware
2054       // behaviour. In particular, isInt<16>(0xffff8000) and similar should be
2055       // true.
2056       ImmValue = SignExtend64<32>(ImmValue);
2057     } else {
2058       Error(IDLoc, "instruction requires a 32-bit immediate");
2059       return true;
2060     }
2061   }
2062
2063   unsigned ZeroReg = IsAddress ? ABI.GetNullPtr() : ABI.GetZeroReg();
2064   unsigned AdduOp = !Is32BitImm ? Mips::DADDu : Mips::ADDu;
2065
2066   bool UseSrcReg = false;
2067   if (SrcReg != Mips::NoRegister)
2068     UseSrcReg = true;
2069
2070   unsigned TmpReg = DstReg;
2071   if (UseSrcReg && (DstReg == SrcReg)) {
2072     // At this point we need AT to perform the expansions and we exit if it is
2073     // not available.
2074     unsigned ATReg = getATReg(IDLoc);
2075     if (!ATReg)
2076       return true;
2077     TmpReg = ATReg;
2078   }
2079
2080   if (isInt<16>(ImmValue)) {
2081     if (!UseSrcReg)
2082       SrcReg = ZeroReg;
2083
2084     // This doesn't quite follow the usual ABI expectations for N32 but matches
2085     // traditional assembler behaviour. N32 would normally use addiu for both
2086     // integers and addresses.
2087     if (IsAddress && !Is32BitImm) {
2088       emitRRI(Mips::DADDiu, DstReg, SrcReg, ImmValue, IDLoc, Instructions);
2089       return false;
2090     }
2091
2092     emitRRI(Mips::ADDiu, DstReg, SrcReg, ImmValue, IDLoc, Instructions);
2093     return false;
2094   }
2095
2096   if (isUInt<16>(ImmValue)) {
2097     unsigned TmpReg = DstReg;
2098     if (SrcReg == DstReg) {
2099       TmpReg = getATReg(IDLoc);
2100       if (!TmpReg)
2101         return true;
2102     }
2103
2104     emitRRI(Mips::ORi, TmpReg, ZeroReg, ImmValue, IDLoc, Instructions);
2105     if (UseSrcReg)
2106       emitRRR(ABI.GetPtrAdduOp(), DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2107     return false;
2108   }
2109
2110   if (isInt<32>(ImmValue) || isUInt<32>(ImmValue)) {
2111     warnIfNoMacro(IDLoc);
2112
2113     uint16_t Bits31To16 = (ImmValue >> 16) & 0xffff;
2114     uint16_t Bits15To0 = ImmValue & 0xffff;
2115
2116     if (!Is32BitImm && !isInt<32>(ImmValue)) {
2117       // Traditional behaviour seems to special case this particular value. It's
2118       // not clear why other masks are handled differently.
2119       if (ImmValue == 0xffffffff) {
2120         emitRI(Mips::LUi, TmpReg, 0xffff, IDLoc, Instructions);
2121         emitRRI(Mips::DSRL32, TmpReg, TmpReg, 0, IDLoc, Instructions);
2122         if (UseSrcReg)
2123           emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2124         return false;
2125       }
2126
2127       // Expand to an ORi instead of a LUi to avoid sign-extending into the
2128       // upper 32 bits.
2129       emitRRI(Mips::ORi, TmpReg, ZeroReg, Bits31To16, IDLoc, Instructions);
2130       emitRRI(Mips::DSLL, TmpReg, TmpReg, 16, IDLoc, Instructions);
2131       if (Bits15To0)
2132         emitRRI(Mips::ORi, TmpReg, TmpReg, Bits15To0, IDLoc, Instructions);
2133       if (UseSrcReg)
2134         emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2135       return false;
2136     }
2137
2138     emitRI(Mips::LUi, TmpReg, Bits31To16, IDLoc, Instructions);
2139     if (Bits15To0)
2140       emitRRI(Mips::ORi, TmpReg, TmpReg, Bits15To0, IDLoc, Instructions);
2141     if (UseSrcReg)
2142       emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2143     return false;
2144   }
2145
2146   if (isShiftedUIntAtAnyPosition<16>(ImmValue)) {
2147     if (Is32BitImm) {
2148       Error(IDLoc, "instruction requires a 32-bit immediate");
2149       return true;
2150     }
2151
2152     // Traditionally, these immediates are shifted as little as possible and as
2153     // such we align the most significant bit to bit 15 of our temporary.
2154     unsigned FirstSet = findFirstSet((uint64_t)ImmValue);
2155     unsigned LastSet = findLastSet((uint64_t)ImmValue);
2156     unsigned ShiftAmount = FirstSet - (15 - (LastSet - FirstSet));
2157     uint16_t Bits = (ImmValue >> ShiftAmount) & 0xffff;
2158     emitRRI(Mips::ORi, TmpReg, ZeroReg, Bits, IDLoc, Instructions);
2159     emitRRI(Mips::DSLL, TmpReg, TmpReg, ShiftAmount, IDLoc, Instructions);
2160
2161     if (UseSrcReg)
2162       emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2163
2164     return false;
2165   }
2166
2167   warnIfNoMacro(IDLoc);
2168
2169   // The remaining case is packed with a sequence of dsll and ori with zeros
2170   // being omitted and any neighbouring dsll's being coalesced.
2171   // The highest 32-bit's are equivalent to a 32-bit immediate load.
2172
2173   // Load bits 32-63 of ImmValue into bits 0-31 of the temporary register.
2174   if (loadImmediate(ImmValue >> 32, TmpReg, Mips::NoRegister, true, false,
2175                     IDLoc, Instructions))
2176     return false;
2177
2178   // Shift and accumulate into the register. If a 16-bit chunk is zero, then
2179   // skip it and defer the shift to the next chunk.
2180   unsigned ShiftCarriedForwards = 16;
2181   for (int BitNum = 16; BitNum >= 0; BitNum -= 16) {
2182     uint16_t ImmChunk = (ImmValue >> BitNum) & 0xffff;
2183
2184     if (ImmChunk != 0) {
2185       emitAppropriateDSLL(TmpReg, TmpReg, ShiftCarriedForwards, IDLoc,
2186                           Instructions);
2187       emitRRI(Mips::ORi, TmpReg, TmpReg, ImmChunk, IDLoc, Instructions);
2188       ShiftCarriedForwards = 0;
2189     }
2190
2191     ShiftCarriedForwards += 16;
2192   }
2193   ShiftCarriedForwards -= 16;
2194
2195   // Finish any remaining shifts left by trailing zeros.
2196   if (ShiftCarriedForwards)
2197     emitAppropriateDSLL(TmpReg, TmpReg, ShiftCarriedForwards, IDLoc,
2198                         Instructions);
2199
2200   if (UseSrcReg)
2201     emitRRR(AdduOp, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2202
2203   return false;
2204 }
2205
2206 bool MipsAsmParser::expandLoadImm(MCInst &Inst, bool Is32BitImm, SMLoc IDLoc,
2207                                   SmallVectorImpl<MCInst> &Instructions) {
2208   const MCOperand &ImmOp = Inst.getOperand(1);
2209   assert(ImmOp.isImm() && "expected immediate operand kind");
2210   const MCOperand &DstRegOp = Inst.getOperand(0);
2211   assert(DstRegOp.isReg() && "expected register operand kind");
2212
2213   if (loadImmediate(ImmOp.getImm(), DstRegOp.getReg(), Mips::NoRegister,
2214                     Is32BitImm, false, IDLoc, Instructions))
2215     return true;
2216
2217   return false;
2218 }
2219
2220 bool MipsAsmParser::expandLoadAddress(unsigned DstReg, unsigned BaseReg,
2221                                       const MCOperand &Offset,
2222                                       bool Is32BitAddress, SMLoc IDLoc,
2223                                       SmallVectorImpl<MCInst> &Instructions) {
2224   // la can't produce a usable address when addresses are 64-bit.
2225   if (Is32BitAddress && ABI.ArePtrs64bit()) {
2226     // FIXME: Demote this to a warning and continue as if we had 'dla' instead.
2227     //        We currently can't do this because we depend on the equality
2228     //        operator and N64 can end up with a GPR32/GPR64 mismatch.
2229     Error(IDLoc, "la used to load 64-bit address");
2230     // Continue as if we had 'dla' instead.
2231     Is32BitAddress = false;
2232   }
2233
2234   // dla requires 64-bit addresses.
2235   if (!Is32BitAddress && !ABI.ArePtrs64bit()) {
2236     Error(IDLoc, "instruction requires a 64-bit architecture");
2237     return true;
2238   }
2239
2240   if (!Offset.isImm())
2241     return loadAndAddSymbolAddress(Offset.getExpr(), DstReg, BaseReg,
2242                                    Is32BitAddress, IDLoc, Instructions);
2243
2244   return loadImmediate(Offset.getImm(), DstReg, BaseReg, Is32BitAddress, true,
2245                        IDLoc, Instructions);
2246 }
2247
2248 bool MipsAsmParser::loadAndAddSymbolAddress(
2249     const MCExpr *SymExpr, unsigned DstReg, unsigned SrcReg, bool Is32BitSym,
2250     SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
2251   warnIfNoMacro(IDLoc);
2252
2253   // FIXME: The way we're handling symbols right now prevents simple expressions
2254   //        like foo+8. We'll be able to fix this once our unary operators (%hi
2255   //        and similar) are treated as operators rather than as fixup types.
2256   const MCSymbolRefExpr *Symbol = cast<MCSymbolRefExpr>(SymExpr);
2257   const MCSymbolRefExpr *HiExpr = MCSymbolRefExpr::create(
2258       &Symbol->getSymbol(), MCSymbolRefExpr::VK_Mips_ABS_HI, getContext());
2259   const MCSymbolRefExpr *LoExpr = MCSymbolRefExpr::create(
2260       &Symbol->getSymbol(), MCSymbolRefExpr::VK_Mips_ABS_LO, getContext());
2261
2262   bool UseSrcReg = SrcReg != Mips::NoRegister;
2263
2264   // This is the 64-bit symbol address expansion.
2265   if (ABI.ArePtrs64bit() && isGP64bit()) {
2266     // We always need AT for the 64-bit expansion.
2267     // If it is not available we exit.
2268     unsigned ATReg = getATReg(IDLoc);
2269     if (!ATReg)
2270       return true;
2271
2272     const MCSymbolRefExpr *HighestExpr = MCSymbolRefExpr::create(
2273         &Symbol->getSymbol(), MCSymbolRefExpr::VK_Mips_HIGHEST, getContext());
2274     const MCSymbolRefExpr *HigherExpr = MCSymbolRefExpr::create(
2275         &Symbol->getSymbol(), MCSymbolRefExpr::VK_Mips_HIGHER, getContext());
2276
2277     if (UseSrcReg && (DstReg == SrcReg)) {
2278       // If $rs is the same as $rd:
2279       // (d)la $rd, sym($rd) => lui    $at, %highest(sym)
2280       //                        daddiu $at, $at, %higher(sym)
2281       //                        dsll   $at, $at, 16
2282       //                        daddiu $at, $at, %hi(sym)
2283       //                        dsll   $at, $at, 16
2284       //                        daddiu $at, $at, %lo(sym)
2285       //                        daddu  $rd, $at, $rd
2286       emitRX(Mips::LUi, ATReg, MCOperand::createExpr(HighestExpr), IDLoc,
2287              Instructions);
2288       emitRRX(Mips::DADDiu, ATReg, ATReg, MCOperand::createExpr(HigherExpr),
2289               IDLoc, Instructions);
2290       emitRRI(Mips::DSLL, ATReg, ATReg, 16, IDLoc, Instructions);
2291       emitRRX(Mips::DADDiu, ATReg, ATReg, MCOperand::createExpr(HiExpr), IDLoc,
2292               Instructions);
2293       emitRRI(Mips::DSLL, ATReg, ATReg, 16, IDLoc, Instructions);
2294       emitRRX(Mips::DADDiu, ATReg, ATReg, MCOperand::createExpr(LoExpr), IDLoc,
2295               Instructions);
2296       emitRRR(Mips::DADDu, DstReg, ATReg, SrcReg, IDLoc, Instructions);
2297
2298       return false;
2299     }
2300
2301     // Otherwise, if the $rs is different from $rd or if $rs isn't specified:
2302     // (d)la $rd, sym/sym($rs) => lui    $rd, %highest(sym)
2303     //                            lui    $at, %hi(sym)
2304     //                            daddiu $rd, $rd, %higher(sym)
2305     //                            daddiu $at, $at, %lo(sym)
2306     //                            dsll32 $rd, $rd, 0
2307     //                            daddu  $rd, $rd, $at
2308     //                            (daddu  $rd, $rd, $rs)
2309     emitRX(Mips::LUi, DstReg, MCOperand::createExpr(HighestExpr), IDLoc,
2310            Instructions);
2311     emitRX(Mips::LUi, ATReg, MCOperand::createExpr(HiExpr), IDLoc,
2312            Instructions);
2313     emitRRX(Mips::DADDiu, DstReg, DstReg, MCOperand::createExpr(HigherExpr),
2314             IDLoc, Instructions);
2315     emitRRX(Mips::DADDiu, ATReg, ATReg, MCOperand::createExpr(LoExpr), IDLoc,
2316             Instructions);
2317     emitRRI(Mips::DSLL32, DstReg, DstReg, 0, IDLoc, Instructions);
2318     emitRRR(Mips::DADDu, DstReg, DstReg, ATReg, IDLoc, Instructions);
2319     if (UseSrcReg)
2320       emitRRR(Mips::DADDu, DstReg, DstReg, SrcReg, IDLoc, Instructions);
2321
2322     return false;
2323   }
2324
2325   // And now, the 32-bit symbol address expansion:
2326   // If $rs is the same as $rd:
2327   // (d)la $rd, sym($rd)     => lui   $at, %hi(sym)
2328   //                            ori   $at, $at, %lo(sym)
2329   //                            addu  $rd, $at, $rd
2330   // Otherwise, if the $rs is different from $rd or if $rs isn't specified:
2331   // (d)la $rd, sym/sym($rs) => lui   $rd, %hi(sym)
2332   //                            ori   $rd, $rd, %lo(sym)
2333   //                            (addu $rd, $rd, $rs)
2334   unsigned TmpReg = DstReg;
2335   if (UseSrcReg && (DstReg == SrcReg)) {
2336     // If $rs is the same as $rd, we need to use AT.
2337     // If it is not available we exit.
2338     unsigned ATReg = getATReg(IDLoc);
2339     if (!ATReg)
2340       return true;
2341     TmpReg = ATReg;
2342   }
2343
2344   emitRX(Mips::LUi, TmpReg, MCOperand::createExpr(HiExpr), IDLoc, Instructions);
2345   emitRRX(Mips::ADDiu, TmpReg, TmpReg, MCOperand::createExpr(LoExpr), IDLoc,
2346           Instructions);
2347
2348   if (UseSrcReg)
2349     emitRRR(Mips::ADDu, DstReg, TmpReg, SrcReg, IDLoc, Instructions);
2350   else
2351     assert(DstReg == TmpReg);
2352
2353   return false;
2354 }
2355
2356 bool MipsAsmParser::expandUncondBranchMMPseudo(
2357     MCInst &Inst, SMLoc IDLoc, SmallVectorImpl<MCInst> &Instructions) {
2358   assert(getInstDesc(Inst.getOpcode()).getNumOperands() == 1 &&
2359          "unexpected number of operands");
2360
2361   MCOperand Offset = Inst.getOperand(0);
2362   if (Offset.isExpr()) {
2363     Inst.clear();
2364     Inst.setOpcode(Mips::BEQ_MM);
2365     Inst.addOperand(MCOperand::createReg(Mips::ZERO));
2366     Inst.addOperand(MCOperand::createReg(Mips::ZERO));
2367     Inst.addOperand(MCOperand::createExpr(Offset.getExpr()));
2368   } else {
2369     assert(Offset.isImm() && "expected immediate operand kind");
2370     if (isIntN(11, Offset.getImm())) {
2371       // If offset fits into 11 bits then this instruction becomes microMIPS
2372       // 16-bit unconditional branch instruction.
2373       Inst.setOpcode(Mips::B16_MM);
2374     } else {
2375       if (!isIntN(17, Offset.getImm()))
2376         Error(IDLoc, "branch target out of range");
2377       if (OffsetToAlignment(Offset.getImm(), 1LL << 1))
2378         Error(IDLoc, "branch to misaligned address");
2379       Inst.clear();
2380       Inst.setOpcode(Mips::BEQ_MM);
2381       Inst.addOperand(MCOperand::createReg(Mips::ZERO));
2382       Inst.addOperand(MCOperand::createReg(Mips::ZERO));
2383       Inst.addOperand(MCOperand::createImm(Offset.getImm()));
2384     }
2385   }
2386   Instructions.push_back(Inst);
2387
2388   // If .set reorder is active, emit a NOP after the branch instruction.
2389   if (AssemblerOptions.back()->isReorder())
2390     createNop(true, IDLoc, Instructions);
2391
2392   return false;
2393 }
2394
2395 bool MipsAsmParser::expandBranchImm(MCInst &Inst, SMLoc IDLoc,
2396                                     SmallVectorImpl<MCInst> &Instructions) {
2397   const MCOperand &DstRegOp = Inst.getOperand(0);
2398   assert(DstRegOp.isReg() && "expected register operand kind");
2399
2400   const MCOperand &ImmOp = Inst.getOperand(1);
2401   assert(ImmOp.isImm() && "expected immediate operand kind");
2402
2403   const MCOperand &MemOffsetOp = Inst.getOperand(2);
2404   assert(MemOffsetOp.isImm() && "expected immediate operand kind");
2405
2406   unsigned OpCode = 0;
2407   switch(Inst.getOpcode()) {
2408     case Mips::BneImm:
2409       OpCode = Mips::BNE;
2410       break;
2411     case Mips::BeqImm:
2412       OpCode = Mips::BEQ;
2413       break;
2414     default:
2415       llvm_unreachable("Unknown immediate branch pseudo-instruction.");
2416       break;
2417   }
2418
2419   int64_t ImmValue = ImmOp.getImm();
2420   if (ImmValue == 0) {
2421     MCInst BranchInst;
2422     BranchInst.setOpcode(OpCode);
2423     BranchInst.addOperand(DstRegOp);
2424     BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2425     BranchInst.addOperand(MemOffsetOp);
2426     Instructions.push_back(BranchInst);
2427   } else {
2428     warnIfNoMacro(IDLoc);
2429
2430     unsigned ATReg = getATReg(IDLoc);
2431     if (!ATReg)
2432       return true;
2433
2434     if (loadImmediate(ImmValue, ATReg, Mips::NoRegister, !isGP64bit(), true,
2435                       IDLoc, Instructions))
2436       return true;
2437
2438     MCInst BranchInst;
2439     BranchInst.setOpcode(OpCode);
2440     BranchInst.addOperand(DstRegOp);
2441     BranchInst.addOperand(MCOperand::createReg(ATReg));
2442     BranchInst.addOperand(MemOffsetOp);
2443     Instructions.push_back(BranchInst);
2444   }
2445   return false;
2446 }
2447
2448 void MipsAsmParser::expandMemInst(MCInst &Inst, SMLoc IDLoc,
2449                                   SmallVectorImpl<MCInst> &Instructions,
2450                                   bool isLoad, bool isImmOpnd) {
2451   MCInst TempInst;
2452   unsigned ImmOffset, HiOffset, LoOffset;
2453   const MCExpr *ExprOffset;
2454   unsigned TmpRegNum;
2455   // 1st operand is either the source or destination register.
2456   assert(Inst.getOperand(0).isReg() && "expected register operand kind");
2457   unsigned RegOpNum = Inst.getOperand(0).getReg();
2458   // 2nd operand is the base register.
2459   assert(Inst.getOperand(1).isReg() && "expected register operand kind");
2460   unsigned BaseRegNum = Inst.getOperand(1).getReg();
2461   // 3rd operand is either an immediate or expression.
2462   if (isImmOpnd) {
2463     assert(Inst.getOperand(2).isImm() && "expected immediate operand kind");
2464     ImmOffset = Inst.getOperand(2).getImm();
2465     LoOffset = ImmOffset & 0x0000ffff;
2466     HiOffset = (ImmOffset & 0xffff0000) >> 16;
2467     // If msb of LoOffset is 1(negative number) we must increment HiOffset.
2468     if (LoOffset & 0x8000)
2469       HiOffset++;
2470   } else
2471     ExprOffset = Inst.getOperand(2).getExpr();
2472   // All instructions will have the same location.
2473   TempInst.setLoc(IDLoc);
2474   // These are some of the types of expansions we perform here:
2475   // 1) lw $8, sym        => lui $8, %hi(sym)
2476   //                         lw $8, %lo(sym)($8)
2477   // 2) lw $8, offset($9) => lui $8, %hi(offset)
2478   //                         add $8, $8, $9
2479   //                         lw $8, %lo(offset)($9)
2480   // 3) lw $8, offset($8) => lui $at, %hi(offset)
2481   //                         add $at, $at, $8
2482   //                         lw $8, %lo(offset)($at)
2483   // 4) sw $8, sym        => lui $at, %hi(sym)
2484   //                         sw $8, %lo(sym)($at)
2485   // 5) sw $8, offset($8) => lui $at, %hi(offset)
2486   //                         add $at, $at, $8
2487   //                         sw $8, %lo(offset)($at)
2488   // 6) ldc1 $f0, sym     => lui $at, %hi(sym)
2489   //                         ldc1 $f0, %lo(sym)($at)
2490   //
2491   // For load instructions we can use the destination register as a temporary
2492   // if base and dst are different (examples 1 and 2) and if the base register
2493   // is general purpose otherwise we must use $at (example 6) and error if it's
2494   // not available. For stores we must use $at (examples 4 and 5) because we
2495   // must not clobber the source register setting up the offset.
2496   const MCInstrDesc &Desc = getInstDesc(Inst.getOpcode());
2497   int16_t RegClassOp0 = Desc.OpInfo[0].RegClass;
2498   unsigned RegClassIDOp0 =
2499       getContext().getRegisterInfo()->getRegClass(RegClassOp0).getID();
2500   bool IsGPR = (RegClassIDOp0 == Mips::GPR32RegClassID) ||
2501                (RegClassIDOp0 == Mips::GPR64RegClassID);
2502   if (isLoad && IsGPR && (BaseRegNum != RegOpNum))
2503     TmpRegNum = RegOpNum;
2504   else {
2505     // At this point we need AT to perform the expansions and we exit if it is
2506     // not available.
2507     TmpRegNum = getATReg(IDLoc);
2508     if (!TmpRegNum)
2509       return;
2510   }
2511
2512   TempInst.setOpcode(Mips::LUi);
2513   TempInst.addOperand(MCOperand::createReg(TmpRegNum));
2514   if (isImmOpnd)
2515     TempInst.addOperand(MCOperand::createImm(HiOffset));
2516   else {
2517     const MCExpr *HiExpr = evaluateRelocExpr(ExprOffset, "hi");
2518     TempInst.addOperand(MCOperand::createExpr(HiExpr));
2519   }
2520   // Add the instruction to the list.
2521   Instructions.push_back(TempInst);
2522   // Prepare TempInst for next instruction.
2523   TempInst.clear();
2524   // Add temp register to base.
2525   if (BaseRegNum != Mips::ZERO) {
2526     TempInst.setOpcode(Mips::ADDu);
2527     TempInst.addOperand(MCOperand::createReg(TmpRegNum));
2528     TempInst.addOperand(MCOperand::createReg(TmpRegNum));
2529     TempInst.addOperand(MCOperand::createReg(BaseRegNum));
2530     Instructions.push_back(TempInst);
2531     TempInst.clear();
2532   }
2533   // And finally, create original instruction with low part
2534   // of offset and new base.
2535   TempInst.setOpcode(Inst.getOpcode());
2536   TempInst.addOperand(MCOperand::createReg(RegOpNum));
2537   TempInst.addOperand(MCOperand::createReg(TmpRegNum));
2538   if (isImmOpnd)
2539     TempInst.addOperand(MCOperand::createImm(LoOffset));
2540   else {
2541     const MCExpr *LoExpr = evaluateRelocExpr(ExprOffset, "lo");
2542     TempInst.addOperand(MCOperand::createExpr(LoExpr));
2543   }
2544   Instructions.push_back(TempInst);
2545   TempInst.clear();
2546 }
2547
2548 bool
2549 MipsAsmParser::expandLoadStoreMultiple(MCInst &Inst, SMLoc IDLoc,
2550                                        SmallVectorImpl<MCInst> &Instructions) {
2551   unsigned OpNum = Inst.getNumOperands();
2552   unsigned Opcode = Inst.getOpcode();
2553   unsigned NewOpcode = Opcode == Mips::SWM_MM ? Mips::SWM32_MM : Mips::LWM32_MM;
2554
2555   assert (Inst.getOperand(OpNum - 1).isImm() &&
2556           Inst.getOperand(OpNum - 2).isReg() &&
2557           Inst.getOperand(OpNum - 3).isReg() && "Invalid instruction operand.");
2558
2559   if (OpNum < 8 && Inst.getOperand(OpNum - 1).getImm() <= 60 &&
2560       Inst.getOperand(OpNum - 1).getImm() >= 0 &&
2561       Inst.getOperand(OpNum - 2).getReg() == Mips::SP &&
2562       Inst.getOperand(OpNum - 3).getReg() == Mips::RA)
2563     // It can be implemented as SWM16 or LWM16 instruction.
2564     NewOpcode = Opcode == Mips::SWM_MM ? Mips::SWM16_MM : Mips::LWM16_MM;
2565
2566   Inst.setOpcode(NewOpcode);
2567   Instructions.push_back(Inst);
2568   return false;
2569 }
2570
2571 bool MipsAsmParser::expandCondBranches(MCInst &Inst, SMLoc IDLoc,
2572                                        SmallVectorImpl<MCInst> &Instructions) {
2573   unsigned PseudoOpcode = Inst.getOpcode();
2574   unsigned SrcReg = Inst.getOperand(0).getReg();
2575   unsigned TrgReg = Inst.getOperand(1).getReg();
2576   const MCExpr *OffsetExpr = Inst.getOperand(2).getExpr();
2577
2578   unsigned ZeroSrcOpcode, ZeroTrgOpcode;
2579   bool ReverseOrderSLT, IsUnsigned, AcceptsEquality;
2580
2581   switch (PseudoOpcode) {
2582   case Mips::BLT:
2583   case Mips::BLTU:
2584     AcceptsEquality = false;
2585     ReverseOrderSLT = false;
2586     IsUnsigned = (PseudoOpcode == Mips::BLTU);
2587     ZeroSrcOpcode = Mips::BGTZ;
2588     ZeroTrgOpcode = Mips::BLTZ;
2589     break;
2590   case Mips::BLE:
2591   case Mips::BLEU:
2592     AcceptsEquality = true;
2593     ReverseOrderSLT = true;
2594     IsUnsigned = (PseudoOpcode == Mips::BLEU);
2595     ZeroSrcOpcode = Mips::BGEZ;
2596     ZeroTrgOpcode = Mips::BLEZ;
2597     break;
2598   case Mips::BGE:
2599   case Mips::BGEU:
2600     AcceptsEquality = true;
2601     ReverseOrderSLT = false;
2602     IsUnsigned = (PseudoOpcode == Mips::BGEU);
2603     ZeroSrcOpcode = Mips::BLEZ;
2604     ZeroTrgOpcode = Mips::BGEZ;
2605     break;
2606   case Mips::BGT:
2607   case Mips::BGTU:
2608     AcceptsEquality = false;
2609     ReverseOrderSLT = true;
2610     IsUnsigned = (PseudoOpcode == Mips::BGTU);
2611     ZeroSrcOpcode = Mips::BLTZ;
2612     ZeroTrgOpcode = Mips::BGTZ;
2613     break;
2614   default:
2615     llvm_unreachable("unknown opcode for branch pseudo-instruction");
2616   }
2617
2618   MCInst BranchInst;
2619   bool IsTrgRegZero = (TrgReg == Mips::ZERO);
2620   bool IsSrcRegZero = (SrcReg == Mips::ZERO);
2621   if (IsSrcRegZero && IsTrgRegZero) {
2622     // FIXME: All of these Opcode-specific if's are needed for compatibility
2623     // with GAS' behaviour. However, they may not generate the most efficient
2624     // code in some circumstances.
2625     if (PseudoOpcode == Mips::BLT) {
2626       BranchInst.setOpcode(Mips::BLTZ);
2627       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2628       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2629       Instructions.push_back(BranchInst);
2630       return false;
2631     }
2632     if (PseudoOpcode == Mips::BLE) {
2633       BranchInst.setOpcode(Mips::BLEZ);
2634       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2635       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2636       Instructions.push_back(BranchInst);
2637       Warning(IDLoc, "branch is always taken");
2638       return false;
2639     }
2640     if (PseudoOpcode == Mips::BGE) {
2641       BranchInst.setOpcode(Mips::BGEZ);
2642       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2643       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2644       Instructions.push_back(BranchInst);
2645       Warning(IDLoc, "branch is always taken");
2646       return false;
2647     }
2648     if (PseudoOpcode == Mips::BGT) {
2649       BranchInst.setOpcode(Mips::BGTZ);
2650       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2651       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2652       Instructions.push_back(BranchInst);
2653       return false;
2654     }
2655     if (PseudoOpcode == Mips::BGTU) {
2656       BranchInst.setOpcode(Mips::BNE);
2657       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2658       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2659       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2660       Instructions.push_back(BranchInst);
2661       return false;
2662     }
2663     if (AcceptsEquality) {
2664       // If both registers are $0 and the pseudo-branch accepts equality, it
2665       // will always be taken, so we emit an unconditional branch.
2666       BranchInst.setOpcode(Mips::BEQ);
2667       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2668       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2669       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2670       Instructions.push_back(BranchInst);
2671       Warning(IDLoc, "branch is always taken");
2672       return false;
2673     }
2674     // If both registers are $0 and the pseudo-branch does not accept
2675     // equality, it will never be taken, so we don't have to emit anything.
2676     return false;
2677   }
2678   if (IsSrcRegZero || IsTrgRegZero) {
2679     if ((IsSrcRegZero && PseudoOpcode == Mips::BGTU) ||
2680         (IsTrgRegZero && PseudoOpcode == Mips::BLTU)) {
2681       // If the $rs is $0 and the pseudo-branch is BGTU (0 > x) or
2682       // if the $rt is $0 and the pseudo-branch is BLTU (x < 0),
2683       // the pseudo-branch will never be taken, so we don't emit anything.
2684       // This only applies to unsigned pseudo-branches.
2685       return false;
2686     }
2687     if ((IsSrcRegZero && PseudoOpcode == Mips::BLEU) ||
2688         (IsTrgRegZero && PseudoOpcode == Mips::BGEU)) {
2689       // If the $rs is $0 and the pseudo-branch is BLEU (0 <= x) or
2690       // if the $rt is $0 and the pseudo-branch is BGEU (x >= 0),
2691       // the pseudo-branch will always be taken, so we emit an unconditional
2692       // branch.
2693       // This only applies to unsigned pseudo-branches.
2694       BranchInst.setOpcode(Mips::BEQ);
2695       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2696       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2697       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2698       Instructions.push_back(BranchInst);
2699       Warning(IDLoc, "branch is always taken");
2700       return false;
2701     }
2702     if (IsUnsigned) {
2703       // If the $rs is $0 and the pseudo-branch is BLTU (0 < x) or
2704       // if the $rt is $0 and the pseudo-branch is BGTU (x > 0),
2705       // the pseudo-branch will be taken only when the non-zero register is
2706       // different from 0, so we emit a BNEZ.
2707       //
2708       // If the $rs is $0 and the pseudo-branch is BGEU (0 >= x) or
2709       // if the $rt is $0 and the pseudo-branch is BLEU (x <= 0),
2710       // the pseudo-branch will be taken only when the non-zero register is
2711       // equal to 0, so we emit a BEQZ.
2712       //
2713       // Because only BLEU and BGEU branch on equality, we can use the
2714       // AcceptsEquality variable to decide when to emit the BEQZ.
2715       BranchInst.setOpcode(AcceptsEquality ? Mips::BEQ : Mips::BNE);
2716       BranchInst.addOperand(
2717           MCOperand::createReg(IsSrcRegZero ? TrgReg : SrcReg));
2718       BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2719       BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2720       Instructions.push_back(BranchInst);
2721       return false;
2722     }
2723     // If we have a signed pseudo-branch and one of the registers is $0,
2724     // we can use an appropriate compare-to-zero branch. We select which one
2725     // to use in the switch statement above.
2726     BranchInst.setOpcode(IsSrcRegZero ? ZeroSrcOpcode : ZeroTrgOpcode);
2727     BranchInst.addOperand(MCOperand::createReg(IsSrcRegZero ? TrgReg : SrcReg));
2728     BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2729     Instructions.push_back(BranchInst);
2730     return false;
2731   }
2732
2733   // If neither the SrcReg nor the TrgReg are $0, we need AT to perform the
2734   // expansions. If it is not available, we return.
2735   unsigned ATRegNum = getATReg(IDLoc);
2736   if (!ATRegNum)
2737     return true;
2738
2739   warnIfNoMacro(IDLoc);
2740
2741   // SLT fits well with 2 of our 4 pseudo-branches:
2742   //   BLT, where $rs < $rt, translates into "slt $at, $rs, $rt" and
2743   //   BGT, where $rs > $rt, translates into "slt $at, $rt, $rs".
2744   // If the result of the SLT is 1, we branch, and if it's 0, we don't.
2745   // This is accomplished by using a BNEZ with the result of the SLT.
2746   //
2747   // The other 2 pseudo-branches are opposites of the above 2 (BGE with BLT
2748   // and BLE with BGT), so we change the BNEZ into a a BEQZ.
2749   // Because only BGE and BLE branch on equality, we can use the
2750   // AcceptsEquality variable to decide when to emit the BEQZ.
2751   // Note that the order of the SLT arguments doesn't change between
2752   // opposites.
2753   //
2754   // The same applies to the unsigned variants, except that SLTu is used
2755   // instead of SLT.
2756   MCInst SetInst;
2757   SetInst.setOpcode(IsUnsigned ? Mips::SLTu : Mips::SLT);
2758   SetInst.addOperand(MCOperand::createReg(ATRegNum));
2759   SetInst.addOperand(MCOperand::createReg(ReverseOrderSLT ? TrgReg : SrcReg));
2760   SetInst.addOperand(MCOperand::createReg(ReverseOrderSLT ? SrcReg : TrgReg));
2761   Instructions.push_back(SetInst);
2762
2763   BranchInst.setOpcode(AcceptsEquality ? Mips::BEQ : Mips::BNE);
2764   BranchInst.addOperand(MCOperand::createReg(ATRegNum));
2765   BranchInst.addOperand(MCOperand::createReg(Mips::ZERO));
2766   BranchInst.addOperand(MCOperand::createExpr(OffsetExpr));
2767   Instructions.push_back(BranchInst);
2768   return false;
2769 }
2770
2771 bool MipsAsmParser::expandDiv(MCInst &Inst, SMLoc IDLoc,
2772                               SmallVectorImpl<MCInst> &Instructions,
2773                               const bool IsMips64, const bool Signed) {
2774   if (hasMips32r6()) {
2775     Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
2776     return false;
2777   }
2778
2779   warnIfNoMacro(IDLoc);
2780
2781   const MCOperand &RsRegOp = Inst.getOperand(0);
2782   assert(RsRegOp.isReg() && "expected register operand kind");
2783   unsigned RsReg = RsRegOp.getReg();
2784
2785   const MCOperand &RtRegOp = Inst.getOperand(1);
2786   assert(RtRegOp.isReg() && "expected register operand kind");
2787   unsigned RtReg = RtRegOp.getReg();
2788   unsigned DivOp;
2789   unsigned ZeroReg;
2790
2791   if (IsMips64) {
2792     DivOp = Signed ? Mips::DSDIV : Mips::DUDIV;
2793     ZeroReg = Mips::ZERO_64;
2794   } else {
2795     DivOp = Signed ? Mips::SDIV : Mips::UDIV;
2796     ZeroReg = Mips::ZERO;
2797   }
2798
2799   bool UseTraps = useTraps();
2800
2801   if (RsReg == Mips::ZERO || RsReg == Mips::ZERO_64) {
2802     if (RtReg == Mips::ZERO || RtReg == Mips::ZERO_64)
2803       Warning(IDLoc, "dividing zero by zero");
2804     if (IsMips64) {
2805       if (Signed && (RtReg == Mips::ZERO || RtReg == Mips::ZERO_64)) {
2806         if (UseTraps) {
2807           emitRRI(Mips::TEQ, RtReg, ZeroReg, 0x7, IDLoc, Instructions);
2808           return false;
2809         }
2810
2811         emitII(Mips::BREAK, 0x7, 0, IDLoc, Instructions);
2812         return false;
2813       }
2814     } else {
2815       emitRR(DivOp, RsReg, RtReg, IDLoc, Instructions);
2816       return false;
2817     }
2818   }
2819
2820   if (RtReg == Mips::ZERO || RtReg == Mips::ZERO_64) {
2821     Warning(IDLoc, "division by zero");
2822     if (Signed) {
2823       if (UseTraps) {
2824         emitRRI(Mips::TEQ, RtReg, ZeroReg, 0x7, IDLoc, Instructions);
2825         return false;
2826       }
2827
2828       emitII(Mips::BREAK, 0x7, 0, IDLoc, Instructions);
2829       return false;
2830     }
2831   }
2832
2833   // FIXME: The values for these two BranchTarget variables may be different in
2834   // micromips. These magic numbers need to be removed.
2835   unsigned BranchTargetNoTraps;
2836   unsigned BranchTarget;
2837
2838   if (UseTraps) {
2839     BranchTarget = IsMips64 ? 12 : 8;
2840     emitRRI(Mips::TEQ, RtReg, ZeroReg, 0x7, IDLoc, Instructions);
2841   } else {
2842     BranchTarget = IsMips64 ? 20 : 16;
2843     BranchTargetNoTraps = 8;
2844     // Branch to the li instruction.
2845     emitRRI(Mips::BNE, RtReg, ZeroReg, BranchTargetNoTraps, IDLoc,
2846             Instructions);
2847   }
2848
2849   emitRR(DivOp, RsReg, RtReg, IDLoc, Instructions);
2850
2851   if (!UseTraps)
2852     emitII(Mips::BREAK, 0x7, 0, IDLoc, Instructions);
2853
2854   if (!Signed) {
2855     emitR(Mips::MFLO, RsReg, IDLoc, Instructions);
2856     return false;
2857   }
2858
2859   unsigned ATReg = getATReg(IDLoc);
2860   if (!ATReg)
2861     return true;
2862
2863   emitRRI(Mips::ADDiu, ATReg, ZeroReg, -1, IDLoc, Instructions);
2864   if (IsMips64) {
2865     // Branch to the mflo instruction.
2866     emitRRI(Mips::BNE, RtReg, ATReg, BranchTarget, IDLoc, Instructions);
2867     emitRRI(Mips::ADDiu, ATReg, ZeroReg, 1, IDLoc, Instructions);
2868     emitRRI(Mips::DSLL32, ATReg, ATReg, 0x1f, IDLoc, Instructions);
2869   } else {
2870     // Branch to the mflo instruction.
2871     emitRRI(Mips::BNE, RtReg, ATReg, BranchTarget, IDLoc, Instructions);
2872     emitRI(Mips::LUi, ATReg, (uint16_t)0x8000, IDLoc, Instructions);
2873   }
2874
2875   if (UseTraps)
2876     emitRRI(Mips::TEQ, RsReg, ATReg, 0x6, IDLoc, Instructions);
2877   else {
2878     // Branch to the mflo instruction.
2879     emitRRI(Mips::BNE, RsReg, ATReg, BranchTargetNoTraps, IDLoc, Instructions);
2880     emitRRI(Mips::SLL, ZeroReg, ZeroReg, 0, IDLoc, Instructions);
2881     emitII(Mips::BREAK, 0x6, 0, IDLoc, Instructions);
2882   }
2883   emitR(Mips::MFLO, RsReg, IDLoc, Instructions);
2884   return false;
2885 }
2886
2887 bool MipsAsmParser::expandUlhu(MCInst &Inst, SMLoc IDLoc,
2888                                SmallVectorImpl<MCInst> &Instructions) {
2889   if (hasMips32r6() || hasMips64r6()) {
2890     Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
2891     return false;
2892   }
2893
2894   warnIfNoMacro(IDLoc);
2895
2896   const MCOperand &DstRegOp = Inst.getOperand(0);
2897   assert(DstRegOp.isReg() && "expected register operand kind");
2898
2899   const MCOperand &SrcRegOp = Inst.getOperand(1);
2900   assert(SrcRegOp.isReg() && "expected register operand kind");
2901
2902   const MCOperand &OffsetImmOp = Inst.getOperand(2);
2903   assert(OffsetImmOp.isImm() && "expected immediate operand kind");
2904
2905   unsigned DstReg = DstRegOp.getReg();
2906   unsigned SrcReg = SrcRegOp.getReg();
2907   int64_t OffsetValue = OffsetImmOp.getImm();
2908
2909   // NOTE: We always need AT for ULHU, as it is always used as the source
2910   // register for one of the LBu's.
2911   unsigned ATReg = getATReg(IDLoc);
2912   if (!ATReg)
2913     return true;
2914
2915   // When the value of offset+1 does not fit in 16 bits, we have to load the
2916   // offset in AT, (D)ADDu the original source register (if there was one), and
2917   // then use AT as the source register for the 2 generated LBu's.
2918   bool LoadedOffsetInAT = false;
2919   if (!isInt<16>(OffsetValue + 1) || !isInt<16>(OffsetValue)) {
2920     LoadedOffsetInAT = true;
2921
2922     if (loadImmediate(OffsetValue, ATReg, Mips::NoRegister, !ABI.ArePtrs64bit(),
2923                       true, IDLoc, Instructions))
2924       return true;
2925
2926     // NOTE: We do this (D)ADDu here instead of doing it in loadImmediate()
2927     // because it will make our output more similar to GAS'. For example,
2928     // generating an "ori $1, $zero, 32768" followed by an "addu $1, $1, $9",
2929     // instead of just an "ori $1, $9, 32768".
2930     // NOTE: If there is no source register specified in the ULHU, the parser
2931     // will interpret it as $0.
2932     if (SrcReg != Mips::ZERO && SrcReg != Mips::ZERO_64)
2933       createAddu(ATReg, ATReg, SrcReg, ABI.ArePtrs64bit(), Instructions);
2934   }
2935
2936   unsigned FirstLbuDstReg = LoadedOffsetInAT ? DstReg : ATReg;
2937   unsigned SecondLbuDstReg = LoadedOffsetInAT ? ATReg : DstReg;
2938   unsigned LbuSrcReg = LoadedOffsetInAT ? ATReg : SrcReg;
2939
2940   int64_t FirstLbuOffset = 0, SecondLbuOffset = 0;
2941   if (isLittle()) {
2942     FirstLbuOffset = LoadedOffsetInAT ? 1 : (OffsetValue + 1);
2943     SecondLbuOffset = LoadedOffsetInAT ? 0 : OffsetValue;
2944   } else {
2945     FirstLbuOffset = LoadedOffsetInAT ? 0 : OffsetValue;
2946     SecondLbuOffset = LoadedOffsetInAT ? 1 : (OffsetValue + 1);
2947   }
2948
2949   unsigned SllReg = LoadedOffsetInAT ? DstReg : ATReg;
2950
2951   MCInst TmpInst;
2952   TmpInst.setOpcode(Mips::LBu);
2953   TmpInst.addOperand(MCOperand::createReg(FirstLbuDstReg));
2954   TmpInst.addOperand(MCOperand::createReg(LbuSrcReg));
2955   TmpInst.addOperand(MCOperand::createImm(FirstLbuOffset));
2956   Instructions.push_back(TmpInst);
2957
2958   TmpInst.clear();
2959   TmpInst.setOpcode(Mips::LBu);
2960   TmpInst.addOperand(MCOperand::createReg(SecondLbuDstReg));
2961   TmpInst.addOperand(MCOperand::createReg(LbuSrcReg));
2962   TmpInst.addOperand(MCOperand::createImm(SecondLbuOffset));
2963   Instructions.push_back(TmpInst);
2964
2965   TmpInst.clear();
2966   TmpInst.setOpcode(Mips::SLL);
2967   TmpInst.addOperand(MCOperand::createReg(SllReg));
2968   TmpInst.addOperand(MCOperand::createReg(SllReg));
2969   TmpInst.addOperand(MCOperand::createImm(8));
2970   Instructions.push_back(TmpInst);
2971
2972   TmpInst.clear();
2973   TmpInst.setOpcode(Mips::OR);
2974   TmpInst.addOperand(MCOperand::createReg(DstReg));
2975   TmpInst.addOperand(MCOperand::createReg(DstReg));
2976   TmpInst.addOperand(MCOperand::createReg(ATReg));
2977   Instructions.push_back(TmpInst);
2978
2979   return false;
2980 }
2981
2982 bool MipsAsmParser::expandUlw(MCInst &Inst, SMLoc IDLoc,
2983                               SmallVectorImpl<MCInst> &Instructions) {
2984   if (hasMips32r6() || hasMips64r6()) {
2985     Error(IDLoc, "instruction not supported on mips32r6 or mips64r6");
2986     return false;
2987   }
2988
2989   const MCOperand &DstRegOp = Inst.getOperand(0);
2990   assert(DstRegOp.isReg() && "expected register operand kind");
2991
2992   const MCOperand &SrcRegOp = Inst.getOperand(1);
2993   assert(SrcRegOp.isReg() && "expected register operand kind");
2994
2995   const MCOperand &OffsetImmOp = Inst.getOperand(2);
2996   assert(OffsetImmOp.isImm() && "expected immediate operand kind");
2997
2998   unsigned SrcReg = SrcRegOp.getReg();
2999   int64_t OffsetValue = OffsetImmOp.getImm();
3000   unsigned ATReg = 0;
3001
3002   // When the value of offset+3 does not fit in 16 bits, we have to load the
3003   // offset in AT, (D)ADDu the original source register (if there was one), and
3004   // then use AT as the source register for the generated LWL and LWR.
3005   bool LoadedOffsetInAT = false;
3006   if (!isInt<16>(OffsetValue + 3) || !isInt<16>(OffsetValue)) {
3007     ATReg = getATReg(IDLoc);
3008     if (!ATReg)
3009       return true;
3010     LoadedOffsetInAT = true;
3011
3012     warnIfNoMacro(IDLoc);
3013
3014     if (loadImmediate(OffsetValue, ATReg, Mips::NoRegister, !ABI.ArePtrs64bit(),
3015                       true, IDLoc, Instructions))
3016       return true;
3017
3018     // NOTE: We do this (D)ADDu here instead of doing it in loadImmediate()
3019     // because it will make our output more similar to GAS'. For example,
3020     // generating an "ori $1, $zero, 32768" followed by an "addu $1, $1, $9",
3021     // instead of just an "ori $1, $9, 32768".
3022     // NOTE: If there is no source register specified in the ULW, the parser
3023     // will interpret it as $0.
3024     if (SrcReg != Mips::ZERO && SrcReg != Mips::ZERO_64)
3025       createAddu(ATReg, ATReg, SrcReg, ABI.ArePtrs64bit(), Instructions);
3026   }
3027
3028   unsigned FinalSrcReg = LoadedOffsetInAT ? ATReg : SrcReg;
3029   int64_t LeftLoadOffset = 0, RightLoadOffset  = 0;
3030   if (isLittle()) {
3031     LeftLoadOffset = LoadedOffsetInAT ? 3 : (OffsetValue + 3);
3032     RightLoadOffset  = LoadedOffsetInAT ? 0 : OffsetValue;
3033   } else {
3034     LeftLoadOffset = LoadedOffsetInAT ? 0 : OffsetValue;
3035     RightLoadOffset  = LoadedOffsetInAT ? 3 : (OffsetValue + 3);
3036   }
3037
3038   MCInst LeftLoadInst;
3039   LeftLoadInst.setOpcode(Mips::LWL);
3040   LeftLoadInst.addOperand(DstRegOp);
3041   LeftLoadInst.addOperand(MCOperand::createReg(FinalSrcReg));
3042   LeftLoadInst.addOperand(MCOperand::createImm(LeftLoadOffset));
3043   Instructions.push_back(LeftLoadInst);
3044
3045   MCInst RightLoadInst;
3046   RightLoadInst.setOpcode(Mips::LWR);
3047   RightLoadInst.addOperand(DstRegOp);
3048   RightLoadInst.addOperand(MCOperand::createReg(FinalSrcReg));
3049   RightLoadInst.addOperand(MCOperand::createImm(RightLoadOffset ));
3050   Instructions.push_back(RightLoadInst);
3051
3052   return false;
3053 }
3054
3055 void MipsAsmParser::createNop(bool hasShortDelaySlot, SMLoc IDLoc,
3056                               SmallVectorImpl<MCInst> &Instructions) {
3057   MCInst NopInst;
3058   if (hasShortDelaySlot) {
3059     NopInst.setOpcode(Mips::MOVE16_MM);
3060     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
3061     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
3062   } else {
3063     NopInst.setOpcode(Mips::SLL);
3064     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
3065     NopInst.addOperand(MCOperand::createReg(Mips::ZERO));
3066     NopInst.addOperand(MCOperand::createImm(0));
3067   }
3068   Instructions.push_back(NopInst);
3069 }
3070
3071 void MipsAsmParser::createAddu(unsigned DstReg, unsigned SrcReg,
3072                                unsigned TrgReg, bool Is64Bit,
3073                                SmallVectorImpl<MCInst> &Instructions) {
3074   emitRRR(Is64Bit ? Mips::DADDu : Mips::ADDu, DstReg, SrcReg, TrgReg, SMLoc(),
3075           Instructions);
3076 }
3077
3078 unsigned MipsAsmParser::checkTargetMatchPredicate(MCInst &Inst) {
3079   // As described by the Mips32r2 spec, the registers Rd and Rs for
3080   // jalr.hb must be different.
3081   unsigned Opcode = Inst.getOpcode();
3082
3083   if (Opcode == Mips::JALR_HB &&
3084       (Inst.getOperand(0).getReg() == Inst.getOperand(1).getReg()))
3085     return Match_RequiresDifferentSrcAndDst;
3086
3087   return Match_Success;
3088 }
3089
3090 bool MipsAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
3091                                             OperandVector &Operands,
3092                                             MCStreamer &Out,
3093                                             uint64_t &ErrorInfo,
3094                                             bool MatchingInlineAsm) {
3095
3096   MCInst Inst;
3097   SmallVector<MCInst, 8> Instructions;
3098   unsigned MatchResult =
3099       MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
3100
3101   switch (MatchResult) {
3102   case Match_Success: {
3103     if (processInstruction(Inst, IDLoc, Instructions))
3104       return true;
3105     for (unsigned i = 0; i < Instructions.size(); i++)
3106       Out.EmitInstruction(Instructions[i], STI);
3107     return false;
3108   }
3109   case Match_MissingFeature:
3110     Error(IDLoc, "instruction requires a CPU feature not currently enabled");
3111     return true;
3112   case Match_InvalidOperand: {
3113     SMLoc ErrorLoc = IDLoc;
3114     if (ErrorInfo != ~0ULL) {
3115       if (ErrorInfo >= Operands.size())
3116         return Error(IDLoc, "too few operands for instruction");
3117
3118       ErrorLoc = ((MipsOperand &)*Operands[ErrorInfo]).getStartLoc();
3119       if (ErrorLoc == SMLoc())
3120         ErrorLoc = IDLoc;
3121     }
3122
3123     return Error(ErrorLoc, "invalid operand for instruction");
3124   }
3125   case Match_MnemonicFail:
3126     return Error(IDLoc, "invalid instruction");
3127   case Match_RequiresDifferentSrcAndDst:
3128     return Error(IDLoc, "source and destination must be different");
3129   }
3130
3131   llvm_unreachable("Implement any new match types added!");
3132 }
3133
3134 void MipsAsmParser::warnIfRegIndexIsAT(unsigned RegIndex, SMLoc Loc) {
3135   if (RegIndex != 0 && AssemblerOptions.back()->getATRegIndex() == RegIndex)
3136     Warning(Loc, "used $at (currently $" + Twine(RegIndex) +
3137                      ") without \".set noat\"");
3138 }
3139
3140 void MipsAsmParser::warnIfNoMacro(SMLoc Loc) {
3141   if (!AssemblerOptions.back()->isMacro())
3142     Warning(Loc, "macro instruction expanded into multiple instructions");
3143 }
3144
3145 void
3146 MipsAsmParser::printWarningWithFixIt(const Twine &Msg, const Twine &FixMsg,
3147                                      SMRange Range, bool ShowColors) {
3148   getSourceManager().PrintMessage(Range.Start, SourceMgr::DK_Warning, Msg,
3149                                   Range, SMFixIt(Range, FixMsg),
3150                                   ShowColors);
3151 }
3152
3153 int MipsAsmParser::matchCPURegisterName(StringRef Name) {
3154   int CC;
3155
3156   CC = StringSwitch<unsigned>(Name)
3157            .Case("zero", 0)
3158            .Case("at", 1)
3159            .Case("a0", 4)
3160            .Case("a1", 5)
3161            .Case("a2", 6)
3162            .Case("a3", 7)
3163            .Case("v0", 2)
3164            .Case("v1", 3)
3165            .Case("s0", 16)
3166            .Case("s1", 17)
3167            .Case("s2", 18)
3168            .Case("s3", 19)
3169            .Case("s4", 20)
3170            .Case("s5", 21)
3171            .Case("s6", 22)
3172            .Case("s7", 23)
3173            .Case("k0", 26)
3174            .Case("k1", 27)
3175            .Case("gp", 28)
3176            .Case("sp", 29)
3177            .Case("fp", 30)
3178            .Case("s8", 30)
3179            .Case("ra", 31)
3180            .Case("t0", 8)
3181            .Case("t1", 9)
3182            .Case("t2", 10)
3183            .Case("t3", 11)
3184            .Case("t4", 12)
3185            .Case("t5", 13)
3186            .Case("t6", 14)
3187            .Case("t7", 15)
3188            .Case("t8", 24)
3189            .Case("t9", 25)
3190            .Default(-1);
3191
3192   if (!(isABI_N32() || isABI_N64()))
3193     return CC;
3194
3195   if (12 <= CC && CC <= 15) {
3196     // Name is one of t4-t7
3197     AsmToken RegTok = getLexer().peekTok();
3198     SMRange RegRange = RegTok.getLocRange();
3199
3200     StringRef FixedName = StringSwitch<StringRef>(Name)
3201                               .Case("t4", "t0")
3202                               .Case("t5", "t1")
3203                               .Case("t6", "t2")
3204                               .Case("t7", "t3")
3205                               .Default("");
3206     assert(FixedName != "" &&  "Register name is not one of t4-t7.");
3207
3208     printWarningWithFixIt("register names $t4-$t7 are only available in O32.",
3209                           "Did you mean $" + FixedName + "?", RegRange);
3210   }
3211
3212   // Although SGI documentation just cuts out t0-t3 for n32/n64,
3213   // GNU pushes the values of t0-t3 to override the o32/o64 values for t4-t7
3214   // We are supporting both cases, so for t0-t3 we'll just push them to t4-t7.
3215   if (8 <= CC && CC <= 11)
3216     CC += 4;
3217
3218   if (CC == -1)
3219     CC = StringSwitch<unsigned>(Name)
3220              .Case("a4", 8)
3221              .Case("a5", 9)
3222              .Case("a6", 10)
3223              .Case("a7", 11)
3224              .Case("kt0", 26)
3225              .Case("kt1", 27)
3226              .Default(-1);
3227
3228   return CC;
3229 }
3230
3231 int MipsAsmParser::matchHWRegsRegisterName(StringRef Name) {
3232   int CC;
3233
3234   CC = StringSwitch<unsigned>(Name)
3235             .Case("hwr_cpunum", 0)
3236             .Case("hwr_synci_step", 1)
3237             .Case("hwr_cc", 2)
3238             .Case("hwr_ccres", 3)
3239             .Case("hwr_ulr", 29)
3240             .Default(-1);
3241
3242   return CC;
3243 }
3244
3245 int MipsAsmParser::matchFPURegisterName(StringRef Name) {
3246
3247   if (Name[0] == 'f') {
3248     StringRef NumString = Name.substr(1);
3249     unsigned IntVal;
3250     if (NumString.getAsInteger(10, IntVal))
3251       return -1;     // This is not an integer.
3252     if (IntVal > 31) // Maximum index for fpu register.
3253       return -1;
3254     return IntVal;
3255   }
3256   return -1;
3257 }
3258
3259 int MipsAsmParser::matchFCCRegisterName(StringRef Name) {
3260
3261   if (Name.startswith("fcc")) {
3262     StringRef NumString = Name.substr(3);
3263     unsigned IntVal;
3264     if (NumString.getAsInteger(10, IntVal))
3265       return -1;    // This is not an integer.
3266     if (IntVal > 7) // There are only 8 fcc registers.
3267       return -1;
3268     return IntVal;
3269   }
3270   return -1;
3271 }
3272
3273 int MipsAsmParser::matchACRegisterName(StringRef Name) {
3274
3275   if (Name.startswith("ac")) {
3276     StringRef NumString = Name.substr(2);
3277     unsigned IntVal;
3278     if (NumString.getAsInteger(10, IntVal))
3279       return -1;    // This is not an integer.
3280     if (IntVal > 3) // There are only 3 acc registers.
3281       return -1;
3282     return IntVal;
3283   }
3284   return -1;
3285 }
3286
3287 int MipsAsmParser::matchMSA128RegisterName(StringRef Name) {
3288   unsigned IntVal;
3289
3290   if (Name.front() != 'w' || Name.drop_front(1).getAsInteger(10, IntVal))
3291     return -1;
3292
3293   if (IntVal > 31)
3294     return -1;
3295
3296   return IntVal;
3297 }
3298
3299 int MipsAsmParser::matchMSA128CtrlRegisterName(StringRef Name) {
3300   int CC;
3301
3302   CC = StringSwitch<unsigned>(Name)
3303            .Case("msair", 0)
3304            .Case("msacsr", 1)
3305            .Case("msaaccess", 2)
3306            .Case("msasave", 3)
3307            .Case("msamodify", 4)
3308            .Case("msarequest", 5)
3309            .Case("msamap", 6)
3310            .Case("msaunmap", 7)
3311            .Default(-1);
3312
3313   return CC;
3314 }
3315
3316 unsigned MipsAsmParser::getATReg(SMLoc Loc) {
3317   unsigned ATIndex = AssemblerOptions.back()->getATRegIndex();
3318   if (ATIndex == 0) {
3319     reportParseError(Loc,
3320                      "pseudo-instruction requires $at, which is not available");
3321     return 0;
3322   }
3323   unsigned AT = getReg(
3324       (isGP64bit()) ? Mips::GPR64RegClassID : Mips::GPR32RegClassID, ATIndex);
3325   return AT;
3326 }
3327
3328 unsigned MipsAsmParser::getReg(int RC, int RegNo) {
3329   return *(getContext().getRegisterInfo()->getRegClass(RC).begin() + RegNo);
3330 }
3331
3332 unsigned MipsAsmParser::getGPR(int RegNo) {
3333   return getReg(isGP64bit() ? Mips::GPR64RegClassID : Mips::GPR32RegClassID,
3334                 RegNo);
3335 }
3336
3337 int MipsAsmParser::matchRegisterByNumber(unsigned RegNum, unsigned RegClass) {
3338   if (RegNum >
3339       getContext().getRegisterInfo()->getRegClass(RegClass).getNumRegs() - 1)
3340     return -1;
3341
3342   return getReg(RegClass, RegNum);
3343 }
3344
3345 bool MipsAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
3346   MCAsmParser &Parser = getParser();
3347   DEBUG(dbgs() << "parseOperand\n");
3348
3349   // Check if the current operand has a custom associated parser, if so, try to
3350   // custom parse the operand, or fallback to the general approach.
3351   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
3352   if (ResTy == MatchOperand_Success)
3353     return false;
3354   // If there wasn't a custom match, try the generic matcher below. Otherwise,
3355   // there was a match, but an error occurred, in which case, just return that
3356   // the operand parsing failed.
3357   if (ResTy == MatchOperand_ParseFail)
3358     return true;
3359
3360   DEBUG(dbgs() << ".. Generic Parser\n");
3361
3362   switch (getLexer().getKind()) {
3363   default:
3364     Error(Parser.getTok().getLoc(), "unexpected token in operand");
3365     return true;
3366   case AsmToken::Dollar: {
3367     // Parse the register.
3368     SMLoc S = Parser.getTok().getLoc();
3369