lib/Target/Mips/MicroMipsInstrInfo.td

   1 def addrimm12 : ComplexPattern<iPTR, 2, "selectIntAddrMM", [frameindex]>;
   2
   3 def simm4 : Operand<i32> {
   4   let DecoderMethod = "DecodeSimm4";
   5 }
   6 def li_simm7 : Operand<i32> {
   7   let DecoderMethod = "DecodeLiSimm7";
   8 }
   9
  10 def simm12 : Operand<i32> {
  11   let DecoderMethod = "DecodeSimm12";
  12 }
  13
  14 def uimm5_lsl2 : Operand<OtherVT> {
  15   let EncoderMethod = "getUImm5Lsl2Encoding";
  16   let DecoderMethod = "DecodeUImm5lsl2";
  17 }
  18
  19 def uimm6_lsl2 : Operand<i32> {
  20   let EncoderMethod = "getUImm6Lsl2Encoding";
  21   let DecoderMethod = "DecodeUImm6Lsl2";
  22 }
  23
  24 def simm9_addiusp : Operand<i32> {
  25   let EncoderMethod = "getSImm9AddiuspValue";
  26   let DecoderMethod = "DecodeSimm9SP";
  27 }
  28
  29 def uimm3_shift : Operand<i32> {
  30   let EncoderMethod = "getUImm3Mod8Encoding";
  31 }
  32
  33 def simm3_lsa2 : Operand<i32> {
  34   let EncoderMethod = "getSImm3Lsa2Value";
  35   let DecoderMethod = "DecodeAddiur2Simm7";
  36 }
  37
  38 def uimm4_andi : Operand<i32> {
  39   let EncoderMethod = "getUImm4AndValue";
  40   let DecoderMethod = "DecodeANDI16Imm";
  41 }
  42
  43 def immSExtAddiur2 : ImmLeaf<i32, [{return Imm == 1 || Imm == -1 ||
  44                                            ((Imm % 4 == 0) &&
  45                                             Imm < 28 && Imm > 0);}]>;
  46
  47 def immSExtAddius5 : ImmLeaf<i32, [{return Imm >= -8 && Imm <= 7;}]>;
  48
  49 def immZExtAndi16 : ImmLeaf<i32,
  50   [{return (Imm == 128 || (Imm >= 1 && Imm <= 4) || Imm == 7 || Imm == 8 ||
  51             Imm == 15 || Imm == 16 || Imm == 31 || Imm == 32 || Imm == 63 ||
  52             Imm == 64 || Imm == 255 || Imm == 32768 || Imm == 65535 );}]>;
  53
  54 def immZExt2Shift : ImmLeaf<i32, [{return Imm >= 1 && Imm <= 8;}]>;
  55
  56 def immLi16 : ImmLeaf<i32, [{return Imm >= -1 && Imm <= 126;}]>;
  57
  58 def MicroMipsMemGPRMM16AsmOperand : AsmOperandClass {
  59   let Name = "MicroMipsMem";
  60   let RenderMethod = "addMicroMipsMemOperands";
  61   let ParserMethod = "parseMemOperand";
  62   let PredicateMethod = "isMemWithGRPMM16Base";
  63 }
  64
  65 class mem_mm_4_generic : Operand<i32> {
  66   let PrintMethod = "printMemOperand";
  67   let MIOperandInfo = (ops ptr_rc, simm4);
  68   let OperandType = "OPERAND_MEMORY";
  69   let ParserMatchClass = MicroMipsMemGPRMM16AsmOperand;
  70 }
  71
  72 def mem_mm_4 : mem_mm_4_generic {
  73   let EncoderMethod = "getMemEncodingMMImm4";
  74 }
  75
  76 def mem_mm_4_lsl1 : mem_mm_4_generic {
  77   let EncoderMethod = "getMemEncodingMMImm4Lsl1";
  78 }
  79
  80 def mem_mm_4_lsl2 : mem_mm_4_generic {
  81   let EncoderMethod = "getMemEncodingMMImm4Lsl2";
  82 }
  83
  84 def MicroMipsMemSPAsmOperand : AsmOperandClass {
  85   let Name = "MicroMipsMemSP";
  86   let RenderMethod = "addMemOperands";
  87   let ParserMethod = "parseMemOperand";
  88   let PredicateMethod = "isMemWithUimmWordAlignedOffsetSP<7>";
  89 }
  90
  91 def mem_mm_sp_imm5_lsl2 : Operand<i32> {
  92   let PrintMethod = "printMemOperand";
  93   let MIOperandInfo = (ops GPR32:$base, simm5:$offset);
  94   let OperandType = "OPERAND_MEMORY";
  95   let ParserMatchClass = MicroMipsMemSPAsmOperand;
  96   let EncoderMethod = "getMemEncodingMMSPImm5Lsl2";
  97 }
  98
  99 def mem_mm_12 : Operand<i32> {
 100   let PrintMethod = "printMemOperand";
 101   let MIOperandInfo = (ops GPR32, simm12);
 102   let EncoderMethod = "getMemEncodingMMImm12";
 103   let ParserMatchClass = MipsMemAsmOperand;
 104   let OperandType = "OPERAND_MEMORY";
 105 }
 106
 107 def MipsMemUimm4AsmOperand : AsmOperandClass {
 108   let Name = "MemOffsetUimm4";
 109   let SuperClasses = [MipsMemAsmOperand];
 110   let RenderMethod = "addMemOperands";
 111   let ParserMethod = "parseMemOperand";
 112   let PredicateMethod = "isMemWithUimmOffsetSP<6>";
 113 }
 114
 115 def mem_mm_4sp : Operand<i32> {
 116   let PrintMethod = "printMemOperand";
 117   let MIOperandInfo = (ops GPR32, uimm8);
 118   let EncoderMethod = "getMemEncodingMMImm4sp";
 119   let ParserMatchClass = MipsMemUimm4AsmOperand;
 120   let OperandType = "OPERAND_MEMORY";
 121 }
 122
 123 def jmptarget_mm : Operand<OtherVT> {
 124   let EncoderMethod = "getJumpTargetOpValueMM";
 125 }
 126
 127 def calltarget_mm : Operand<iPTR> {
 128   let EncoderMethod = "getJumpTargetOpValueMM";
 129 }
 130
 131 def brtarget7_mm : Operand<OtherVT> {
 132   let EncoderMethod = "getBranchTarget7OpValueMM";
 133   let OperandType   = "OPERAND_PCREL";
 134   let DecoderMethod = "DecodeBranchTarget7MM";
 135   let ParserMatchClass = MipsJumpTargetAsmOperand;
 136 }
 137
 138 def brtarget_mm : Operand<OtherVT> {
 139   let EncoderMethod = "getBranchTargetOpValueMM";
 140   let OperandType   = "OPERAND_PCREL";
 141   let DecoderMethod = "DecodeBranchTargetMM";
 142 }
 143
 144 class CompactBranchMM<string opstr, DAGOperand opnd, PatFrag cond_op,
 145                       RegisterOperand RO> :
 146   InstSE<(outs), (ins RO:$rs, opnd:$offset),
 147          !strconcat(opstr, "\t$rs, $offset"), [], IIBranch, FrmI> {
 148   let isBranch = 1;
 149   let isTerminator = 1;
 150   let hasDelaySlot = 0;
 151   let Defs = [AT];
 152 }
 153
 154 let canFoldAsLoad = 1 in
 155 class LoadLeftRightMM<string opstr, SDNode OpNode, RegisterOperand RO,
 156                       Operand MemOpnd> :
 157   InstSE<(outs RO:$rt), (ins MemOpnd:$addr, RO:$src),
 158          !strconcat(opstr, "\t$rt, $addr"),
 159          [(set RO:$rt, (OpNode addrimm12:$addr, RO:$src))],
 160          NoItinerary, FrmI> {
 161   let DecoderMethod = "DecodeMemMMImm12";
 162   string Constraints = "$src = $rt";
 163 }
 164
 165 class StoreLeftRightMM<string opstr, SDNode OpNode, RegisterOperand RO,
 166                        Operand MemOpnd>:
 167   InstSE<(outs), (ins RO:$rt, MemOpnd:$addr),
 168          !strconcat(opstr, "\t$rt, $addr"),
 169          [(OpNode RO:$rt, addrimm12:$addr)], NoItinerary, FrmI> {
 170   let DecoderMethod = "DecodeMemMMImm12";
 171 }
 172
 173 /// A register pair used by load/store pair instructions.
 174 def RegPairAsmOperand : AsmOperandClass {
 175   let Name = "RegPair";
 176   let ParserMethod = "parseRegisterPair";
 177 }
 178
 179 def regpair : Operand<i32> {
 180   let EncoderMethod = "getRegisterPairOpValue";
 181   let ParserMatchClass = RegPairAsmOperand;
 182   let PrintMethod = "printRegisterPair";
 183   let DecoderMethod = "DecodeRegPairOperand";
 184   let MIOperandInfo = (ops GPR32Opnd, GPR32Opnd);
 185 }
 186
 187 class StorePairMM<string opstr, InstrItinClass Itin = NoItinerary,
 188                   ComplexPattern Addr = addr> :
 189   InstSE<(outs), (ins regpair:$rt, mem_mm_12:$addr),
 190          !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI, opstr> {
 191   let DecoderMethod = "DecodeMemMMImm12";
 192   let mayStore = 1;
 193 }
 194
 195 class LoadPairMM<string opstr, InstrItinClass Itin = NoItinerary,
 196                  ComplexPattern Addr = addr> :
 197   InstSE<(outs regpair:$rt), (ins mem_mm_12:$addr),
 198           !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI, opstr> {
 199   let DecoderMethod = "DecodeMemMMImm12";
 200   let mayLoad = 1;
 201 }
 202
 203 class LLBaseMM<string opstr, RegisterOperand RO> :
 204   InstSE<(outs RO:$rt), (ins mem_mm_12:$addr),
 205          !strconcat(opstr, "\t$rt, $addr"), [], NoItinerary, FrmI> {
 206   let DecoderMethod = "DecodeMemMMImm12";
 207   let mayLoad = 1;
 208 }
 209
 210 class SCBaseMM<string opstr, RegisterOperand RO> :
 211   InstSE<(outs RO:$dst), (ins RO:$rt, mem_mm_12:$addr),
 212          !strconcat(opstr, "\t$rt, $addr"), [], NoItinerary, FrmI> {
 213   let DecoderMethod = "DecodeMemMMImm12";
 214   let mayStore = 1;
 215   let Constraints = "$rt = $dst";
 216 }
 217
 218 class LoadMM<string opstr, DAGOperand RO, SDPatternOperator OpNode = null_frag,
 219              InstrItinClass Itin = NoItinerary> :
 220   InstSE<(outs RO:$rt), (ins mem_mm_12:$addr),
 221          !strconcat(opstr, "\t$rt, $addr"),
 222          [(set RO:$rt, (OpNode addrimm12:$addr))], Itin, FrmI> {
 223   let DecoderMethod = "DecodeMemMMImm12";
 224   let canFoldAsLoad = 1;
 225   let mayLoad = 1;
 226 }
 227
 228 class ArithRMM16<string opstr, RegisterOperand RO, bit isComm = 0,
 229                  InstrItinClass Itin = NoItinerary,
 230                  SDPatternOperator OpNode = null_frag> :
 231   MicroMipsInst16<(outs RO:$rd), (ins RO:$rs, RO:$rt),
 232                   !strconcat(opstr, "\t$rd, $rs, $rt"),
 233                   [(set RO:$rd, (OpNode RO:$rs, RO:$rt))], Itin, FrmR> {
 234   let isCommutable = isComm;
 235 }
 236
 237 class AndImmMM16<string opstr, RegisterOperand RO,
 238                  InstrItinClass Itin = NoItinerary> :
 239   MicroMipsInst16<(outs RO:$rd), (ins RO:$rs, uimm4_andi:$imm),
 240                   !strconcat(opstr, "\t$rd, $rs, $imm"), [], Itin, FrmI>;
 241
 242 class LogicRMM16<string opstr, RegisterOperand RO,
 243                  InstrItinClass Itin = NoItinerary,
 244                  SDPatternOperator OpNode = null_frag> :
 245   MicroMipsInst16<(outs RO:$dst), (ins RO:$rs, RO:$rt),
 246          !strconcat(opstr, "\t$rt, $rs"),
 247          [(set RO:$dst, (OpNode RO:$rs, RO:$rt))], Itin, FrmR> {
 248   let isCommutable = 1;
 249   let Constraints = "$rt = $dst";
 250 }
 251
 252 class NotMM16<string opstr, RegisterOperand RO> :
 253   MicroMipsInst16<(outs RO:$rt), (ins RO:$rs),
 254          !strconcat(opstr, "\t$rt, $rs"),
 255          [(set RO:$rt, (not RO:$rs))], NoItinerary, FrmR>;
 256
 257 class ShiftIMM16<string opstr, Operand ImmOpnd, RegisterOperand RO,
 258                  InstrItinClass Itin = NoItinerary> :
 259   MicroMipsInst16<(outs RO:$rd), (ins RO:$rt, ImmOpnd:$shamt),
 260                   !strconcat(opstr, "\t$rd, $rt, $shamt"), [], Itin, FrmR>;
 261
 262 class LoadMM16<string opstr, DAGOperand RO, SDPatternOperator OpNode,
 263                InstrItinClass Itin, Operand MemOpnd> :
 264   MicroMipsInst16<(outs RO:$rt), (ins MemOpnd:$addr),
 265                   !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI> {
 266   let DecoderMethod = "DecodeMemMMImm4";
 267   let canFoldAsLoad = 1;
 268   let mayLoad = 1;
 269 }
 270
 271 class StoreMM16<string opstr, DAGOperand RTOpnd, DAGOperand RO,
 272                 SDPatternOperator OpNode, InstrItinClass Itin,
 273                 Operand MemOpnd> :
 274   MicroMipsInst16<(outs), (ins RTOpnd:$rt, MemOpnd:$addr),
 275                   !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI> {
 276   let DecoderMethod = "DecodeMemMMImm4";
 277   let mayStore = 1;
 278 }
 279
 280 class LoadSPMM16<string opstr, DAGOperand RO, InstrItinClass Itin,
 281                  Operand MemOpnd> :
 282   MicroMipsInst16<(outs RO:$rt), (ins MemOpnd:$offset),
 283                   !strconcat(opstr, "\t$rt, $offset"), [], Itin, FrmI> {
 284   let DecoderMethod = "DecodeMemMMSPImm5Lsl2";
 285   let canFoldAsLoad = 1;
 286   let mayLoad = 1;
 287 }
 288
 289 class StoreSPMM16<string opstr, DAGOperand RO, InstrItinClass Itin,
 290                   Operand MemOpnd> :
 291   MicroMipsInst16<(outs), (ins RO:$rt, MemOpnd:$offset),
 292                   !strconcat(opstr, "\t$rt, $offset"), [], Itin, FrmI> {
 293   let DecoderMethod = "DecodeMemMMSPImm5Lsl2";
 294   let mayStore = 1;
 295 }
 296
 297 class AddImmUR2<string opstr, RegisterOperand RO> :
 298   MicroMipsInst16<(outs RO:$rd), (ins RO:$rs, simm3_lsa2:$imm),
 299                   !strconcat(opstr, "\t$rd, $rs, $imm"),
 300                   [], NoItinerary, FrmR> {
 301   let isCommutable = 1;
 302 }
 303
 304 class AddImmUS5<string opstr, RegisterOperand RO> :
 305   MicroMipsInst16<(outs RO:$dst), (ins RO:$rd, simm4:$imm),
 306                   !strconcat(opstr, "\t$rd, $imm"), [], NoItinerary, FrmR> {
 307   let Constraints = "$rd = $dst";
 308 }
 309
 310 class AddImmUR1SP<string opstr, RegisterOperand RO> :
 311   MicroMipsInst16<(outs RO:$rd), (ins uimm6_lsl2:$imm),
 312                   !strconcat(opstr, "\t$rd, $imm"), [], NoItinerary, FrmR>;
 313
 314 class AddImmUSP<string opstr> :
 315   MicroMipsInst16<(outs), (ins simm9_addiusp:$imm),
 316                   !strconcat(opstr, "\t$imm"), [], NoItinerary, FrmI>;
 317
 318 class MoveFromHILOMM<string opstr, RegisterOperand RO, Register UseReg> :
 319       MicroMipsInst16<(outs RO:$rd), (ins), !strconcat(opstr, "\t$rd"),
 320   [], II_MFHI_MFLO, FrmR> {
 321   let Uses = [UseReg];
 322   let hasSideEffects = 0;
 323 }
 324
 325 class MoveMM16<string opstr, RegisterOperand RO, bit isComm = 0,
 326                InstrItinClass Itin = NoItinerary> :
 327   MicroMipsInst16<(outs RO:$rd), (ins RO:$rs),
 328                   !strconcat(opstr, "\t$rd, $rs"), [], Itin, FrmR> {
 329   let isCommutable = isComm;
 330   let isReMaterializable = 1;
 331 }
 332
 333 class LoadImmMM16<string opstr, Operand Od, RegisterOperand RO> :
 334   MicroMipsInst16<(outs RO:$rd), (ins Od:$imm),
 335                   !strconcat(opstr, "\t$rd, $imm"), [], NoItinerary, FrmI> {
 336   let isReMaterializable = 1;
 337 }
 338
 339 // 16-bit Jump and Link (Call)
 340 class JumpLinkRegMM16<string opstr, RegisterOperand RO> :
 341   MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
 342            [(MipsJmpLink RO:$rs)], IIBranch, FrmR> {
 343   let isCall = 1;
 344   let hasDelaySlot = 1;
 345   let Defs = [RA];
 346 }
 347
 348 // 16-bit Jump Reg
 349 class JumpRegMM16<string opstr, RegisterOperand RO> :
 350   MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
 351            [], IIBranch, FrmR> {
 352   let hasDelaySlot = 1;
 353   let isBranch = 1;
 354   let isIndirectBranch = 1;
 355 }
 356
 357 // Base class for JRADDIUSP instruction.
 358 class JumpRAddiuStackMM16 :
 359   MicroMipsInst16<(outs), (ins uimm5_lsl2:$imm), "jraddiusp\t$imm",
 360                   [], IIBranch, FrmR> {
 361   let isTerminator = 1;
 362   let isBarrier = 1;
 363   let isBranch = 1;
 364   let isIndirectBranch = 1;
 365 }
 366
 367 // 16-bit Jump and Link (Call) - Short Delay Slot
 368 class JumpLinkRegSMM16<string opstr, RegisterOperand RO> :
 369   MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
 370            [], IIBranch, FrmR> {
 371   let isCall = 1;
 372   let hasDelaySlot = 1;
 373   let Defs = [RA];
 374 }
 375
 376 // 16-bit Jump Register Compact - No delay slot
 377 class JumpRegCMM16<string opstr, RegisterOperand RO> :
 378   MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
 379                   [], IIBranch, FrmR> {
 380   let isTerminator = 1;
 381   let isBarrier = 1;
 382   let isBranch = 1;
 383   let isIndirectBranch = 1;
 384 }
 385
 386 // Break16 and Sdbbp16
 387 class BrkSdbbp16MM<string opstr> :
 388   MicroMipsInst16<(outs), (ins uimm4:$code_),
 389                   !strconcat(opstr, "\t$code_"),
 390                   [], NoItinerary, FrmOther>;
 391
 392 class CBranchZeroMM<string opstr, DAGOperand opnd, RegisterOperand RO> :
 393   MicroMipsInst16<(outs), (ins RO:$rs, opnd:$offset),
 394                   !strconcat(opstr, "\t$rs, $offset"), [], IIBranch, FrmI> {
 395   let isBranch = 1;
 396   let isTerminator = 1;
 397   let hasDelaySlot = 1;
 398   let Defs = [AT];
 399 }
 400
 401 // MicroMIPS Jump and Link (Call) - Short Delay Slot
 402 let isCall = 1, hasDelaySlot = 1, Defs = [RA] in {
 403   class JumpLinkMM<string opstr, DAGOperand opnd> :
 404     InstSE<(outs), (ins opnd:$target), !strconcat(opstr, "\t$target"),
 405            [], IIBranch, FrmJ, opstr> {
 406     let DecoderMethod = "DecodeJumpTargetMM";
 407   }
 408
 409   class JumpLinkRegMM<string opstr, RegisterOperand RO>:
 410     InstSE<(outs RO:$rd), (ins RO:$rs), !strconcat(opstr, "\t$rd, $rs"),
 411             [], IIBranch, FrmR>;
 412
 413   class BranchCompareToZeroLinkMM<string opstr, DAGOperand opnd,
 414                                   RegisterOperand RO> :
 415     InstSE<(outs), (ins RO:$rs, opnd:$offset),
 416            !strconcat(opstr, "\t$rs, $offset"), [], IIBranch, FrmI, opstr>;
 417 }
 418
 419 class LoadWordIndexedScaledMM<string opstr, RegisterOperand RO,
 420                               InstrItinClass Itin = NoItinerary,
 421                               SDPatternOperator OpNode = null_frag> :
 422   InstSE<(outs RO:$rd), (ins PtrRC:$base, PtrRC:$index),
 423          !strconcat(opstr, "\t$rd, ${index}(${base})"), [], Itin, FrmFI>;
 424
 425 /// A list of registers used by load/store multiple instructions.
 426 def RegListAsmOperand : AsmOperandClass {
 427   let Name = "RegList";
 428   let ParserMethod = "parseRegisterList";
 429 }
 430
 431 def reglist : Operand<i32> {
 432   let EncoderMethod = "getRegisterListOpValue";
 433   let ParserMatchClass = RegListAsmOperand;
 434   let PrintMethod = "printRegisterList";
 435   let DecoderMethod = "DecodeRegListOperand";
 436 }
 437
 438 def RegList16AsmOperand : AsmOperandClass {
 439   let Name = "RegList16";
 440   let ParserMethod = "parseRegisterList";
 441   let PredicateMethod = "isRegList16";
 442   let RenderMethod = "addRegListOperands";
 443 }
 444
 445 def reglist16 : Operand<i32> {
 446   let EncoderMethod = "getRegisterListOpValue16";
 447   let DecoderMethod = "DecodeRegListOperand16";
 448   let PrintMethod = "printRegisterList";
 449   let ParserMatchClass = RegList16AsmOperand;
 450 }
 451
 452 class StoreMultMM<string opstr,
 453             InstrItinClass Itin = NoItinerary, ComplexPattern Addr = addr> :
 454   InstSE<(outs), (ins reglist:$rt, mem_mm_12:$addr),
 455          !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI, opstr> {
 456   let DecoderMethod = "DecodeMemMMImm12";
 457   let mayStore = 1;
 458 }
 459
 460 class LoadMultMM<string opstr,
 461             InstrItinClass Itin = NoItinerary, ComplexPattern Addr = addr> :
 462   InstSE<(outs reglist:$rt), (ins mem_mm_12:$addr),
 463           !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI, opstr> {
 464   let DecoderMethod = "DecodeMemMMImm12";
 465   let mayLoad = 1;
 466 }
 467
 468 class StoreMultMM16<string opstr,
 469                     InstrItinClass Itin = NoItinerary,
 470                     ComplexPattern Addr = addr> :
 471   MicroMipsInst16<(outs), (ins reglist16:$rt, mem_mm_4sp:$addr),
 472                   !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI> {
 473   let mayStore = 1;
 474 }
 475
 476 class LoadMultMM16<string opstr,
 477                    InstrItinClass Itin = NoItinerary,
 478                    ComplexPattern Addr = addr> :
 479   MicroMipsInst16<(outs reglist16:$rt), (ins mem_mm_4sp:$addr),
 480                   !strconcat(opstr, "\t$rt, $addr"), [], Itin, FrmI> {
 481   let mayLoad = 1;
 482 }
 483
 484 def ADDU16_MM : ArithRMM16<"addu16", GPRMM16Opnd, 1, II_ADDU, add>,
 485                 ARITH_FM_MM16<0>;
 486 def SUBU16_MM : ArithRMM16<"subu16", GPRMM16Opnd, 0, II_SUBU, sub>,
 487                 ARITH_FM_MM16<1>;
 488 def ANDI16_MM : AndImmMM16<"andi16", GPRMM16Opnd, II_AND>, ANDI_FM_MM16<0x0b>;
 489 def AND16_MM : LogicRMM16<"and16", GPRMM16Opnd, II_AND, and>,
 490                LOGIC_FM_MM16<0x2>;
 491 def OR16_MM  : LogicRMM16<"or16", GPRMM16Opnd, II_OR, or>,
 492                LOGIC_FM_MM16<0x3>;
 493 def XOR16_MM : LogicRMM16<"xor16", GPRMM16Opnd, II_XOR, xor>,
 494                LOGIC_FM_MM16<0x1>;
 495 def NOT16_MM : NotMM16<"not16", GPRMM16Opnd>, LOGIC_FM_MM16<0x0>;
 496 def SLL16_MM : ShiftIMM16<"sll16", uimm3_shift, GPRMM16Opnd, II_SLL>,
 497                SHIFT_FM_MM16<0>;
 498 def SRL16_MM : ShiftIMM16<"srl16", uimm3_shift, GPRMM16Opnd, II_SRL>,
 499                SHIFT_FM_MM16<1>;
 500 def LBU16_MM : LoadMM16<"lbu16", GPRMM16Opnd, zextloadi8, II_LBU,
 501                         mem_mm_4>, LOAD_STORE_FM_MM16<0x02>;
 502 def LHU16_MM : LoadMM16<"lhu16", GPRMM16Opnd, zextloadi16, II_LHU,
 503                         mem_mm_4_lsl1>, LOAD_STORE_FM_MM16<0x0a>;
 504 def LW16_MM : LoadMM16<"lw16", GPRMM16Opnd, load, II_LW, mem_mm_4_lsl2>,
 505                       LOAD_STORE_FM_MM16<0x1a>;
 506 def SB16_MM : StoreMM16<"sb16", GPRMM16OpndZero, GPRMM16Opnd, truncstorei8,
 507                         II_SB, mem_mm_4>, LOAD_STORE_FM_MM16<0x22>;
 508 def SH16_MM : StoreMM16<"sh16", GPRMM16OpndZero, GPRMM16Opnd, truncstorei16,
 509                         II_SH, mem_mm_4_lsl1>,
 510                         LOAD_STORE_FM_MM16<0x2a>;
 511 def SW16_MM : StoreMM16<"sw16", GPRMM16OpndZero, GPRMM16Opnd, store, II_SW,
 512                         mem_mm_4_lsl2>, LOAD_STORE_FM_MM16<0x3a>;
 513 def LWSP_MM : LoadSPMM16<"lw", GPR32Opnd, II_LW, mem_mm_sp_imm5_lsl2>,
 514               LOAD_STORE_SP_FM_MM16<0x12>;
 515 def SWSP_MM : StoreSPMM16<"sw", GPR32Opnd, II_SW, mem_mm_sp_imm5_lsl2>,
 516               LOAD_STORE_SP_FM_MM16<0x32>;
 517 def ADDIUR1SP_MM : AddImmUR1SP<"addiur1sp", GPRMM16Opnd>, ADDIUR1SP_FM_MM16;
 518 def ADDIUR2_MM : AddImmUR2<"addiur2", GPRMM16Opnd>, ADDIUR2_FM_MM16;
 519 def ADDIUS5_MM : AddImmUS5<"addius5", GPR32Opnd>, ADDIUS5_FM_MM16;
 520 def ADDIUSP_MM : AddImmUSP<"addiusp">, ADDIUSP_FM_MM16;
 521 def MFHI16_MM : MoveFromHILOMM<"mfhi", GPR32Opnd, AC0>, MFHILO_FM_MM16<0x10>;
 522 def MFLO16_MM : MoveFromHILOMM<"mflo", GPR32Opnd, AC0>, MFHILO_FM_MM16<0x12>;
 523 def MOVE16_MM : MoveMM16<"move", GPR32Opnd>, MOVE_FM_MM16<0x03>;
 524 def LI16_MM : LoadImmMM16<"li16", li_simm7, GPRMM16Opnd>, LI_FM_MM16,
 525               IsAsCheapAsAMove;
 526 def JALR16_MM : JumpLinkRegMM16<"jalr", GPR32Opnd>, JALR_FM_MM16<0x0e>;
 527 def JALRS16_MM : JumpLinkRegSMM16<"jalrs16", GPR32Opnd>, JALR_FM_MM16<0x0f>;
 528 def JRC16_MM : JumpRegCMM16<"jrc", GPR32Opnd>, JALR_FM_MM16<0x0d>;
 529 def JRADDIUSP : JumpRAddiuStackMM16, JRADDIUSP_FM_MM16<0x18>;
 530 def JR16_MM : JumpRegMM16<"jr16", GPR32Opnd>, JALR_FM_MM16<0x0c>;
 531 def BEQZ16_MM : CBranchZeroMM<"beqz16", brtarget7_mm, GPRMM16Opnd>,
 532                 BEQNEZ_FM_MM16<0x23>;
 533 def BNEZ16_MM : CBranchZeroMM<"bnez16", brtarget7_mm, GPRMM16Opnd>,
 534                 BEQNEZ_FM_MM16<0x2b>;
 535 def BREAK16_MM : BrkSdbbp16MM<"break16">, BRKSDBBP16_FM_MM<0x28>;
 536 def SDBBP16_MM : BrkSdbbp16MM<"sdbbp16">, BRKSDBBP16_FM_MM<0x2C>;
 537
 538 class WaitMM<string opstr> :
 539   InstSE<(outs), (ins uimm10:$code_), !strconcat(opstr, "\t$code_"), [],
 540          NoItinerary, FrmOther, opstr>;
 541
 542 let DecoderNamespace = "MicroMips", Predicates = [InMicroMips] in {
 543   /// Compact Branch Instructions
 544   def BEQZC_MM : CompactBranchMM<"beqzc", brtarget_mm, seteq, GPR32Opnd>,
 545                  COMPACT_BRANCH_FM_MM<0x7>;
 546   def BNEZC_MM : CompactBranchMM<"bnezc", brtarget_mm, setne, GPR32Opnd>,
 547                  COMPACT_BRANCH_FM_MM<0x5>;
 548
 549   /// Arithmetic Instructions (ALU Immediate)
 550   def ADDiu_MM : MMRel, ArithLogicI<"addiu", simm16, GPR32Opnd>,
 551                  ADDI_FM_MM<0xc>;
 552   def ADDi_MM  : MMRel, ArithLogicI<"addi", simm16, GPR32Opnd>,
 553                  ADDI_FM_MM<0x4>;
 554   def SLTi_MM  : MMRel, SetCC_I<"slti", setlt, simm16, immSExt16, GPR32Opnd>,
 555                  SLTI_FM_MM<0x24>;
 556   def SLTiu_MM : MMRel, SetCC_I<"sltiu", setult, simm16, immSExt16, GPR32Opnd>,
 557                  SLTI_FM_MM<0x2c>;
 558   def ANDi_MM  : MMRel, ArithLogicI<"andi", uimm16, GPR32Opnd>,
 559                  ADDI_FM_MM<0x34>;
 560   def ORi_MM   : MMRel, ArithLogicI<"ori", uimm16, GPR32Opnd>,
 561                  ADDI_FM_MM<0x14>;
 562   def XORi_MM  : MMRel, ArithLogicI<"xori", uimm16, GPR32Opnd>,
 563                  ADDI_FM_MM<0x1c>;
 564   def LUi_MM   : MMRel, LoadUpper<"lui", GPR32Opnd, uimm16>, LUI_FM_MM;
 565
 566   def LEA_ADDiu_MM : MMRel, EffectiveAddress<"addiu", GPR32Opnd>,
 567                      LW_FM_MM<0xc>;
 568
 569   /// Arithmetic Instructions (3-Operand, R-Type)
 570   def ADDu_MM  : MMRel, ArithLogicR<"addu", GPR32Opnd>, ADD_FM_MM<0, 0x150>;
 571   def SUBu_MM  : MMRel, ArithLogicR<"subu", GPR32Opnd>, ADD_FM_MM<0, 0x1d0>;
 572   def MUL_MM   : MMRel, ArithLogicR<"mul", GPR32Opnd>, ADD_FM_MM<0, 0x210>;
 573   def ADD_MM   : MMRel, ArithLogicR<"add", GPR32Opnd>, ADD_FM_MM<0, 0x110>;
 574   def SUB_MM   : MMRel, ArithLogicR<"sub", GPR32Opnd>, ADD_FM_MM<0, 0x190>;
 575   def SLT_MM   : MMRel, SetCC_R<"slt", setlt, GPR32Opnd>, ADD_FM_MM<0, 0x350>;
 576   def SLTu_MM  : MMRel, SetCC_R<"sltu", setult, GPR32Opnd>,
 577                  ADD_FM_MM<0, 0x390>;
 578   def AND_MM   : MMRel, ArithLogicR<"and", GPR32Opnd, 1, II_AND, and>,
 579                  ADD_FM_MM<0, 0x250>;
 580   def OR_MM    : MMRel, ArithLogicR<"or", GPR32Opnd, 1, II_OR, or>,
 581                  ADD_FM_MM<0, 0x290>;
 582   def XOR_MM   : MMRel, ArithLogicR<"xor", GPR32Opnd, 1, II_XOR, xor>,
 583                  ADD_FM_MM<0, 0x310>;
 584   def NOR_MM   : MMRel, LogicNOR<"nor", GPR32Opnd>, ADD_FM_MM<0, 0x2d0>;
 585   def MULT_MM  : MMRel, Mult<"mult", II_MULT, GPR32Opnd, [HI0, LO0]>,
 586                  MULT_FM_MM<0x22c>;
 587   def MULTu_MM : MMRel, Mult<"multu", II_MULTU, GPR32Opnd, [HI0, LO0]>,
 588                  MULT_FM_MM<0x26c>;
 589   def SDIV_MM  : MMRel, Div<"div", II_DIV, GPR32Opnd, [HI0, LO0]>,
 590                  MULT_FM_MM<0x2ac>;
 591   def UDIV_MM  : MMRel, Div<"divu", II_DIVU, GPR32Opnd, [HI0, LO0]>,
 592                  MULT_FM_MM<0x2ec>;
 593
 594   /// Shift Instructions
 595   def SLL_MM   : MMRel, shift_rotate_imm<"sll", uimm5, GPR32Opnd, II_SLL>,
 596                  SRA_FM_MM<0, 0>;
 597   def SRL_MM   : MMRel, shift_rotate_imm<"srl", uimm5, GPR32Opnd, II_SRL>,
 598                  SRA_FM_MM<0x40, 0>;
 599   def SRA_MM   : MMRel, shift_rotate_imm<"sra", uimm5, GPR32Opnd, II_SRA>,
 600                  SRA_FM_MM<0x80, 0>;
 601   def SLLV_MM  : MMRel, shift_rotate_reg<"sllv", GPR32Opnd, II_SLLV>,
 602                  SRLV_FM_MM<0x10, 0>;
 603   def SRLV_MM  : MMRel, shift_rotate_reg<"srlv", GPR32Opnd, II_SRLV>,
 604                  SRLV_FM_MM<0x50, 0>;
 605   def SRAV_MM  : MMRel, shift_rotate_reg<"srav", GPR32Opnd, II_SRAV>,
 606                  SRLV_FM_MM<0x90, 0>;
 607   def ROTR_MM  : MMRel, shift_rotate_imm<"rotr", uimm5, GPR32Opnd, II_ROTR>,
 608                  SRA_FM_MM<0xc0, 0>;
 609   def ROTRV_MM : MMRel, shift_rotate_reg<"rotrv", GPR32Opnd, II_ROTRV>,
 610                  SRLV_FM_MM<0xd0, 0>;
 611
 612   /// Load and Store Instructions - aligned
 613   let DecoderMethod = "DecodeMemMMImm16" in {
 614     def LB_MM  : Load<"lb", GPR32Opnd>, MMRel, LW_FM_MM<0x7>;
 615     def LBu_MM : Load<"lbu", GPR32Opnd>, MMRel, LW_FM_MM<0x5>;
 616     def LH_MM  : Load<"lh", GPR32Opnd>, MMRel, LW_FM_MM<0xf>;
 617     def LHu_MM : Load<"lhu", GPR32Opnd>, MMRel, LW_FM_MM<0xd>;
 618     def LW_MM  : Load<"lw", GPR32Opnd>, MMRel, LW_FM_MM<0x3f>;
 619     def SB_MM  : Store<"sb", GPR32Opnd>, MMRel, LW_FM_MM<0x6>;
 620     def SH_MM  : Store<"sh", GPR32Opnd>, MMRel, LW_FM_MM<0xe>;
 621     def SW_MM  : Store<"sw", GPR32Opnd>, MMRel, LW_FM_MM<0x3e>;
 622   }
 623
 624   def LWXS_MM : LoadWordIndexedScaledMM<"lwxs", GPR32Opnd>, LWXS_FM_MM<0x118>;
 625
 626   def LWU_MM : LoadMM<"lwu", GPR32Opnd, zextloadi32, II_LWU>, LL_FM_MM<0xe>;
 627
 628   /// Load and Store Instructions - unaligned
 629   def LWL_MM : LoadLeftRightMM<"lwl", MipsLWL, GPR32Opnd, mem_mm_12>,
 630                LWL_FM_MM<0x0>;
 631   def LWR_MM : LoadLeftRightMM<"lwr", MipsLWR, GPR32Opnd, mem_mm_12>,
 632                LWL_FM_MM<0x1>;
 633   def SWL_MM : StoreLeftRightMM<"swl", MipsSWL, GPR32Opnd, mem_mm_12>,
 634                LWL_FM_MM<0x8>;
 635   def SWR_MM : StoreLeftRightMM<"swr", MipsSWR, GPR32Opnd, mem_mm_12>,
 636                LWL_FM_MM<0x9>;
 637
 638   /// Load and Store Instructions - multiple
 639   def SWM32_MM  : StoreMultMM<"swm32">, LWM_FM_MM<0xd>;
 640   def LWM32_MM  : LoadMultMM<"lwm32">, LWM_FM_MM<0x5>;
 641   def SWM16_MM : StoreMultMM16<"swm16">, LWM_FM_MM16<0x5>;
 642   def LWM16_MM : LoadMultMM16<"lwm16">, LWM_FM_MM16<0x4>;
 643
 644   /// Load and Store Pair Instructions
 645   def SWP_MM  : StorePairMM<"swp">, LWM_FM_MM<0x9>;
 646   def LWP_MM  : LoadPairMM<"lwp">, LWM_FM_MM<0x1>;
 647
 648   /// Move Conditional
 649   def MOVZ_I_MM : MMRel, CMov_I_I_FT<"movz", GPR32Opnd, GPR32Opnd,
 650                   NoItinerary>, ADD_FM_MM<0, 0x58>;
 651   def MOVN_I_MM : MMRel, CMov_I_I_FT<"movn", GPR32Opnd, GPR32Opnd,
 652                   NoItinerary>, ADD_FM_MM<0, 0x18>;
 653   def MOVT_I_MM : MMRel, CMov_F_I_FT<"movt", GPR32Opnd, II_MOVT>,
 654                   CMov_F_I_FM_MM<0x25>;
 655   def MOVF_I_MM : MMRel, CMov_F_I_FT<"movf", GPR32Opnd, II_MOVF>,
 656                   CMov_F_I_FM_MM<0x5>;
 657
 658   /// Move to/from HI/LO
 659   def MTHI_MM : MMRel, MoveToLOHI<"mthi", GPR32Opnd, [HI0]>,
 660                 MTLO_FM_MM<0x0b5>;
 661   def MTLO_MM : MMRel, MoveToLOHI<"mtlo", GPR32Opnd, [LO0]>,
 662                 MTLO_FM_MM<0x0f5>;
 663   def MFHI_MM : MMRel, MoveFromLOHI<"mfhi", GPR32Opnd, AC0>,
 664                 MFLO_FM_MM<0x035>;
 665   def MFLO_MM : MMRel, MoveFromLOHI<"mflo", GPR32Opnd, AC0>,
 666                 MFLO_FM_MM<0x075>;
 667
 668   /// Multiply Add/Sub Instructions
 669   def MADD_MM  : MMRel, MArithR<"madd", II_MADD, 1>, MULT_FM_MM<0x32c>;
 670   def MADDU_MM : MMRel, MArithR<"maddu", II_MADDU, 1>, MULT_FM_MM<0x36c>;
 671   def MSUB_MM  : MMRel, MArithR<"msub", II_MSUB>, MULT_FM_MM<0x3ac>;
 672   def MSUBU_MM : MMRel, MArithR<"msubu", II_MSUBU>, MULT_FM_MM<0x3ec>;
 673
 674   /// Count Leading
 675   def CLZ_MM : MMRel, CountLeading0<"clz", GPR32Opnd>, CLO_FM_MM<0x16c>,
 676                ISA_MIPS32;
 677   def CLO_MM : MMRel, CountLeading1<"clo", GPR32Opnd>, CLO_FM_MM<0x12c>,
 678                ISA_MIPS32;
 679
 680   /// Sign Ext In Register Instructions.
 681   def SEB_MM : MMRel, SignExtInReg<"seb", i8, GPR32Opnd, II_SEB>,
 682                SEB_FM_MM<0x0ac>, ISA_MIPS32R2;
 683   def SEH_MM : MMRel, SignExtInReg<"seh", i16, GPR32Opnd, II_SEH>,
 684                SEB_FM_MM<0x0ec>, ISA_MIPS32R2;
 685
 686   /// Word Swap Bytes Within Halfwords
 687   def WSBH_MM : MMRel, SubwordSwap<"wsbh", GPR32Opnd>, SEB_FM_MM<0x1ec>,
 688                 ISA_MIPS32R2;
 689
 690   def EXT_MM : MMRel, ExtBase<"ext", GPR32Opnd, uimm5, MipsExt>,
 691                EXT_FM_MM<0x2c>;
 692   def INS_MM : MMRel, InsBase<"ins", GPR32Opnd, uimm5, MipsIns>,
 693                EXT_FM_MM<0x0c>;
 694
 695   /// Jump Instructions
 696   let DecoderMethod = "DecodeJumpTargetMM" in {
 697     def J_MM        : MMRel, JumpFJ<jmptarget_mm, "j", br, bb, "j">,
 698                       J_FM_MM<0x35>;
 699     def JAL_MM      : MMRel, JumpLink<"jal", calltarget_mm>, J_FM_MM<0x3d>;
 700   }
 701   def JR_MM   : MMRel, IndirectBranch<"jr", GPR32Opnd>, JR_FM_MM<0x3c>;
 702   def JALR_MM : JumpLinkReg<"jalr", GPR32Opnd>, JALR_FM_MM<0x03c>;
 703
 704   /// Jump Instructions - Short Delay Slot
 705   def JALS_MM   : JumpLinkMM<"jals", calltarget_mm>, J_FM_MM<0x1d>;
 706   def JALRS_MM  : JumpLinkRegMM<"jalrs", GPR32Opnd>, JALR_FM_MM<0x13c>;
 707
 708   /// Branch Instructions
 709   def BEQ_MM  : MMRel, CBranch<"beq", brtarget_mm, seteq, GPR32Opnd>,
 710                 BEQ_FM_MM<0x25>;
 711   def BNE_MM  : MMRel, CBranch<"bne", brtarget_mm, setne, GPR32Opnd>,
 712                 BEQ_FM_MM<0x2d>;
 713   def BGEZ_MM : MMRel, CBranchZero<"bgez", brtarget_mm, setge, GPR32Opnd>,
 714                 BGEZ_FM_MM<0x2>;
 715   def BGTZ_MM : MMRel, CBranchZero<"bgtz", brtarget_mm, setgt, GPR32Opnd>,
 716                 BGEZ_FM_MM<0x6>;
 717   def BLEZ_MM : MMRel, CBranchZero<"blez", brtarget_mm, setle, GPR32Opnd>,
 718                 BGEZ_FM_MM<0x4>;
 719   def BLTZ_MM : MMRel, CBranchZero<"bltz", brtarget_mm, setlt, GPR32Opnd>,
 720                 BGEZ_FM_MM<0x0>;
 721   def BGEZAL_MM : MMRel, BGEZAL_FT<"bgezal", brtarget_mm, GPR32Opnd>,
 722                   BGEZAL_FM_MM<0x03>;
 723   def BLTZAL_MM : MMRel, BGEZAL_FT<"bltzal", brtarget_mm, GPR32Opnd>,
 724                   BGEZAL_FM_MM<0x01>;
 725
 726   /// Branch Instructions - Short Delay Slot
 727   def BGEZALS_MM : BranchCompareToZeroLinkMM<"bgezals", brtarget_mm,
 728                                              GPR32Opnd>, BGEZAL_FM_MM<0x13>;
 729   def BLTZALS_MM : BranchCompareToZeroLinkMM<"bltzals", brtarget_mm,
 730                                              GPR32Opnd>, BGEZAL_FM_MM<0x11>;
 731
 732   /// Control Instructions
 733   def SYNC_MM    : MMRel, SYNC_FT<"sync">, SYNC_FM_MM;
 734   def BREAK_MM   : MMRel, BRK_FT<"break">, BRK_FM_MM;
 735   def SYSCALL_MM : MMRel, SYS_FT<"syscall">, SYS_FM_MM;
 736   def WAIT_MM    : WaitMM<"wait">, WAIT_FM_MM;
 737   def ERET_MM    : MMRel, ER_FT<"eret">, ER_FM_MM<0x3cd>;
 738   def DERET_MM   : MMRel, ER_FT<"deret">, ER_FM_MM<0x38d>;
 739   def EI_MM      : MMRel, DEI_FT<"ei", GPR32Opnd>, EI_FM_MM<0x15d>,
 740                    ISA_MIPS32R2;
 741   def DI_MM      : MMRel, DEI_FT<"di", GPR32Opnd>, EI_FM_MM<0x11d>,
 742                    ISA_MIPS32R2;
 743
 744   /// Trap Instructions
 745   def TEQ_MM  : MMRel, TEQ_FT<"teq", GPR32Opnd>, TEQ_FM_MM<0x0>;
 746   def TGE_MM  : MMRel, TEQ_FT<"tge", GPR32Opnd>, TEQ_FM_MM<0x08>;
 747   def TGEU_MM : MMRel, TEQ_FT<"tgeu", GPR32Opnd>, TEQ_FM_MM<0x10>;
 748   def TLT_MM  : MMRel, TEQ_FT<"tlt", GPR32Opnd>, TEQ_FM_MM<0x20>;
 749   def TLTU_MM : MMRel, TEQ_FT<"tltu", GPR32Opnd>, TEQ_FM_MM<0x28>;
 750   def TNE_MM  : MMRel, TEQ_FT<"tne", GPR32Opnd>, TEQ_FM_MM<0x30>;
 751
 752   def TEQI_MM  : MMRel, TEQI_FT<"teqi", GPR32Opnd>, TEQI_FM_MM<0x0e>;
 753   def TGEI_MM  : MMRel, TEQI_FT<"tgei", GPR32Opnd>, TEQI_FM_MM<0x09>;
 754   def TGEIU_MM : MMRel, TEQI_FT<"tgeiu", GPR32Opnd>, TEQI_FM_MM<0x0b>;
 755   def TLTI_MM  : MMRel, TEQI_FT<"tlti", GPR32Opnd>, TEQI_FM_MM<0x08>;
 756   def TLTIU_MM : MMRel, TEQI_FT<"tltiu", GPR32Opnd>, TEQI_FM_MM<0x0a>;
 757   def TNEI_MM  : MMRel, TEQI_FT<"tnei", GPR32Opnd>, TEQI_FM_MM<0x0c>;
 758
 759   /// Load-linked, Store-conditional
 760   def LL_MM : LLBaseMM<"ll", GPR32Opnd>, LL_FM_MM<0x3>;
 761   def SC_MM : SCBaseMM<"sc", GPR32Opnd>, LL_FM_MM<0xb>;
 762
 763   let DecoderMethod = "DecodeCacheOpMM" in {
 764   def CACHE_MM : MMRel, CacheOp<"cache", mem_mm_12>,
 765                  CACHE_PREF_FM_MM<0x08, 0x6>;
 766   def PREF_MM  : MMRel, CacheOp<"pref", mem_mm_12>,
 767                  CACHE_PREF_FM_MM<0x18, 0x2>;
 768   }
 769   def SSNOP_MM : MMRel, Barrier<"ssnop">, BARRIER_FM_MM<0x1>;
 770   def EHB_MM   : MMRel, Barrier<"ehb">, BARRIER_FM_MM<0x3>;
 771   def PAUSE_MM : MMRel, Barrier<"pause">, BARRIER_FM_MM<0x5>;
 772
 773   def TLBP_MM : MMRel, TLB<"tlbp">, COP0_TLB_FM_MM<0x0d>;
 774   def TLBR_MM : MMRel, TLB<"tlbr">, COP0_TLB_FM_MM<0x4d>;
 775   def TLBWI_MM : MMRel, TLB<"tlbwi">, COP0_TLB_FM_MM<0x8d>;
 776   def TLBWR_MM : MMRel, TLB<"tlbwr">, COP0_TLB_FM_MM<0xcd>;
 777
 778   def SDBBP_MM : MMRel, SYS_FT<"sdbbp">, SDBBP_FM_MM;
 779   def RDHWR_MM : MMRel, ReadHardware<GPR32Opnd, HWRegsOpnd>, RDHWR_FM_MM;
 780 }
 781
 782 let Predicates = [InMicroMips] in {
 783
 784 //===----------------------------------------------------------------------===//
 785 // MicroMips arbitrary patterns that map to one or more instructions
 786 //===----------------------------------------------------------------------===//
 787
 788 def : MipsPat<(i32 immLi16:$imm),
 789               (LI16_MM immLi16:$imm)>;
 790 def : MipsPat<(i32 immSExt16:$imm),
 791               (ADDiu_MM ZERO, immSExt16:$imm)>;
 792 def : MipsPat<(i32 immZExt16:$imm),
 793               (ORi_MM ZERO, immZExt16:$imm)>;
 794
 795 def : MipsPat<(add GPRMM16:$src, immSExtAddiur2:$imm),
 796               (ADDIUR2_MM GPRMM16:$src, immSExtAddiur2:$imm)>;
 797 def : MipsPat<(add GPR32:$src, immSExtAddius5:$imm),
 798               (ADDIUS5_MM GPR32:$src, immSExtAddius5:$imm)>;
 799 def : MipsPat<(add GPR32:$src, immSExt16:$imm),
 800               (ADDiu_MM GPR32:$src, immSExt16:$imm)>;
 801
 802 def : MipsPat<(and GPRMM16:$src, immZExtAndi16:$imm),
 803               (ANDI16_MM GPRMM16:$src, immZExtAndi16:$imm)>;
 804 def : MipsPat<(and GPR32:$src, immZExt16:$imm),
 805               (ANDi_MM GPR32:$src, immZExt16:$imm)>;
 806
 807 def : MipsPat<(shl GPRMM16:$src, immZExt2Shift:$imm),
 808               (SLL16_MM GPRMM16:$src, immZExt2Shift:$imm)>;
 809 def : MipsPat<(shl GPR32:$src, immZExt5:$imm),
 810               (SLL_MM GPR32:$src, immZExt5:$imm)>;
 811
 812 def : MipsPat<(srl GPRMM16:$src, immZExt2Shift:$imm),
 813               (SRL16_MM GPRMM16:$src, immZExt2Shift:$imm)>;
 814 def : MipsPat<(srl GPR32:$src, immZExt5:$imm),
 815               (SRL_MM GPR32:$src, immZExt5:$imm)>;
 816
 817 //===----------------------------------------------------------------------===//
 818 // MicroMips instruction aliases
 819 //===----------------------------------------------------------------------===//
 820
 821   def : MipsInstAlias<"wait", (WAIT_MM 0x0), 1>;
 822   def : MipsInstAlias<"nop", (SLL_MM ZERO, ZERO, 0), 1>;
 823   def : MipsInstAlias<"nop", (MOVE16_MM ZERO, ZERO), 1>;
 824 }