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