2012-02-28 15:46:26 +08:00
|
|
|
//===-- MipsCondMov.td - Describe Mips Conditional Moves --*- tablegen -*--===//
|
2012-02-17 09:23:50 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This is the Conditional Moves implementation.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-10-18 02:43:19 +08:00
|
|
|
// Conditional moves:
|
|
|
|
// These instructions are expanded in
|
|
|
|
// MipsISelLowering::EmitInstrWithCustomInserter if target does not have
|
|
|
|
// conditional move instructions.
|
|
|
|
// cond:int, data:int
|
2013-07-16 18:07:14 +08:00
|
|
|
class CMov_I_I_FT<string opstr, RegisterOperand CRC, RegisterOperand DRC,
|
2013-01-05 03:16:38 +08:00
|
|
|
InstrItinClass Itin> :
|
|
|
|
InstSE<(outs DRC:$rd), (ins DRC:$rs, CRC:$rt, DRC:$F),
|
2013-09-06 20:41:17 +08:00
|
|
|
!strconcat(opstr, "\t$rd, $rs, $rt"), [], Itin, FrmFR, opstr> {
|
2011-10-18 02:43:19 +08:00
|
|
|
let Constraints = "$F = $rd";
|
|
|
|
}
|
|
|
|
|
|
|
|
// cond:int, data:float
|
2013-07-16 18:07:14 +08:00
|
|
|
class CMov_I_F_FT<string opstr, RegisterOperand CRC, RegisterOperand DRC,
|
2012-12-13 09:41:15 +08:00
|
|
|
InstrItinClass Itin> :
|
|
|
|
InstSE<(outs DRC:$fd), (ins DRC:$fs, CRC:$rt, DRC:$F),
|
2013-12-25 18:09:27 +08:00
|
|
|
!strconcat(opstr, "\t$fd, $fs, $rt"), [], Itin, FrmFR, opstr> {
|
2012-12-13 09:41:15 +08:00
|
|
|
let Constraints = "$F = $fd";
|
|
|
|
}
|
|
|
|
|
2012-12-13 10:05:02 +08:00
|
|
|
// cond:float, data:int
|
2013-07-16 18:07:14 +08:00
|
|
|
class CMov_F_I_FT<string opstr, RegisterOperand RC, InstrItinClass Itin,
|
2012-12-13 09:41:15 +08:00
|
|
|
SDPatternOperator OpNode = null_frag> :
|
2013-07-30 18:12:14 +08:00
|
|
|
InstSE<(outs RC:$rd), (ins RC:$rs, FCCRegsOpnd:$fcc, RC:$F),
|
2013-07-27 04:51:20 +08:00
|
|
|
!strconcat(opstr, "\t$rd, $rs, $fcc"),
|
2013-07-30 18:12:14 +08:00
|
|
|
[(set RC:$rd, (OpNode RC:$rs, FCCRegsOpnd:$fcc, RC:$F))],
|
2013-09-06 20:41:17 +08:00
|
|
|
Itin, FrmFR, opstr> {
|
2012-12-13 09:41:15 +08:00
|
|
|
let Constraints = "$F = $rd";
|
|
|
|
}
|
|
|
|
|
2012-12-13 10:05:02 +08:00
|
|
|
// cond:float, data:float
|
2013-07-30 18:12:14 +08:00
|
|
|
class CMov_F_F_FT<string opstr, RegisterOperand RC, InstrItinClass Itin,
|
2012-12-13 09:41:15 +08:00
|
|
|
SDPatternOperator OpNode = null_frag> :
|
2013-07-30 18:12:14 +08:00
|
|
|
InstSE<(outs RC:$fd), (ins RC:$fs, FCCRegsOpnd:$fcc, RC:$F),
|
2013-07-27 04:51:20 +08:00
|
|
|
!strconcat(opstr, "\t$fd, $fs, $fcc"),
|
2013-07-30 18:12:14 +08:00
|
|
|
[(set RC:$fd, (OpNode RC:$fs, FCCRegsOpnd:$fcc, RC:$F))],
|
2013-12-25 18:09:27 +08:00
|
|
|
Itin, FrmFR, opstr> {
|
2012-12-13 09:41:15 +08:00
|
|
|
let Constraints = "$F = $fd";
|
|
|
|
}
|
|
|
|
|
2011-10-18 02:43:19 +08:00
|
|
|
// select patterns
|
2011-10-18 02:53:29 +08:00
|
|
|
multiclass MovzPats0<RegisterClass CRC, RegisterClass DRC,
|
|
|
|
Instruction MOVZInst, Instruction SLTOp,
|
|
|
|
Instruction SLTuOp, Instruction SLTiOp,
|
|
|
|
Instruction SLTiuOp> {
|
2012-06-15 05:03:23 +08:00
|
|
|
def : MipsPat<(select (i32 (setge CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTOp CRC:$lhs, CRC:$rhs), DRC:$F)>;
|
2013-03-02 05:22:21 +08:00
|
|
|
def : MipsPat<(select (i32 (setuge CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTuOp CRC:$lhs, CRC:$rhs), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setge CRC:$lhs, immSExt16:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTiOp CRC:$lhs, immSExt16:$rhs), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setuge CRC:$lh, immSExt16:$rh)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTiuOp CRC:$lh, immSExt16:$rh), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setle CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTOp CRC:$rhs, CRC:$lhs), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setule CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTuOp CRC:$rhs, CRC:$lhs), DRC:$F)>;
|
2013-03-02 05:52:08 +08:00
|
|
|
def : MipsPat<(select (i32 (setgt CRC:$lhs, immSExt16Plus1:$rhs)),
|
|
|
|
DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTiOp CRC:$lhs, (Plus1 imm:$rhs)), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setugt CRC:$lhs, immSExt16Plus1:$rhs)),
|
|
|
|
DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (SLTiuOp CRC:$lhs, (Plus1 imm:$rhs)),
|
|
|
|
DRC:$F)>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
multiclass MovzPats1<RegisterClass CRC, RegisterClass DRC,
|
|
|
|
Instruction MOVZInst, Instruction XOROp> {
|
2012-06-15 05:03:23 +08:00
|
|
|
def : MipsPat<(select (i32 (seteq CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, (XOROp CRC:$lhs, CRC:$rhs), DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (seteq CRC:$lhs, 0)), DRC:$T, DRC:$F),
|
|
|
|
(MOVZInst DRC:$T, CRC:$lhs, DRC:$F)>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
|
|
|
|
2012-05-09 10:29:29 +08:00
|
|
|
multiclass MovzPats2<RegisterClass CRC, RegisterClass DRC,
|
|
|
|
Instruction MOVZInst, Instruction XORiOp> {
|
2012-06-15 05:03:23 +08:00
|
|
|
def : MipsPat<
|
|
|
|
(select (i32 (seteq CRC:$lhs, immZExt16:$uimm16)), DRC:$T, DRC:$F),
|
2012-05-09 10:29:29 +08:00
|
|
|
(MOVZInst DRC:$T, (XORiOp CRC:$lhs, immZExt16:$uimm16), DRC:$F)>;
|
|
|
|
}
|
|
|
|
|
2011-10-18 02:53:29 +08:00
|
|
|
multiclass MovnPats<RegisterClass CRC, RegisterClass DRC, Instruction MOVNInst,
|
|
|
|
Instruction XOROp> {
|
2012-06-15 05:03:23 +08:00
|
|
|
def : MipsPat<(select (i32 (setne CRC:$lhs, CRC:$rhs)), DRC:$T, DRC:$F),
|
|
|
|
(MOVNInst DRC:$T, (XOROp CRC:$lhs, CRC:$rhs), DRC:$F)>;
|
|
|
|
def : MipsPat<(select CRC:$cond, DRC:$T, DRC:$F),
|
|
|
|
(MOVNInst DRC:$T, CRC:$cond, DRC:$F)>;
|
|
|
|
def : MipsPat<(select (i32 (setne CRC:$lhs, 0)),DRC:$T, DRC:$F),
|
|
|
|
(MOVNInst DRC:$T, CRC:$lhs, DRC:$F)>;
|
2011-10-18 02:43:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Instantiation of 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 MOVZ_I_I : MMRel, CMov_I_I_FT<"movz", GPR32Opnd, GPR32Opnd, II_MOVZ>,
|
2013-01-05 03:16:38 +08:00
|
|
|
ADD_FM<0, 0xa>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
2014-04-30 01:04:30 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
[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 MOVZ_I_I64 : CMov_I_I_FT<"movz", GPR32Opnd, GPR64Opnd, II_MOVZ>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xa>;
|
[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 MOVZ_I64_I : CMov_I_I_FT<"movz", GPR64Opnd, GPR32Opnd, II_MOVZ>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xa>;
|
[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 MOVZ_I64_I64 : CMov_I_I_FT<"movz", GPR64Opnd, GPR64Opnd, II_MOVZ>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xa>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
|
|
|
|
[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 MOVN_I_I : MMRel, CMov_I_I_FT<"movn", GPR32Opnd, GPR32Opnd, II_MOVN>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xb>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
2014-04-30 01:04:30 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
[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 MOVN_I_I64 : CMov_I_I_FT<"movn", GPR32Opnd, GPR64Opnd, II_MOVN>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xb>;
|
[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 MOVN_I64_I : CMov_I_I_FT<"movn", GPR64Opnd, GPR32Opnd, II_MOVN>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xb>;
|
[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 MOVN_I64_I64 : CMov_I_I_FT<"movn", GPR64Opnd, GPR64Opnd, II_MOVN>,
|
2013-09-07 07:28:24 +08:00
|
|
|
ADD_FM<0, 0xb>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
|
|
|
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVZ_I_S : MMRel, CMov_I_F_FT<"movz.s", GPR32Opnd, FGR32Opnd, II_MOVZ_S>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_I_F_FM<18, 16>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVZ_I64_S : CMov_I_F_FT<"movz.s", GPR64Opnd, FGR32Opnd, II_MOVZ_S>,
|
2014-05-07 18:27:09 +08:00
|
|
|
CMov_I_F_FM<18, 16>, AdditionalRequires<[HasMips64]>;
|
2011-10-18 02:53:29 +08:00
|
|
|
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVN_I_S : MMRel, CMov_I_F_FT<"movn.s", GPR32Opnd, FGR32Opnd, II_MOVN_S>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_I_F_FM<19, 16>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVN_I64_S : CMov_I_F_FT<"movn.s", GPR64Opnd, FGR32Opnd, II_MOVN_S>,
|
2014-05-07 18:27:09 +08:00
|
|
|
CMov_I_F_FM<19, 16>, AdditionalRequires<[IsGP64bit]>;
|
2011-10-18 02:43:19 +08:00
|
|
|
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [NotFP64bit] in {
|
2013-12-25 18:09:27 +08:00
|
|
|
def MOVZ_I_D32 : MMRel, CMov_I_F_FT<"movz.d", GPR32Opnd, AFGR64Opnd,
|
2014-01-21 19:28:03 +08:00
|
|
|
II_MOVZ_D>, CMov_I_F_FM<18, 17>;
|
2013-12-25 18:09:27 +08:00
|
|
|
def MOVN_I_D32 : MMRel, CMov_I_F_FT<"movn.d", GPR32Opnd, AFGR64Opnd,
|
2014-01-21 19:28:03 +08:00
|
|
|
II_MOVN_D>, CMov_I_F_FM<19, 17>;
|
2011-10-18 02:43:19 +08:00
|
|
|
}
|
2013-08-07 07:01:10 +08:00
|
|
|
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [IsFP64bit], DecoderNamespace = "Mips64" in {
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVZ_I_D64 : CMov_I_F_FT<"movz.d", GPR32Opnd, FGR64Opnd, II_MOVZ_D>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_I_F_FM<18, 17>;
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVN_I_D64 : CMov_I_F_FT<"movn.d", GPR32Opnd, FGR64Opnd, II_MOVN_D>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_I_F_FM<19, 17>;
|
2013-08-20 03:08:03 +08:00
|
|
|
let isCodeGenOnly = 1 in {
|
|
|
|
def MOVZ_I64_D64 : CMov_I_F_FT<"movz.d", GPR64Opnd, FGR64Opnd,
|
2014-01-21 19:28:03 +08:00
|
|
|
II_MOVZ_D>, CMov_I_F_FM<18, 17>;
|
2013-08-20 03:08:03 +08:00
|
|
|
def MOVN_I64_D64 : CMov_I_F_FT<"movn.d", GPR64Opnd, FGR64Opnd,
|
2014-01-21 19:28:03 +08:00
|
|
|
II_MOVN_D>, CMov_I_F_FM<19, 17>;
|
2013-08-20 03:08:03 +08:00
|
|
|
}
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
|
|
|
|
[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 MOVT_I : MMRel, CMov_F_I_FT<"movt", GPR32Opnd, II_MOVT, MipsCMovFP_T>,
|
2013-07-16 18:07:14 +08:00
|
|
|
CMov_F_I_FM<1>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in
|
[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 MOVT_I64 : CMov_F_I_FT<"movt", GPR64Opnd, II_MOVT, MipsCMovFP_T>,
|
2014-05-07 18:27:09 +08:00
|
|
|
CMov_F_I_FM<1>, AdditionalRequires<[IsGP64bit]>;
|
2011-10-18 02:43:19 +08:00
|
|
|
|
[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 MOVF_I : MMRel, CMov_F_I_FT<"movf", GPR32Opnd, II_MOVF, MipsCMovFP_F>,
|
2013-07-16 18:07:14 +08:00
|
|
|
CMov_F_I_FM<0>;
|
2013-08-07 07:01:10 +08:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in
|
[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 MOVF_I64 : CMov_F_I_FT<"movf", GPR64Opnd, II_MOVF, MipsCMovFP_F>,
|
2014-05-07 18:27:09 +08:00
|
|
|
CMov_F_I_FM<0>, AdditionalRequires<[IsGP64bit]>;
|
2011-10-18 02:43:19 +08:00
|
|
|
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVT_S : MMRel, CMov_F_F_FT<"movt.s", FGR32Opnd, II_MOVT_S, MipsCMovFP_T>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_F_F_FM<16, 1>;
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVF_S : MMRel, CMov_F_F_FT<"movf.s", FGR32Opnd, II_MOVF_S, MipsCMovFP_F>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_F_F_FM<16, 0>;
|
2011-10-18 02:53:29 +08:00
|
|
|
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [NotFP64bit] in {
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVT_D32 : MMRel, CMov_F_F_FT<"movt.d", AFGR64Opnd, II_MOVT_D,
|
2013-12-25 18:09:27 +08:00
|
|
|
MipsCMovFP_T>, CMov_F_F_FM<17, 1>;
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVF_D32 : MMRel, CMov_F_F_FT<"movf.d", AFGR64Opnd, II_MOVF_D,
|
2013-12-25 18:09:27 +08:00
|
|
|
MipsCMovFP_F>, CMov_F_F_FM<17, 0>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
2013-08-20 03:08:03 +08:00
|
|
|
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [IsFP64bit], DecoderNamespace = "Mips64" in {
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVT_D64 : CMov_F_F_FT<"movt.d", FGR64Opnd, II_MOVT_D, MipsCMovFP_T>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_F_F_FM<17, 1>;
|
2014-01-21 19:28:03 +08:00
|
|
|
def MOVF_D64 : CMov_F_F_FT<"movf.d", FGR64Opnd, II_MOVF_D, MipsCMovFP_F>,
|
2012-12-13 09:41:15 +08:00
|
|
|
CMov_F_F_FM<17, 0>;
|
2011-10-18 02:43:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Instantiation of conditional move patterns.
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR32, GPR32, MOVZ_I_I, SLT, SLTu, SLTi, SLTiu>;
|
|
|
|
defm : MovzPats1<GPR32, GPR32, MOVZ_I_I, XOR>;
|
|
|
|
defm : MovzPats2<GPR32, GPR32, MOVZ_I_I, XORi>;
|
2014-05-07 20:48:37 +08:00
|
|
|
let GPRPredicates = [IsGP64bit] in {
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR32, GPR64, MOVZ_I_I64, SLT, SLTu, SLTi, SLTiu>;
|
|
|
|
defm : MovzPats0<GPR64, GPR32, MOVZ_I_I, SLT64, SLTu64, SLTi64,
|
2011-10-18 02:53:29 +08:00
|
|
|
SLTiu64>;
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR64, GPR64, MOVZ_I_I64, SLT64, SLTu64, SLTi64,
|
2011-10-18 02:53:29 +08:00
|
|
|
SLTiu64>;
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats1<GPR32, GPR64, MOVZ_I_I64, XOR>;
|
|
|
|
defm : MovzPats1<GPR64, GPR32, MOVZ_I64_I, XOR64>;
|
|
|
|
defm : MovzPats1<GPR64, GPR64, MOVZ_I64_I64, XOR64>;
|
|
|
|
defm : MovzPats2<GPR32, GPR64, MOVZ_I_I64, XORi>;
|
|
|
|
defm : MovzPats2<GPR64, GPR32, MOVZ_I64_I, XORi64>;
|
|
|
|
defm : MovzPats2<GPR64, GPR64, MOVZ_I64_I64, XORi64>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
2011-10-18 02:43:19 +08:00
|
|
|
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovnPats<GPR32, GPR32, MOVN_I_I, XOR>;
|
2014-05-07 20:48:37 +08:00
|
|
|
let GPRPredicates = [IsGP64bit] in {
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovnPats<GPR32, GPR64, MOVN_I_I64, XOR>;
|
|
|
|
defm : MovnPats<GPR64, GPR32, MOVN_I64_I, XOR64>;
|
|
|
|
defm : MovnPats<GPR64, GPR64, MOVN_I64_I64, XOR64>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
2011-10-18 02:43:19 +08:00
|
|
|
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR32, FGR32, MOVZ_I_S, SLT, SLTu, SLTi, SLTiu>;
|
|
|
|
defm : MovzPats1<GPR32, FGR32, MOVZ_I_S, XOR>;
|
|
|
|
defm : MovnPats<GPR32, FGR32, MOVN_I_S, XOR>;
|
2014-05-07 20:48:37 +08:00
|
|
|
let GPRPredicates = [IsGP64bit] in {
|
|
|
|
defm : MovzPats0<GPR64, FGR32, MOVZ_I_S, SLT64, SLTu64, SLTi64, SLTiu64>;
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats1<GPR64, FGR32, MOVZ_I64_S, XOR64>;
|
|
|
|
defm : MovnPats<GPR64, FGR32, MOVN_I64_S, XOR64>;
|
2011-10-18 02:43:19 +08:00
|
|
|
}
|
|
|
|
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [NotFP64bit] in {
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR32, AFGR64, MOVZ_I_D32, SLT, SLTu, SLTi, SLTiu>;
|
|
|
|
defm : MovzPats1<GPR32, AFGR64, MOVZ_I_D32, XOR>;
|
|
|
|
defm : MovnPats<GPR32, AFGR64, MOVN_I_D32, XOR>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|
2014-05-07 20:48:37 +08:00
|
|
|
let FGRPredicates = [IsFP64bit] in {
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats0<GPR32, FGR64, MOVZ_I_D64, SLT, SLTu, SLTi, SLTiu>;
|
|
|
|
defm : MovzPats0<GPR64, FGR64, MOVZ_I_D64, SLT64, SLTu64, SLTi64,
|
2011-10-18 02:53:29 +08:00
|
|
|
SLTiu64>;
|
2013-08-07 07:08:38 +08:00
|
|
|
defm : MovzPats1<GPR32, FGR64, MOVZ_I_D64, XOR>;
|
|
|
|
defm : MovzPats1<GPR64, FGR64, MOVZ_I64_D64, XOR64>;
|
|
|
|
defm : MovnPats<GPR32, FGR64, MOVN_I_D64, XOR>;
|
|
|
|
defm : MovnPats<GPR64, FGR64, MOVN_I64_D64, XOR64>;
|
2011-10-18 02:53:29 +08:00
|
|
|
}
|