2013-08-14 04:19:16 +08:00
|
|
|
def addrimm12 : ComplexPattern<iPTR, 2, "selectIntAddrMM", [frameindex]>;
|
|
|
|
|
|
2014-10-10 21:45:34 +08:00
|
|
|
def simm4 : Operand<i32>;
|
|
|
|
|
|
2013-08-14 04:19:16 +08:00
|
|
|
def simm12 : Operand<i32> {
|
|
|
|
|
let DecoderMethod = "DecodeSimm12";
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-12 22:29:54 +08:00
|
|
|
def uimm5_lsl2 : Operand<OtherVT> {
|
|
|
|
|
let EncoderMethod = "getUImm5Lsl2Encoding";
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 22:37:30 +08:00
|
|
|
def simm9_addiusp : Operand<i32> {
|
|
|
|
|
let EncoderMethod = "getSImm9AddiuspValue";
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-14 04:19:16 +08:00
|
|
|
def mem_mm_12 : Operand<i32> {
|
|
|
|
|
let PrintMethod = "printMemOperand";
|
|
|
|
|
let MIOperandInfo = (ops GPR32, simm12);
|
|
|
|
|
let EncoderMethod = "getMemEncodingMMImm12";
|
|
|
|
|
let ParserMatchClass = MipsMemAsmOperand;
|
|
|
|
|
let OperandType = "OPERAND_MEMORY";
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-30 00:38:59 +08:00
|
|
|
def jmptarget_mm : Operand<OtherVT> {
|
|
|
|
|
let EncoderMethod = "getJumpTargetOpValueMM";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
def calltarget_mm : Operand<iPTR> {
|
|
|
|
|
let EncoderMethod = "getJumpTargetOpValueMM";
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-04 22:53:22 +08:00
|
|
|
def brtarget_mm : Operand<OtherVT> {
|
|
|
|
|
let EncoderMethod = "getBranchTargetOpValueMM";
|
|
|
|
|
let OperandType = "OPERAND_PCREL";
|
|
|
|
|
let DecoderMethod = "DecodeBranchTargetMM";
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-14 20:09:10 +08:00
|
|
|
class CompactBranchMM<string opstr, DAGOperand opnd, PatFrag cond_op,
|
|
|
|
|
RegisterOperand RO> :
|
|
|
|
|
InstSE<(outs), (ins RO:$rs, opnd:$offset),
|
|
|
|
|
!strconcat(opstr, "\t$rs, $offset"), [], IIBranch, FrmI> {
|
|
|
|
|
let isBranch = 1;
|
|
|
|
|
let isTerminator = 1;
|
|
|
|
|
let hasDelaySlot = 0;
|
|
|
|
|
let Defs = [AT];
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-14 04:19:16 +08:00
|
|
|
let canFoldAsLoad = 1 in
|
|
|
|
|
class LoadLeftRightMM<string opstr, SDNode OpNode, RegisterOperand RO,
|
|
|
|
|
Operand MemOpnd> :
|
|
|
|
|
InstSE<(outs RO:$rt), (ins MemOpnd:$addr, RO:$src),
|
|
|
|
|
!strconcat(opstr, "\t$rt, $addr"),
|
|
|
|
|
[(set RO:$rt, (OpNode addrimm12:$addr, RO:$src))],
|
|
|
|
|
NoItinerary, FrmI> {
|
2013-09-06 20:30:36 +08:00
|
|
|
let DecoderMethod = "DecodeMemMMImm12";
|
2013-08-14 04:19:16 +08:00
|
|
|
string Constraints = "$src = $rt";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class StoreLeftRightMM<string opstr, SDNode OpNode, RegisterOperand RO,
|
|
|
|
|
Operand MemOpnd>:
|
|
|
|
|
InstSE<(outs), (ins RO:$rt, MemOpnd:$addr),
|
|
|
|
|
!strconcat(opstr, "\t$rt, $addr"),
|
2013-09-06 20:30:36 +08:00
|
|
|
[(OpNode RO:$rt, addrimm12:$addr)], NoItinerary, FrmI> {
|
|
|
|
|
let DecoderMethod = "DecodeMemMMImm12";
|
|
|
|
|
}
|
2013-08-14 04:19:16 +08:00
|
|
|
|
2013-12-20 00:12:56 +08:00
|
|
|
class LLBaseMM<string opstr, RegisterOperand RO> :
|
|
|
|
|
InstSE<(outs RO:$rt), (ins mem_mm_12:$addr),
|
|
|
|
|
!strconcat(opstr, "\t$rt, $addr"), [], NoItinerary, FrmI> {
|
2014-01-15 21:17:33 +08:00
|
|
|
let DecoderMethod = "DecodeMemMMImm12";
|
2013-12-20 00:12:56 +08:00
|
|
|
let mayLoad = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class SCBaseMM<string opstr, RegisterOperand RO> :
|
2014-03-01 02:22:56 +08:00
|
|
|
InstSE<(outs RO:$dst), (ins RO:$rt, mem_mm_12:$addr),
|
2013-12-20 00:12:56 +08:00
|
|
|
!strconcat(opstr, "\t$rt, $addr"), [], NoItinerary, FrmI> {
|
2014-01-15 21:17:33 +08:00
|
|
|
let DecoderMethod = "DecodeMemMMImm12";
|
2013-12-20 00:12:56 +08:00
|
|
|
let mayStore = 1;
|
2014-03-01 02:22:56 +08:00
|
|
|
let Constraints = "$rt = $dst";
|
2013-12-20 00:12:56 +08:00
|
|
|
}
|
|
|
|
|
|
2014-01-15 21:01:18 +08:00
|
|
|
class LoadMM<string opstr, DAGOperand RO, SDPatternOperator OpNode = null_frag,
|
|
|
|
|
InstrItinClass Itin = NoItinerary> :
|
|
|
|
|
InstSE<(outs RO:$rt), (ins mem_mm_12:$addr),
|
|
|
|
|
!strconcat(opstr, "\t$rt, $addr"),
|
|
|
|
|
[(set RO:$rt, (OpNode addrimm12:$addr))], Itin, FrmI> {
|
|
|
|
|
let DecoderMethod = "DecodeMemMMImm12";
|
|
|
|
|
let canFoldAsLoad = 1;
|
|
|
|
|
let mayLoad = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 21:45:34 +08:00
|
|
|
class AddImmUS5<string opstr, RegisterOperand RO> :
|
|
|
|
|
MicroMipsInst16<(outs RO:$dst), (ins RO:$rd, simm4:$imm),
|
|
|
|
|
!strconcat(opstr, "\t$rd, $imm"), [], NoItinerary, FrmR> {
|
|
|
|
|
let Constraints = "$rd = $dst";
|
|
|
|
|
let isCommutable = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 22:37:30 +08:00
|
|
|
class AddImmUSP<string opstr> :
|
|
|
|
|
MicroMipsInst16<(outs), (ins simm9_addiusp:$imm),
|
|
|
|
|
!strconcat(opstr, "\t$imm"), [], NoItinerary, FrmI>;
|
|
|
|
|
|
2014-04-03 20:47:34 +08:00
|
|
|
class MoveFromHILOMM<string opstr, RegisterOperand RO, Register UseReg> :
|
|
|
|
|
MicroMipsInst16<(outs RO:$rd), (ins), !strconcat(opstr, "\t$rd"),
|
|
|
|
|
[], II_MFHI_MFLO, FrmR> {
|
|
|
|
|
let Uses = [UseReg];
|
|
|
|
|
let hasSideEffects = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-20 18:18:24 +08:00
|
|
|
class MoveMM16<string opstr, RegisterOperand RO, bit isComm = 0,
|
|
|
|
|
InstrItinClass Itin = NoItinerary> :
|
|
|
|
|
MicroMipsInst16<(outs RO:$rd), (ins RO:$rs),
|
|
|
|
|
!strconcat(opstr, "\t$rd, $rs"), [], Itin, FrmR> {
|
|
|
|
|
let isCommutable = isComm;
|
|
|
|
|
let isReMaterializable = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 16-bit Jump and Link (Call)
|
|
|
|
|
class JumpLinkRegMM16<string opstr, RegisterOperand RO> :
|
|
|
|
|
MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
|
2014-03-31 22:00:10 +08:00
|
|
|
[(MipsJmpLink RO:$rs)], IIBranch, FrmR> {
|
2014-03-20 18:18:24 +08:00
|
|
|
let isCall = 1;
|
|
|
|
|
let hasDelaySlot = 1;
|
|
|
|
|
let Defs = [RA];
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 22:02:44 +08:00
|
|
|
// 16-bit Jump Reg
|
|
|
|
|
class JumpRegMM16<string opstr, RegisterOperand RO> :
|
|
|
|
|
MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
|
|
|
|
|
[], IIBranch, FrmR> {
|
|
|
|
|
let hasDelaySlot = 1;
|
|
|
|
|
let isBranch = 1;
|
|
|
|
|
let isIndirectBranch = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-12 22:29:54 +08:00
|
|
|
// Base class for JRADDIUSP instruction.
|
|
|
|
|
class JumpRAddiuStackMM16 :
|
|
|
|
|
MicroMipsInst16<(outs), (ins uimm5_lsl2:$imm), "jraddiusp\t$imm",
|
|
|
|
|
[], IIBranch, FrmR> {
|
|
|
|
|
let isTerminator = 1;
|
|
|
|
|
let isBarrier = 1;
|
|
|
|
|
let hasDelaySlot = 1;
|
|
|
|
|
let isBranch = 1;
|
|
|
|
|
let isIndirectBranch = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 21:22:28 +08:00
|
|
|
// 16-bit Jump and Link (Call) - Short Delay Slot
|
|
|
|
|
class JumpLinkRegSMM16<string opstr, RegisterOperand RO> :
|
|
|
|
|
MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
|
|
|
|
|
[], IIBranch, FrmR> {
|
|
|
|
|
let isCall = 1;
|
|
|
|
|
let hasDelaySlot = 1;
|
|
|
|
|
let Defs = [RA];
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-10 21:31:18 +08:00
|
|
|
// 16-bit Jump Register Compact - No delay slot
|
|
|
|
|
class JumpRegCMM16<string opstr, RegisterOperand RO> :
|
|
|
|
|
MicroMipsInst16<(outs), (ins RO:$rs), !strconcat(opstr, "\t$rs"),
|
|
|
|
|
[], IIBranch, FrmR> {
|
|
|
|
|
let isTerminator = 1;
|
|
|
|
|
let isBarrier = 1;
|
|
|
|
|
let isBranch = 1;
|
|
|
|
|
let isIndirectBranch = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-12 21:43:41 +08:00
|
|
|
// MicroMIPS Jump and Link (Call) - Short Delay Slot
|
|
|
|
|
let isCall = 1, hasDelaySlot = 1, Defs = [RA] in {
|
|
|
|
|
class JumpLinkMM<string opstr, DAGOperand opnd> :
|
|
|
|
|
InstSE<(outs), (ins opnd:$target), !strconcat(opstr, "\t$target"),
|
|
|
|
|
[], IIBranch, FrmJ, opstr> {
|
|
|
|
|
let DecoderMethod = "DecodeJumpTargetMM";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class JumpLinkRegMM<string opstr, RegisterOperand RO>:
|
|
|
|
|
InstSE<(outs RO:$rd), (ins RO:$rs), !strconcat(opstr, "\t$rd, $rs"),
|
|
|
|
|
[], IIBranch, FrmR>;
|
2014-09-12 21:51:58 +08:00
|
|
|
|
|
|
|
|
class BranchCompareToZeroLinkMM<string opstr, DAGOperand opnd,
|
|
|
|
|
RegisterOperand RO> :
|
|
|
|
|
InstSE<(outs), (ins RO:$rs, opnd:$offset),
|
|
|
|
|
!strconcat(opstr, "\t$rs, $offset"), [], IIBranch, FrmI, opstr>;
|
2014-09-12 21:43:41 +08:00
|
|
|
}
|
|
|
|
|
|
2014-10-10 21:45:34 +08:00
|
|
|
def ADDIUS5_MM : AddImmUS5<"addius5", GPR32Opnd>, ADDIUS5_FM_MM16;
|
2014-10-10 22:37:30 +08:00
|
|
|
def ADDIUSP_MM : AddImmUSP<"addiusp">, ADDIUSP_FM_MM16;
|
2014-04-03 20:47:34 +08:00
|
|
|
def MFHI16_MM : MoveFromHILOMM<"mfhi", GPR32Opnd, AC0>, MFHILO_FM_MM16<0x10>;
|
|
|
|
|
def MFLO16_MM : MoveFromHILOMM<"mflo", GPR32Opnd, AC0>, MFHILO_FM_MM16<0x12>;
|
2014-03-20 18:18:24 +08:00
|
|
|
def MOVE16_MM : MoveMM16<"move", GPR32Opnd>, MOVE_FM_MM16<0x03>;
|
|
|
|
|
def JALR16_MM : JumpLinkRegMM16<"jalr", GPR32Opnd>, JALR_FM_MM16<0x0e>;
|
2014-10-10 21:22:28 +08:00
|
|
|
def JALRS16_MM : JumpLinkRegSMM16<"jalrs16", GPR32Opnd>, JALR_FM_MM16<0x0f>;
|
2014-10-10 21:31:18 +08:00
|
|
|
def JRC16_MM : JumpRegCMM16<"jrc", GPR32Opnd>, JALR_FM_MM16<0x0d>;
|
2014-09-12 22:29:54 +08:00
|
|
|
def JRADDIUSP : JumpRAddiuStackMM16, JRADDIUSP_FM_MM16<0x18>;
|
2014-10-10 22:02:44 +08:00
|
|
|
def JR16_MM : JumpRegMM16<"jr16", GPR32Opnd>, JALR_FM_MM16<0x0c>;
|
2014-03-20 18:18:24 +08:00
|
|
|
|
2014-03-20 18:41:37 +08:00
|
|
|
class WaitMM<string opstr> :
|
|
|
|
|
InstSE<(outs), (ins uimm10:$code_), !strconcat(opstr, "\t$code_"), [],
|
|
|
|
|
NoItinerary, FrmOther, opstr>;
|
|
|
|
|
|
2013-08-21 04:46:51 +08:00
|
|
|
let DecoderNamespace = "MicroMips", Predicates = [InMicroMips] in {
|
2014-08-14 20:09:10 +08:00
|
|
|
/// Compact Branch Instructions
|
|
|
|
|
def BEQZC_MM : CompactBranchMM<"beqzc", brtarget_mm, seteq, GPR32Opnd>,
|
|
|
|
|
COMPACT_BRANCH_FM_MM<0x7>;
|
|
|
|
|
def BNEZC_MM : CompactBranchMM<"bnezc", brtarget_mm, setne, GPR32Opnd>,
|
|
|
|
|
COMPACT_BRANCH_FM_MM<0x5>;
|
|
|
|
|
|
2013-04-20 03:03:11 +08:00
|
|
|
/// Arithmetic Instructions (ALU Immediate)
|
2013-08-07 07:08:38 +08:00
|
|
|
def ADDiu_MM : MMRel, ArithLogicI<"addiu", simm16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADDI_FM_MM<0xc>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def ADDi_MM : MMRel, ArithLogicI<"addi", simm16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADDI_FM_MM<0x4>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def SLTi_MM : MMRel, SetCC_I<"slti", setlt, simm16, immSExt16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
SLTI_FM_MM<0x24>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def SLTiu_MM : MMRel, SetCC_I<"sltiu", setult, simm16, immSExt16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
SLTI_FM_MM<0x2c>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def ANDi_MM : MMRel, ArithLogicI<"andi", uimm16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADDI_FM_MM<0x34>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def ORi_MM : MMRel, ArithLogicI<"ori", uimm16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADDI_FM_MM<0x14>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def XORi_MM : MMRel, ArithLogicI<"xori", uimm16, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADDI_FM_MM<0x1c>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def LUi_MM : MMRel, LoadUpper<"lui", GPR32Opnd, uimm16>, LUI_FM_MM;
|
2013-04-20 03:03:11 +08:00
|
|
|
|
2013-12-25 18:14:07 +08:00
|
|
|
def LEA_ADDiu_MM : MMRel, EffectiveAddress<"addiu", GPR32Opnd>,
|
|
|
|
|
LW_FM_MM<0xc>;
|
|
|
|
|
|
2013-04-20 03:03:11 +08:00
|
|
|
/// Arithmetic Instructions (3-Operand, R-Type)
|
2013-08-07 07:08:38 +08:00
|
|
|
def ADDu_MM : MMRel, ArithLogicR<"addu", GPR32Opnd>, ADD_FM_MM<0, 0x150>;
|
|
|
|
|
def SUBu_MM : MMRel, ArithLogicR<"subu", GPR32Opnd>, ADD_FM_MM<0, 0x1d0>;
|
|
|
|
|
def MUL_MM : MMRel, ArithLogicR<"mul", GPR32Opnd>, ADD_FM_MM<0, 0x210>;
|
|
|
|
|
def ADD_MM : MMRel, ArithLogicR<"add", GPR32Opnd>, ADD_FM_MM<0, 0x110>;
|
|
|
|
|
def SUB_MM : MMRel, ArithLogicR<"sub", GPR32Opnd>, ADD_FM_MM<0, 0x190>;
|
|
|
|
|
def SLT_MM : MMRel, SetCC_R<"slt", setlt, GPR32Opnd>, ADD_FM_MM<0, 0x350>;
|
|
|
|
|
def SLTu_MM : MMRel, SetCC_R<"sltu", setult, GPR32Opnd>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADD_FM_MM<0, 0x390>;
|
2014-01-17 01:13:57 +08:00
|
|
|
def AND_MM : MMRel, ArithLogicR<"and", GPR32Opnd, 1, II_AND, and>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADD_FM_MM<0, 0x250>;
|
2014-01-17 01:13:57 +08:00
|
|
|
def OR_MM : MMRel, ArithLogicR<"or", GPR32Opnd, 1, II_OR, or>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADD_FM_MM<0, 0x290>;
|
2014-01-17 01:13:57 +08:00
|
|
|
def XOR_MM : MMRel, ArithLogicR<"xor", GPR32Opnd, 1, II_XOR, xor>,
|
2013-04-20 03:03:11 +08:00
|
|
|
ADD_FM_MM<0, 0x310>;
|
2013-08-07 07:08:38 +08:00
|
|
|
def NOR_MM : MMRel, LogicNOR<"nor", GPR32Opnd>, ADD_FM_MM<0, 0x2d0>;
|
2014-01-17 22:32:41 +08:00
|
|
|
def MULT_MM : MMRel, Mult<"mult", II_MULT, GPR32Opnd, [HI0, LO0]>,
|
2013-04-20 03:03:11 +08:00
|
|
|
MULT_FM_MM<0x22c>;
|
2014-01-17 22:32:41 +08:00
|
|
|
def MULTu_MM : MMRel, Mult<"multu", II_MULTU, GPR32Opnd, [HI0, LO0]>,
|
2013-04-20 03:03:11 +08:00
|
|
|
MULT_FM_MM<0x26c>;
|
2014-01-17 22:48:06 +08:00
|
|
|
def SDIV_MM : MMRel, Div<"div", II_DIV, GPR32Opnd, [HI0, LO0]>,
|
2013-09-14 15:15:21 +08:00
|
|
|
MULT_FM_MM<0x2ac>;
|
2014-01-17 22:48:06 +08:00
|
|
|
def UDIV_MM : MMRel, Div<"divu", II_DIVU, GPR32Opnd, [HI0, LO0]>,
|
2013-09-14 15:15:21 +08:00
|
|
|
MULT_FM_MM<0x2ec>;
|
2013-04-25 09:11:15 +08:00
|
|
|
|
|
|
|
|
/// Shift Instructions
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SLL_MM : MMRel, shift_rotate_imm<"sll", uimm5, GPR32Opnd, II_SLL>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRA_FM_MM<0, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SRL_MM : MMRel, shift_rotate_imm<"srl", uimm5, GPR32Opnd, II_SRL>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRA_FM_MM<0x40, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SRA_MM : MMRel, shift_rotate_imm<"sra", uimm5, GPR32Opnd, II_SRA>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRA_FM_MM<0x80, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SLLV_MM : MMRel, shift_rotate_reg<"sllv", GPR32Opnd, II_SLLV>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRLV_FM_MM<0x10, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SRLV_MM : MMRel, shift_rotate_reg<"srlv", GPR32Opnd, II_SRLV>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRLV_FM_MM<0x50, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def SRAV_MM : MMRel, shift_rotate_reg<"srav", GPR32Opnd, II_SRAV>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRLV_FM_MM<0x90, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def ROTR_MM : MMRel, shift_rotate_imm<"rotr", uimm5, GPR32Opnd, II_ROTR>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRA_FM_MM<0xc0, 0>;
|
[mips][sched] Split IIArith in preparation for the first scheduler targeting a specific MIPS CPU.
IIArith -> II_ADD, II_ADDU, II_AND, II_CL[ZO], II_DADDIU, II_DADDU,
II_DROTR, II_DROTR32, II_DROTRV, II_DSLL, II_DSLL32, II_DSLLV,
II_DSR[AL], II_DSR[AL]32, II_DSR[AL]V, II_DSUBU, II_LUI, II_MOV[ZFNT],
II_NOR, II_OR, II_RDHWR, II_ROTR, II_ROTRV, II_SLL, II_SLLV, II_SR[AL],
II_SR[AL]V, II_SUBU, II_XOR
No functional change since the InstrItinData's have been duplicated.
This is necessary because the classes are shared between all schedulers.
Once this patch series is committed there will be an InstrItinClass for
each mnemonic with minimal grouping. This does increase the size of the
itinerary tables for each MIPS scheduler but we have a few options for dealing
with that later. These options include reducing the number of classes once
we see the best way to simplify them, or by extending tablegen to be able
to compress the table by eliminating duplicates entries, etc.
llvm-svn: 199391
2014-01-16 22:27:20 +08:00
|
|
|
def ROTRV_MM : MMRel, shift_rotate_reg<"rotrv", GPR32Opnd, II_ROTRV>,
|
2013-04-25 09:11:15 +08:00
|
|
|
SRLV_FM_MM<0xd0, 0>;
|
2013-04-25 09:21:25 +08:00
|
|
|
|
|
|
|
|
/// Load and Store Instructions - aligned
|
2013-09-06 20:30:36 +08:00
|
|
|
let DecoderMethod = "DecodeMemMMImm16" in {
|
|
|
|
|
def LB_MM : Load<"lb", GPR32Opnd>, MMRel, LW_FM_MM<0x7>;
|
|
|
|
|
def LBu_MM : Load<"lbu", GPR32Opnd>, MMRel, LW_FM_MM<0x5>;
|
|
|
|
|
def LH_MM : Load<"lh", GPR32Opnd>, MMRel, LW_FM_MM<0xf>;
|
|
|
|
|
def LHu_MM : Load<"lhu", GPR32Opnd>, MMRel, LW_FM_MM<0xd>;
|
|
|
|
|
def LW_MM : Load<"lw", GPR32Opnd>, MMRel, LW_FM_MM<0x3f>;
|
|
|
|
|
def SB_MM : Store<"sb", GPR32Opnd>, MMRel, LW_FM_MM<0x6>;
|
|
|
|
|
def SH_MM : Store<"sh", GPR32Opnd>, MMRel, LW_FM_MM<0xe>;
|
|
|
|
|
def SW_MM : Store<"sw", GPR32Opnd>, MMRel, LW_FM_MM<0x3e>;
|
|
|
|
|
}
|
2013-08-14 04:19:16 +08:00
|
|
|
|
2014-01-21 23:21:14 +08:00
|
|
|
def LWU_MM : LoadMM<"lwu", GPR32Opnd, zextloadi32, II_LWU>, LL_FM_MM<0xe>;
|
2014-01-15 21:01:18 +08:00
|
|
|
|
2013-08-14 04:19:16 +08:00
|
|
|
/// Load and Store Instructions - unaligned
|
2013-08-21 04:46:51 +08:00
|
|
|
def LWL_MM : LoadLeftRightMM<"lwl", MipsLWL, GPR32Opnd, mem_mm_12>,
|
|
|
|
|
LWL_FM_MM<0x0>;
|
|
|
|
|
def LWR_MM : LoadLeftRightMM<"lwr", MipsLWR, GPR32Opnd, mem_mm_12>,
|
|
|
|
|
LWL_FM_MM<0x1>;
|
|
|
|
|
def SWL_MM : StoreLeftRightMM<"swl", MipsSWL, GPR32Opnd, mem_mm_12>,
|
|
|
|
|
LWL_FM_MM<0x8>;
|
|
|
|
|
def SWR_MM : StoreLeftRightMM<"swr", MipsSWR, GPR32Opnd, mem_mm_12>,
|
|
|
|
|
LWL_FM_MM<0x9>;
|
2013-09-06 20:41:17 +08:00
|
|
|
|
|
|
|
|
/// Move Conditional
|
|
|
|
|
def MOVZ_I_MM : MMRel, CMov_I_I_FT<"movz", GPR32Opnd, GPR32Opnd,
|
|
|
|
|
NoItinerary>, ADD_FM_MM<0, 0x58>;
|
|
|
|
|
def MOVN_I_MM : MMRel, CMov_I_I_FT<"movn", GPR32Opnd, GPR32Opnd,
|
|
|
|
|
NoItinerary>, ADD_FM_MM<0, 0x18>;
|
2014-01-17 01:13:57 +08:00
|
|
|
def MOVT_I_MM : MMRel, CMov_F_I_FT<"movt", GPR32Opnd, II_MOVT>,
|
2013-09-06 20:41:17 +08:00
|
|
|
CMov_F_I_FM_MM<0x25>;
|
2014-01-17 01:13:57 +08:00
|
|
|
def MOVF_I_MM : MMRel, CMov_F_I_FT<"movf", GPR32Opnd, II_MOVF>,
|
2013-09-06 20:41:17 +08:00
|
|
|
CMov_F_I_FM_MM<0x5>;
|
2013-09-06 20:53:21 +08:00
|
|
|
|
|
|
|
|
/// Move to/from HI/LO
|
|
|
|
|
def MTHI_MM : MMRel, MoveToLOHI<"mthi", GPR32Opnd, [HI0]>,
|
|
|
|
|
MTLO_FM_MM<0x0b5>;
|
|
|
|
|
def MTLO_MM : MMRel, MoveToLOHI<"mtlo", GPR32Opnd, [LO0]>,
|
|
|
|
|
MTLO_FM_MM<0x0f5>;
|
2013-10-08 02:49:46 +08:00
|
|
|
def MFHI_MM : MMRel, MoveFromLOHI<"mfhi", GPR32Opnd, AC0>,
|
2013-09-06 20:53:21 +08:00
|
|
|
MFLO_FM_MM<0x035>;
|
2013-10-08 02:49:46 +08:00
|
|
|
def MFLO_MM : MMRel, MoveFromLOHI<"mflo", GPR32Opnd, AC0>,
|
2013-09-06 20:53:21 +08:00
|
|
|
MFLO_FM_MM<0x075>;
|
2013-09-06 21:08:00 +08:00
|
|
|
|
|
|
|
|
/// Multiply Add/Sub Instructions
|
2014-01-17 22:32:41 +08:00
|
|
|
def MADD_MM : MMRel, MArithR<"madd", II_MADD, 1>, MULT_FM_MM<0x32c>;
|
|
|
|
|
def MADDU_MM : MMRel, MArithR<"maddu", II_MADDU, 1>, MULT_FM_MM<0x36c>;
|
|
|
|
|
def MSUB_MM : MMRel, MArithR<"msub", II_MSUB>, MULT_FM_MM<0x3ac>;
|
|
|
|
|
def MSUBU_MM : MMRel, MArithR<"msubu", II_MSUBU>, MULT_FM_MM<0x3ec>;
|
2013-09-14 14:49:25 +08:00
|
|
|
|
|
|
|
|
/// Count Leading
|
2014-05-12 20:41:59 +08:00
|
|
|
def CLZ_MM : MMRel, CountLeading0<"clz", GPR32Opnd>, CLO_FM_MM<0x16c>,
|
|
|
|
|
ISA_MIPS32;
|
|
|
|
|
def CLO_MM : MMRel, CountLeading1<"clo", GPR32Opnd>, CLO_FM_MM<0x12c>,
|
|
|
|
|
ISA_MIPS32;
|
2013-09-14 14:49:25 +08:00
|
|
|
|
|
|
|
|
/// Sign Ext In Register Instructions.
|
2014-05-12 20:28:15 +08:00
|
|
|
def SEB_MM : MMRel, SignExtInReg<"seb", i8, GPR32Opnd, II_SEB>,
|
|
|
|
|
SEB_FM_MM<0x0ac>, ISA_MIPS32R2;
|
|
|
|
|
def SEH_MM : MMRel, SignExtInReg<"seh", i16, GPR32Opnd, II_SEH>,
|
|
|
|
|
SEB_FM_MM<0x0ec>, ISA_MIPS32R2;
|
2013-09-14 14:49:25 +08:00
|
|
|
|
|
|
|
|
/// Word Swap Bytes Within Halfwords
|
2014-05-12 20:15:41 +08:00
|
|
|
def WSBH_MM : MMRel, SubwordSwap<"wsbh", GPR32Opnd>, SEB_FM_MM<0x1ec>,
|
|
|
|
|
ISA_MIPS32R2;
|
2013-09-14 14:49:25 +08:00
|
|
|
|
|
|
|
|
def EXT_MM : MMRel, ExtBase<"ext", GPR32Opnd, uimm5, MipsExt>,
|
|
|
|
|
EXT_FM_MM<0x2c>;
|
|
|
|
|
def INS_MM : MMRel, InsBase<"ins", GPR32Opnd, uimm5, MipsIns>,
|
|
|
|
|
EXT_FM_MM<0x0c>;
|
2013-10-30 00:38:59 +08:00
|
|
|
|
|
|
|
|
/// Jump Instructions
|
|
|
|
|
let DecoderMethod = "DecodeJumpTargetMM" in {
|
|
|
|
|
def J_MM : MMRel, JumpFJ<jmptarget_mm, "j", br, bb, "j">,
|
|
|
|
|
J_FM_MM<0x35>;
|
|
|
|
|
def JAL_MM : MMRel, JumpLink<"jal", calltarget_mm>, J_FM_MM<0x3d>;
|
|
|
|
|
}
|
|
|
|
|
def JR_MM : MMRel, IndirectBranch<"jr", GPR32Opnd>, JR_FM_MM<0x3c>;
|
2014-03-20 18:18:24 +08:00
|
|
|
def JALR_MM : JumpLinkReg<"jalr", GPR32Opnd>, JALR_FM_MM<0x03c>;
|
2013-11-04 22:53:22 +08:00
|
|
|
|
2014-09-12 21:43:41 +08:00
|
|
|
/// Jump Instructions - Short Delay Slot
|
|
|
|
|
def JALS_MM : JumpLinkMM<"jals", calltarget_mm>, J_FM_MM<0x1d>;
|
|
|
|
|
def JALRS_MM : JumpLinkRegMM<"jalrs", GPR32Opnd>, JALR_FM_MM<0x13c>;
|
|
|
|
|
|
2013-11-04 22:53:22 +08:00
|
|
|
/// Branch Instructions
|
|
|
|
|
def BEQ_MM : MMRel, CBranch<"beq", brtarget_mm, seteq, GPR32Opnd>,
|
|
|
|
|
BEQ_FM_MM<0x25>;
|
|
|
|
|
def BNE_MM : MMRel, CBranch<"bne", brtarget_mm, setne, GPR32Opnd>,
|
|
|
|
|
BEQ_FM_MM<0x2d>;
|
|
|
|
|
def BGEZ_MM : MMRel, CBranchZero<"bgez", brtarget_mm, setge, GPR32Opnd>,
|
|
|
|
|
BGEZ_FM_MM<0x2>;
|
|
|
|
|
def BGTZ_MM : MMRel, CBranchZero<"bgtz", brtarget_mm, setgt, GPR32Opnd>,
|
|
|
|
|
BGEZ_FM_MM<0x6>;
|
|
|
|
|
def BLEZ_MM : MMRel, CBranchZero<"blez", brtarget_mm, setle, GPR32Opnd>,
|
|
|
|
|
BGEZ_FM_MM<0x4>;
|
|
|
|
|
def BLTZ_MM : MMRel, CBranchZero<"bltz", brtarget_mm, setlt, GPR32Opnd>,
|
|
|
|
|
BGEZ_FM_MM<0x0>;
|
|
|
|
|
def BGEZAL_MM : MMRel, BGEZAL_FT<"bgezal", brtarget_mm, GPR32Opnd>,
|
|
|
|
|
BGEZAL_FM_MM<0x03>;
|
|
|
|
|
def BLTZAL_MM : MMRel, BGEZAL_FT<"bltzal", brtarget_mm, GPR32Opnd>,
|
|
|
|
|
BGEZAL_FM_MM<0x01>;
|
2013-11-07 22:35:24 +08:00
|
|
|
|
2014-09-12 21:51:58 +08:00
|
|
|
/// Branch Instructions - Short Delay Slot
|
|
|
|
|
def BGEZALS_MM : BranchCompareToZeroLinkMM<"bgezals", brtarget_mm,
|
|
|
|
|
GPR32Opnd>, BGEZAL_FM_MM<0x13>;
|
|
|
|
|
def BLTZALS_MM : BranchCompareToZeroLinkMM<"bltzals", brtarget_mm,
|
|
|
|
|
GPR32Opnd>, BGEZAL_FM_MM<0x11>;
|
|
|
|
|
|
2013-12-20 00:25:00 +08:00
|
|
|
/// Control Instructions
|
|
|
|
|
def SYNC_MM : MMRel, SYNC_FT<"sync">, SYNC_FM_MM;
|
|
|
|
|
def BREAK_MM : MMRel, BRK_FT<"break">, BRK_FM_MM;
|
|
|
|
|
def SYSCALL_MM : MMRel, SYS_FT<"syscall">, SYS_FM_MM;
|
2014-03-20 18:41:37 +08:00
|
|
|
def WAIT_MM : WaitMM<"wait">, WAIT_FM_MM;
|
2013-12-20 00:25:00 +08:00
|
|
|
def ERET_MM : MMRel, ER_FT<"eret">, ER_FM_MM<0x3cd>;
|
|
|
|
|
def DERET_MM : MMRel, ER_FT<"deret">, ER_FM_MM<0x38d>;
|
2014-05-13 19:45:36 +08:00
|
|
|
def EI_MM : MMRel, DEI_FT<"ei", GPR32Opnd>, EI_FM_MM<0x15d>,
|
|
|
|
|
ISA_MIPS32R2;
|
|
|
|
|
def DI_MM : MMRel, DEI_FT<"di", GPR32Opnd>, EI_FM_MM<0x11d>,
|
|
|
|
|
ISA_MIPS32R2;
|
2013-12-20 00:25:00 +08:00
|
|
|
|
2013-11-07 22:35:24 +08:00
|
|
|
/// Trap Instructions
|
|
|
|
|
def TEQ_MM : MMRel, TEQ_FT<"teq", GPR32Opnd>, TEQ_FM_MM<0x0>;
|
|
|
|
|
def TGE_MM : MMRel, TEQ_FT<"tge", GPR32Opnd>, TEQ_FM_MM<0x08>;
|
|
|
|
|
def TGEU_MM : MMRel, TEQ_FT<"tgeu", GPR32Opnd>, TEQ_FM_MM<0x10>;
|
|
|
|
|
def TLT_MM : MMRel, TEQ_FT<"tlt", GPR32Opnd>, TEQ_FM_MM<0x20>;
|
|
|
|
|
def TLTU_MM : MMRel, TEQ_FT<"tltu", GPR32Opnd>, TEQ_FM_MM<0x28>;
|
|
|
|
|
def TNE_MM : MMRel, TEQ_FT<"tne", GPR32Opnd>, TEQ_FM_MM<0x30>;
|
2013-11-13 21:15:03 +08:00
|
|
|
|
|
|
|
|
def TEQI_MM : MMRel, TEQI_FT<"teqi", GPR32Opnd>, TEQI_FM_MM<0x0e>;
|
|
|
|
|
def TGEI_MM : MMRel, TEQI_FT<"tgei", GPR32Opnd>, TEQI_FM_MM<0x09>;
|
|
|
|
|
def TGEIU_MM : MMRel, TEQI_FT<"tgeiu", GPR32Opnd>, TEQI_FM_MM<0x0b>;
|
|
|
|
|
def TLTI_MM : MMRel, TEQI_FT<"tlti", GPR32Opnd>, TEQI_FM_MM<0x08>;
|
|
|
|
|
def TLTIU_MM : MMRel, TEQI_FT<"tltiu", GPR32Opnd>, TEQI_FM_MM<0x0a>;
|
|
|
|
|
def TNEI_MM : MMRel, TEQI_FT<"tnei", GPR32Opnd>, TEQI_FM_MM<0x0c>;
|
2013-12-20 00:12:56 +08:00
|
|
|
|
|
|
|
|
/// Load-linked, Store-conditional
|
|
|
|
|
def LL_MM : LLBaseMM<"ll", GPR32Opnd>, LL_FM_MM<0x3>;
|
|
|
|
|
def SC_MM : SCBaseMM<"sc", GPR32Opnd>, LL_FM_MM<0xb>;
|
2014-09-12 21:33:33 +08:00
|
|
|
|
|
|
|
|
def TLBP_MM : MMRel, TLB<"tlbp">, COP0_TLB_FM_MM<0x0d>;
|
|
|
|
|
def TLBR_MM : MMRel, TLB<"tlbr">, COP0_TLB_FM_MM<0x4d>;
|
|
|
|
|
def TLBWI_MM : MMRel, TLB<"tlbwi">, COP0_TLB_FM_MM<0x8d>;
|
|
|
|
|
def TLBWR_MM : MMRel, TLB<"tlbwr">, COP0_TLB_FM_MM<0xcd>;
|
2013-04-20 03:03:11 +08:00
|
|
|
}
|
2014-03-20 18:41:37 +08:00
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// MicroMips instruction aliases
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
let Predicates = [InMicroMips] in {
|
2014-05-09 00:12:31 +08:00
|
|
|
def : MipsInstAlias<"wait", (WAIT_MM 0x0), 1>;
|
2014-03-20 18:41:37 +08:00
|
|
|
}
|
