2011-09-24 01:40:18 +00:00
|
|
|
//===- Mips64InstrInfo.td - Mips64 Instruction Information -*- tablegen -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file describes Mips64 instructions.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2011-09-28 17:50:27 +00:00
|
|
|
|
2011-09-30 02:08:54 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Mips Operand, Complex Patterns and Transformations Definitions.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// Unsigned Operand
|
|
|
|
def uimm16_64 : Operand<i64> {
|
|
|
|
let PrintMethod = "printUnsignedImm";
|
|
|
|
}
|
|
|
|
|
2011-09-30 03:18:46 +00:00
|
|
|
// Transformation Function - get Imm - 32.
|
|
|
|
def Subtract32 : SDNodeXForm<imm, [{
|
2011-12-07 20:10:24 +00:00
|
|
|
return getImm(N, (unsigned)N->getZExtValue() - 32);
|
2011-09-30 03:18:46 +00:00
|
|
|
}]>;
|
|
|
|
|
2011-12-19 19:44:09 +00:00
|
|
|
// shamt must fit in 6 bits.
|
|
|
|
def immZExt6 : ImmLeaf<i32, [{return Imm == (Imm & 0x3f);}]>;
|
2011-09-30 03:18:46 +00:00
|
|
|
|
2011-09-29 20:37:56 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instructions specific format
|
|
|
|
//===----------------------------------------------------------------------===//
|
2013-08-20 21:08:22 +00:00
|
|
|
let usesCustomInserter = 1 in {
|
|
|
|
def ATOMIC_LOAD_ADD_I64 : Atomic2Ops<atomic_load_add_64, GPR64>;
|
|
|
|
def ATOMIC_LOAD_SUB_I64 : Atomic2Ops<atomic_load_sub_64, GPR64>;
|
|
|
|
def ATOMIC_LOAD_AND_I64 : Atomic2Ops<atomic_load_and_64, GPR64>;
|
|
|
|
def ATOMIC_LOAD_OR_I64 : Atomic2Ops<atomic_load_or_64, GPR64>;
|
|
|
|
def ATOMIC_LOAD_XOR_I64 : Atomic2Ops<atomic_load_xor_64, GPR64>;
|
|
|
|
def ATOMIC_LOAD_NAND_I64 : Atomic2Ops<atomic_load_nand_64, GPR64>;
|
|
|
|
def ATOMIC_SWAP_I64 : Atomic2Ops<atomic_swap_64, GPR64>;
|
|
|
|
def ATOMIC_CMP_SWAP_I64 : AtomicCmpSwap<atomic_cmp_swap_64, GPR64>;
|
2011-11-11 04:14:30 +00:00
|
|
|
}
|
|
|
|
|
2013-04-30 23:22:09 +00:00
|
|
|
/// Pseudo instructions for loading and storing accumulator registers.
|
2013-08-01 23:14:16 +00:00
|
|
|
let isPseudo = 1, isCodeGenOnly = 1 in {
|
2013-08-20 21:08:22 +00:00
|
|
|
def LOAD_ACC128 : Load<"", ACC128>;
|
|
|
|
def STORE_ACC128 : Store<"", ACC128>;
|
2013-03-30 00:54:52 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 20:37:56 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instruction definition
|
|
|
|
//===----------------------------------------------------------------------===//
|
2012-04-17 18:03:21 +00:00
|
|
|
let DecoderNamespace = "Mips64" in {
|
2011-09-30 02:08:54 +00:00
|
|
|
/// Arithmetic Instructions (ALU Immediate)
|
2013-08-06 23:08:38 +00:00
|
|
|
def DADDi : ArithLogicI<"daddi", simm16_64, GPR64Opnd>, ADDI_FM<0x18>;
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DADDiu : ArithLogicI<"daddiu", simm16_64, GPR64Opnd, II_DADDIU,
|
2013-07-31 00:55:34 +00:00
|
|
|
immSExt16, add>,
|
2012-12-20 03:40:03 +00:00
|
|
|
ADDI_FM<0x19>, IsAsCheapAsAMove;
|
2013-08-06 23:01:10 +00:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in {
|
2013-08-06 23:08:38 +00:00
|
|
|
def SLTi64 : SetCC_I<"slti", setlt, simm16_64, immSExt16, GPR64Opnd>,
|
2012-12-20 04:27:52 +00:00
|
|
|
SLTI_FM<0xa>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def SLTiu64 : SetCC_I<"sltiu", setult, simm16_64, immSExt16, GPR64Opnd>,
|
2012-12-20 04:27:52 +00:00
|
|
|
SLTI_FM<0xb>;
|
2014-01-16 15:57:05 +00:00
|
|
|
def ANDi64 : ArithLogicI<"andi", uimm16_64, GPR64Opnd, II_AND, immZExt16, and>,
|
2013-07-31 00:57:41 +00:00
|
|
|
ADDI_FM<0xc>;
|
2014-01-16 15:57:05 +00:00
|
|
|
def ORi64 : ArithLogicI<"ori", uimm16_64, GPR64Opnd, II_OR, immZExt16, or>,
|
2012-12-20 03:40:03 +00:00
|
|
|
ADDI_FM<0xd>;
|
2014-01-16 15:57:05 +00:00
|
|
|
def XORi64 : ArithLogicI<"xori", uimm16_64, GPR64Opnd, II_XOR, immZExt16, xor>,
|
2012-12-20 03:40:03 +00:00
|
|
|
ADDI_FM<0xe>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def LUi64 : LoadUpper<"lui", GPR64Opnd, uimm16_64>, LUI_FM;
|
2013-08-06 23:01:10 +00:00
|
|
|
}
|
2011-09-30 02:08:54 +00:00
|
|
|
|
2011-09-29 20:37:56 +00:00
|
|
|
/// Arithmetic Instructions (3-Operand, R-Type)
|
2013-08-06 23:08:38 +00:00
|
|
|
def DADD : ArithLogicR<"dadd", GPR64Opnd>, ADD_FM<0, 0x2c>;
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DADDu : ArithLogicR<"daddu", GPR64Opnd, 1, II_DADDU, add>,
|
2013-01-12 01:03:14 +00:00
|
|
|
ADD_FM<0, 0x2d>;
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DSUBu : ArithLogicR<"dsubu", GPR64Opnd, 0, II_DSUBU, sub>,
|
2013-01-12 01:03:14 +00:00
|
|
|
ADD_FM<0, 0x2f>;
|
2013-08-06 22:35:29 +00:00
|
|
|
|
|
|
|
let isCodeGenOnly = 1 in {
|
2013-08-06 23:08:38 +00:00
|
|
|
def SLT64 : SetCC_R<"slt", setlt, GPR64Opnd>, ADD_FM<0, 0x2a>;
|
|
|
|
def SLTu64 : SetCC_R<"sltu", setult, GPR64Opnd>, ADD_FM<0, 0x2b>;
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def AND64 : ArithLogicR<"and", GPR64Opnd, 1, II_AND, and>, ADD_FM<0, 0x24>;
|
|
|
|
def OR64 : ArithLogicR<"or", GPR64Opnd, 1, II_OR, or>, ADD_FM<0, 0x25>;
|
|
|
|
def XOR64 : ArithLogicR<"xor", GPR64Opnd, 1, II_XOR, xor>, ADD_FM<0, 0x26>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def NOR64 : LogicNOR<"nor", GPR64Opnd>, ADD_FM<0, 0x27>;
|
2013-08-06 22:35:29 +00:00
|
|
|
}
|
2011-09-30 03:18:46 +00: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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DSLL : shift_rotate_imm<"dsll", uimm6, GPR64Opnd, II_DSLL, shl, immZExt6>,
|
2013-01-04 19:25:46 +00:00
|
|
|
SRA_FM<0x38, 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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DSRL : shift_rotate_imm<"dsrl", uimm6, GPR64Opnd, II_DSRL, srl, immZExt6>,
|
2013-01-04 19:25:46 +00:00
|
|
|
SRA_FM<0x3a, 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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DSRA : shift_rotate_imm<"dsra", uimm6, GPR64Opnd, II_DSRA, sra, immZExt6>,
|
2013-01-04 19:25:46 +00:00
|
|
|
SRA_FM<0x3b, 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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DSLLV : shift_rotate_reg<"dsllv", GPR64Opnd, II_DSLLV, shl>,
|
|
|
|
SRLV_FM<0x14, 0>;
|
|
|
|
def DSRLV : shift_rotate_reg<"dsrlv", GPR64Opnd, II_DSRLV, srl>,
|
|
|
|
SRLV_FM<0x16, 0>;
|
|
|
|
def DSRAV : shift_rotate_reg<"dsrav", GPR64Opnd, II_DSRAV, sra>,
|
|
|
|
SRLV_FM<0x17, 0>;
|
|
|
|
def DSLL32 : shift_rotate_imm<"dsll32", uimm5, GPR64Opnd, II_DSLL32>,
|
|
|
|
SRA_FM<0x3c, 0>;
|
|
|
|
def DSRL32 : shift_rotate_imm<"dsrl32", uimm5, GPR64Opnd, II_DSRL32>,
|
|
|
|
SRA_FM<0x3e, 0>;
|
|
|
|
def DSRA32 : shift_rotate_imm<"dsra32", uimm5, GPR64Opnd, II_DSRA32>,
|
|
|
|
SRA_FM<0x3f, 0>;
|
2013-08-06 23:01:10 +00:00
|
|
|
|
2011-09-30 18:51:46 +00:00
|
|
|
// Rotate Instructions
|
2013-08-06 23:01:10 +00:00
|
|
|
let Predicates = [HasMips64r2, HasStdEnc] 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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DROTR : shift_rotate_imm<"drotr", uimm6, GPR64Opnd, II_DROTR, rotr,
|
|
|
|
immZExt6>, SRA_FM<0x3a, 1>;
|
|
|
|
def DROTRV : shift_rotate_reg<"drotrv", GPR64Opnd, II_DROTRV, rotr>,
|
2013-01-18 20:15:06 +00:00
|
|
|
SRLV_FM<0x16, 1>;
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
def DROTR32 : shift_rotate_imm<"drotr32", uimm5, GPR64Opnd, II_DROTR32>,
|
|
|
|
SRA_FM<0x3e, 1>;
|
2011-09-30 18:51:46 +00:00
|
|
|
}
|
|
|
|
|
2011-10-11 00:27:28 +00:00
|
|
|
/// Load and Store Instructions
|
2012-02-28 07:46:26 +00:00
|
|
|
/// aligned
|
2013-08-06 23:01:10 +00:00
|
|
|
let isCodeGenOnly = 1 in {
|
2013-08-20 21:08:22 +00:00
|
|
|
def LB64 : Load<"lb", GPR64Opnd, sextloadi8, IILoad>, LW_FM<0x20>;
|
|
|
|
def LBu64 : Load<"lbu", GPR64Opnd, zextloadi8, IILoad>, LW_FM<0x24>;
|
|
|
|
def LH64 : Load<"lh", GPR64Opnd, sextloadi16, IILoad>, LW_FM<0x21>;
|
|
|
|
def LHu64 : Load<"lhu", GPR64Opnd, zextloadi16, IILoad>, LW_FM<0x25>;
|
|
|
|
def LW64 : Load<"lw", GPR64Opnd, sextloadi32, IILoad>, LW_FM<0x23>;
|
|
|
|
def SB64 : Store<"sb", GPR64Opnd, truncstorei8, IIStore>, LW_FM<0x28>;
|
|
|
|
def SH64 : Store<"sh", GPR64Opnd, truncstorei16, IIStore>, LW_FM<0x29>;
|
|
|
|
def SW64 : Store<"sw", GPR64Opnd, truncstorei32, IIStore>, LW_FM<0x2b>;
|
2013-08-06 23:01:10 +00:00
|
|
|
}
|
|
|
|
|
2013-08-20 21:08:22 +00:00
|
|
|
def LWu : Load<"lwu", GPR64Opnd, zextloadi32, IILoad>, LW_FM<0x27>;
|
|
|
|
def LD : Load<"ld", GPR64Opnd, load, IILoad>, LW_FM<0x37>;
|
|
|
|
def SD : Store<"sd", GPR64Opnd, store, IIStore>, LW_FM<0x3f>;
|
2011-10-11 00:27:28 +00:00
|
|
|
|
2012-06-02 00:04:19 +00:00
|
|
|
/// load/store left/right
|
2013-08-06 23:01:10 +00:00
|
|
|
let isCodeGenOnly = 1 in {
|
2013-09-06 23:28:24 +00:00
|
|
|
def LWL64 : LoadLeftRight<"lwl", MipsLWL, GPR64Opnd, IILoad>, LW_FM<0x22>;
|
|
|
|
def LWR64 : LoadLeftRight<"lwr", MipsLWR, GPR64Opnd, IILoad>, LW_FM<0x26>;
|
|
|
|
def SWL64 : StoreLeftRight<"swl", MipsSWL, GPR64Opnd, IIStore>, LW_FM<0x2a>;
|
|
|
|
def SWR64 : StoreLeftRight<"swr", MipsSWR, GPR64Opnd, IIStore>, LW_FM<0x2e>;
|
2013-08-06 23:01:10 +00:00
|
|
|
}
|
2013-01-12 01:03:14 +00:00
|
|
|
|
2013-09-06 23:28:24 +00:00
|
|
|
def LDL : LoadLeftRight<"ldl", MipsLDL, GPR64Opnd, IILoad>, LW_FM<0x1a>;
|
|
|
|
def LDR : LoadLeftRight<"ldr", MipsLDR, GPR64Opnd, IILoad>, LW_FM<0x1b>;
|
|
|
|
def SDL : StoreLeftRight<"sdl", MipsSDL, GPR64Opnd, IIStore>, LW_FM<0x2c>;
|
|
|
|
def SDR : StoreLeftRight<"sdr", MipsSDR, GPR64Opnd, IIStore>, LW_FM<0x2d>;
|
2012-06-02 00:04:19 +00:00
|
|
|
|
2011-11-11 04:14:30 +00:00
|
|
|
/// Load-linked, Store-conditional
|
2013-08-20 21:08:22 +00:00
|
|
|
def LLD : LLBase<"lld", GPR64Opnd>, LW_FM<0x34>;
|
|
|
|
def SCD : SCBase<"scd", GPR64Opnd>, LW_FM<0x3c>;
|
2011-11-11 04:14:30 +00:00
|
|
|
|
2011-10-11 18:49:17 +00:00
|
|
|
/// Jump and Branch Instructions
|
2013-08-06 23:01:10 +00:00
|
|
|
let isCodeGenOnly = 1 in {
|
2013-10-29 16:38:59 +00:00
|
|
|
def JR64 : IndirectBranch<"jr", GPR64Opnd>, MTLO_FM<8>;
|
2013-11-04 14:53:22 +00:00
|
|
|
def BEQ64 : CBranch<"beq", brtarget, seteq, GPR64Opnd>, BEQ_FM<4>;
|
|
|
|
def BNE64 : CBranch<"bne", brtarget, setne, GPR64Opnd>, BEQ_FM<5>;
|
|
|
|
def BGEZ64 : CBranchZero<"bgez", brtarget, setge, GPR64Opnd>, BGEZ_FM<1, 1>;
|
|
|
|
def BGTZ64 : CBranchZero<"bgtz", brtarget, setgt, GPR64Opnd>, BGEZ_FM<7, 0>;
|
|
|
|
def BLEZ64 : CBranchZero<"blez", brtarget, setle, GPR64Opnd>, BGEZ_FM<6, 0>;
|
|
|
|
def BLTZ64 : CBranchZero<"bltz", brtarget, setlt, GPR64Opnd>, BGEZ_FM<1, 0>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def JALR64 : JumpLinkReg<"jalr", GPR64Opnd>, JALR_FM;
|
|
|
|
def JALR64Pseudo : JumpLinkRegPseudo<GPR64Opnd, JALR, RA, GPR32Opnd>;
|
2013-11-27 23:58:32 +00:00
|
|
|
def TAILCALL64_R : TailCallReg<GPR64Opnd, JR, GPR32Opnd>;
|
2013-08-06 23:01:10 +00:00
|
|
|
}
|
2012-01-04 03:02:47 +00:00
|
|
|
|
2011-10-03 20:01:11 +00:00
|
|
|
/// Multiply and Divide Instructions.
|
2014-01-17 14:32:41 +00:00
|
|
|
def DMULT : Mult<"dmult", II_DMULT, GPR64Opnd, [HI0_64, LO0_64]>,
|
2013-01-18 20:15:06 +00:00
|
|
|
MULT_FM<0, 0x1c>;
|
2014-01-17 14:32:41 +00:00
|
|
|
def DMULTu : Mult<"dmultu", II_DMULTU, GPR64Opnd, [HI0_64, LO0_64]>,
|
2013-01-18 20:15:06 +00:00
|
|
|
MULT_FM<0, 0x1d>;
|
2013-08-08 21:54:26 +00:00
|
|
|
def PseudoDMULT : MultDivPseudo<DMULT, ACC128, GPR64Opnd, MipsMult,
|
2014-01-17 14:32:41 +00:00
|
|
|
II_DMULT>;
|
2013-08-08 21:54:26 +00:00
|
|
|
def PseudoDMULTu : MultDivPseudo<DMULTu, ACC128, GPR64Opnd, MipsMultu,
|
2014-01-17 14:32:41 +00:00
|
|
|
II_DMULTU>;
|
2014-01-17 14:48:06 +00:00
|
|
|
def DSDIV : Div<"ddiv", II_DDIV, GPR64Opnd, [HI0_64, LO0_64]>,
|
|
|
|
MULT_FM<0, 0x1e>;
|
|
|
|
def DUDIV : Div<"ddivu", II_DDIVU, GPR64Opnd, [HI0_64, LO0_64]>,
|
|
|
|
MULT_FM<0, 0x1f>;
|
2013-08-08 21:54:26 +00:00
|
|
|
def PseudoDSDIV : MultDivPseudo<DSDIV, ACC128, GPR64Opnd, MipsDivRem,
|
2014-01-17 14:48:06 +00:00
|
|
|
II_DDIV, 0, 1, 1>;
|
2013-08-08 21:54:26 +00:00
|
|
|
def PseudoDUDIV : MultDivPseudo<DUDIV, ACC128, GPR64Opnd, MipsDivRemU,
|
2014-01-17 14:48:06 +00:00
|
|
|
II_DDIVU, 0, 1, 1>;
|
2011-10-03 20:01:11 +00:00
|
|
|
|
2013-08-06 23:01:10 +00:00
|
|
|
let isCodeGenOnly = 1 in {
|
2013-08-14 00:47:08 +00:00
|
|
|
def MTHI64 : MoveToLOHI<"mthi", GPR64Opnd, [HI0_64]>, MTLO_FM<0x11>;
|
|
|
|
def MTLO64 : MoveToLOHI<"mtlo", GPR64Opnd, [LO0_64]>, MTLO_FM<0x13>;
|
2013-10-07 18:49:46 +00:00
|
|
|
def MFHI64 : MoveFromLOHI<"mfhi", GPR64Opnd, AC0_64>, MFLO_FM<0x10>;
|
|
|
|
def MFLO64 : MoveFromLOHI<"mflo", GPR64Opnd, AC0_64>, MFLO_FM<0x12>;
|
2013-10-15 01:12:50 +00:00
|
|
|
def PseudoMFHI64 : PseudoMFLOHI<GPR64, ACC128, MipsMFHI>;
|
|
|
|
def PseudoMFLO64 : PseudoMFLOHI<GPR64, ACC128, MipsMFLO>;
|
2013-10-15 01:48:30 +00:00
|
|
|
def PseudoMTLOHI64 : PseudoMTLOHI<ACC128, GPR64>;
|
2011-10-03 19:28:44 +00:00
|
|
|
|
2012-01-24 21:41:09 +00:00
|
|
|
/// Sign Ext In Register Instructions.
|
2014-01-16 16:19:38 +00:00
|
|
|
def SEB64 : SignExtInReg<"seb", i8, GPR64Opnd, II_SEB>, SEB_FM<0x10, 0x20>;
|
|
|
|
def SEH64 : SignExtInReg<"seh", i16, GPR64Opnd, II_SEH>, SEB_FM<0x18, 0x20>;
|
2013-08-06 23:01:10 +00:00
|
|
|
}
|
2012-01-24 21:41:09 +00:00
|
|
|
|
2011-10-03 21:16:50 +00:00
|
|
|
/// Count Leading
|
2013-08-06 23:08:38 +00:00
|
|
|
def DCLZ : CountLeading0<"dclz", GPR64Opnd>, CLO_FM<0x24>;
|
|
|
|
def DCLO : CountLeading1<"dclo", GPR64Opnd>, CLO_FM<0x25>;
|
2011-10-03 21:16:50 +00:00
|
|
|
|
2011-12-20 23:56:43 +00:00
|
|
|
/// Double Word Swap Bytes/HalfWords
|
2013-08-06 23:08:38 +00:00
|
|
|
def DSBH : SubwordSwap<"dsbh", GPR64Opnd>, SEB_FM<2, 0x24>;
|
|
|
|
def DSHD : SubwordSwap<"dshd", GPR64Opnd>, SEB_FM<5, 0x24>;
|
2012-12-21 23:21:32 +00:00
|
|
|
|
2013-08-20 21:08:22 +00:00
|
|
|
def LEA_ADDiu64 : EffectiveAddress<"daddiu", GPR64Opnd>, LW_FM<0x19>;
|
2011-12-20 23:56:43 +00:00
|
|
|
|
2013-08-06 23:01:10 +00:00
|
|
|
let isCodeGenOnly = 1 in
|
2013-08-08 21:37:32 +00:00
|
|
|
def RDHWR64 : ReadHardware<GPR64Opnd, HWRegsOpnd>, RDHWR_FM;
|
2011-12-07 23:31:26 +00:00
|
|
|
|
2013-09-07 00:02:02 +00:00
|
|
|
def DEXT : ExtBase<"dext", GPR64Opnd, uimm6, MipsExt>, EXT_FM<3>;
|
|
|
|
def DEXTU : ExtBase<"dextu", GPR64Opnd, uimm6>, EXT_FM<2>;
|
|
|
|
def DEXTM : ExtBase<"dextm", GPR64Opnd, uimm5>, EXT_FM<1>;
|
|
|
|
|
|
|
|
def DINS : InsBase<"dins", GPR64Opnd, uimm6, MipsIns>, EXT_FM<7>;
|
|
|
|
def DINSU : InsBase<"dinsu", GPR64Opnd, uimm6>, EXT_FM<6>;
|
|
|
|
def DINSM : InsBase<"dinsm", GPR64Opnd, uimm5>, EXT_FM<5>;
|
2011-12-05 21:26:34 +00:00
|
|
|
|
2012-08-07 00:35:22 +00:00
|
|
|
let isCodeGenOnly = 1, rs = 0, shamt = 0 in {
|
2013-08-06 23:08:38 +00:00
|
|
|
def DSLL64_32 : FR<0x00, 0x3c, (outs GPR64:$rd), (ins GPR32:$rt),
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
"dsll\t$rd, $rt, 32", [], II_DSLL>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def SLL64_32 : FR<0x0, 0x00, (outs GPR64:$rd), (ins GPR32:$rt),
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
"sll\t$rd, $rt, 0", [], II_SLL>;
|
2013-08-06 23:08:38 +00:00
|
|
|
def SLL64_64 : FR<0x0, 0x00, (outs GPR64:$rd), (ins GPR64:$rt),
|
[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.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@199391 91177308-0d34-0410-b5e6-96231b3b80d8
2014-01-16 14:27:20 +00:00
|
|
|
"sll\t$rd, $rt, 0", [], II_SLL>;
|
2012-08-07 00:35:22 +00:00
|
|
|
}
|
2012-04-17 18:03:21 +00:00
|
|
|
}
|
2011-09-30 18:51:46 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Arbitrary patterns that map to one or more instructions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-11-14 19:06:14 +00:00
|
|
|
// extended loads
|
2013-08-20 21:08:22 +00:00
|
|
|
let Predicates = [HasStdEnc] in {
|
2012-06-14 21:03:23 +00:00
|
|
|
def : MipsPat<(i64 (extloadi1 addr:$src)), (LB64 addr:$src)>;
|
|
|
|
def : MipsPat<(i64 (extloadi8 addr:$src)), (LB64 addr:$src)>;
|
2012-09-15 01:52:08 +00:00
|
|
|
def : MipsPat<(i64 (extloadi16 addr:$src)), (LH64 addr:$src)>;
|
|
|
|
def : MipsPat<(i64 (extloadi32 addr:$src)), (LW64 addr:$src)>;
|
2011-11-14 19:06:14 +00:00
|
|
|
}
|
2011-10-11 00:55:05 +00:00
|
|
|
|
|
|
|
// hi/lo relocs
|
2012-06-14 21:03:23 +00:00
|
|
|
def : MipsPat<(MipsHi tglobaladdr:$in), (LUi64 tglobaladdr:$in)>;
|
|
|
|
def : MipsPat<(MipsHi tblockaddress:$in), (LUi64 tblockaddress:$in)>;
|
|
|
|
def : MipsPat<(MipsHi tjumptable:$in), (LUi64 tjumptable:$in)>;
|
|
|
|
def : MipsPat<(MipsHi tconstpool:$in), (LUi64 tconstpool:$in)>;
|
|
|
|
def : MipsPat<(MipsHi tglobaltlsaddr:$in), (LUi64 tglobaltlsaddr:$in)>;
|
2012-11-21 20:40:38 +00:00
|
|
|
def : MipsPat<(MipsHi texternalsym:$in), (LUi64 texternalsym:$in)>;
|
2012-06-14 21:03:23 +00:00
|
|
|
|
|
|
|
def : MipsPat<(MipsLo tglobaladdr:$in), (DADDiu ZERO_64, tglobaladdr:$in)>;
|
|
|
|
def : MipsPat<(MipsLo tblockaddress:$in), (DADDiu ZERO_64, tblockaddress:$in)>;
|
|
|
|
def : MipsPat<(MipsLo tjumptable:$in), (DADDiu ZERO_64, tjumptable:$in)>;
|
|
|
|
def : MipsPat<(MipsLo tconstpool:$in), (DADDiu ZERO_64, tconstpool:$in)>;
|
|
|
|
def : MipsPat<(MipsLo tglobaltlsaddr:$in),
|
|
|
|
(DADDiu ZERO_64, tglobaltlsaddr:$in)>;
|
2012-11-21 20:40:38 +00:00
|
|
|
def : MipsPat<(MipsLo texternalsym:$in), (DADDiu ZERO_64, texternalsym:$in)>;
|
2012-06-14 21:03:23 +00:00
|
|
|
|
2013-08-06 23:08:38 +00:00
|
|
|
def : MipsPat<(add GPR64:$hi, (MipsLo tglobaladdr:$lo)),
|
|
|
|
(DADDiu GPR64:$hi, tglobaladdr:$lo)>;
|
|
|
|
def : MipsPat<(add GPR64:$hi, (MipsLo tblockaddress:$lo)),
|
|
|
|
(DADDiu GPR64:$hi, tblockaddress:$lo)>;
|
|
|
|
def : MipsPat<(add GPR64:$hi, (MipsLo tjumptable:$lo)),
|
|
|
|
(DADDiu GPR64:$hi, tjumptable:$lo)>;
|
|
|
|
def : MipsPat<(add GPR64:$hi, (MipsLo tconstpool:$lo)),
|
|
|
|
(DADDiu GPR64:$hi, tconstpool:$lo)>;
|
|
|
|
def : MipsPat<(add GPR64:$hi, (MipsLo tglobaltlsaddr:$lo)),
|
|
|
|
(DADDiu GPR64:$hi, tglobaltlsaddr:$lo)>;
|
|
|
|
|
|
|
|
def : WrapperPat<tglobaladdr, DADDiu, GPR64>;
|
|
|
|
def : WrapperPat<tconstpool, DADDiu, GPR64>;
|
|
|
|
def : WrapperPat<texternalsym, DADDiu, GPR64>;
|
|
|
|
def : WrapperPat<tblockaddress, DADDiu, GPR64>;
|
|
|
|
def : WrapperPat<tjumptable, DADDiu, GPR64>;
|
|
|
|
def : WrapperPat<tglobaltlsaddr, DADDiu, GPR64>;
|
|
|
|
|
|
|
|
defm : BrcondPats<GPR64, BEQ64, BNE64, SLT64, SLTu64, SLTi64, SLTiu64,
|
2011-10-11 19:09:09 +00:00
|
|
|
ZERO_64>;
|
|
|
|
|
2013-05-21 17:13:47 +00:00
|
|
|
def : MipsPat<(brcond (i32 (setlt i64:$lhs, 1)), bb:$dst),
|
|
|
|
(BLEZ64 i64:$lhs, bb:$dst)>;
|
|
|
|
def : MipsPat<(brcond (i32 (setgt i64:$lhs, -1)), bb:$dst),
|
|
|
|
(BGEZ64 i64:$lhs, bb:$dst)>;
|
|
|
|
|
2011-10-11 18:53:46 +00:00
|
|
|
// setcc patterns
|
2013-08-06 23:08:38 +00:00
|
|
|
defm : SeteqPats<GPR64, SLTiu64, XOR64, SLTu64, ZERO_64>;
|
|
|
|
defm : SetlePats<GPR64, SLT64, SLTu64>;
|
|
|
|
defm : SetgtPats<GPR64, SLT64, SLTu64>;
|
|
|
|
defm : SetgePats<GPR64, SLT64, SLTu64>;
|
|
|
|
defm : SetgeImmPats<GPR64, SLTi64, SLTiu64>;
|
2011-11-07 18:57:41 +00:00
|
|
|
|
|
|
|
// truncate
|
2013-08-06 23:08:38 +00:00
|
|
|
def : MipsPat<(i32 (trunc GPR64:$src)),
|
|
|
|
(SLL (EXTRACT_SUBREG GPR64:$src, sub_32), 0)>,
|
2013-08-20 23:21:55 +00:00
|
|
|
Requires<[HasStdEnc]>;
|
2012-02-28 07:46:26 +00:00
|
|
|
|
2011-12-07 23:14:41 +00:00
|
|
|
// 32-to-64-bit extension
|
2013-08-06 23:08:38 +00:00
|
|
|
def : MipsPat<(i64 (anyext GPR32:$src)), (SLL64_32 GPR32:$src)>;
|
|
|
|
def : MipsPat<(i64 (zext GPR32:$src)), (DSRL (DSLL64_32 GPR32:$src), 32)>;
|
|
|
|
def : MipsPat<(i64 (sext GPR32:$src)), (SLL64_32 GPR32:$src)>;
|
2011-12-20 22:06:20 +00:00
|
|
|
|
2011-12-20 22:40:40 +00:00
|
|
|
// Sign extend in register
|
2013-08-06 23:08:38 +00:00
|
|
|
def : MipsPat<(i64 (sext_inreg GPR64:$src, i32)),
|
|
|
|
(SLL64_64 GPR64:$src)>;
|
2011-12-20 22:40:40 +00:00
|
|
|
|
2012-06-14 21:03:23 +00:00
|
|
|
// bswap MipsPattern
|
2013-08-06 23:08:38 +00:00
|
|
|
def : MipsPat<(bswap GPR64:$rt), (DSHD (DSBH GPR64:$rt))>;
|
2012-10-09 16:27:43 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Instruction aliases
|
|
|
|
//===----------------------------------------------------------------------===//
|
2013-02-05 08:32:10 +00:00
|
|
|
def : InstAlias<"move $dst, $src",
|
2013-08-06 23:08:38 +00:00
|
|
|
(DADDu GPR64Opnd:$dst, GPR64Opnd:$src, ZERO_64), 1>,
|
2013-01-18 20:15:06 +00:00
|
|
|
Requires<[HasMips64]>;
|
2013-01-12 01:03:14 +00:00
|
|
|
def : InstAlias<"daddu $rs, $rt, $imm",
|
2013-08-06 23:08:38 +00:00
|
|
|
(DADDiu GPR64Opnd:$rs, GPR64Opnd:$rt, simm16_64:$imm),
|
2013-08-06 22:35:29 +00:00
|
|
|
0>;
|
2013-01-12 01:03:14 +00:00
|
|
|
def : InstAlias<"dadd $rs, $rt, $imm",
|
2013-08-06 23:08:38 +00:00
|
|
|
(DADDi GPR64Opnd:$rs, GPR64Opnd:$rt, simm16_64:$imm),
|
2013-08-06 22:35:29 +00:00
|
|
|
0>;
|
2013-01-18 20:15:06 +00:00
|
|
|
|
2013-05-16 19:40:19 +00:00
|
|
|
/// Move between CPU and coprocessor registers
|
2013-08-28 00:42:50 +00:00
|
|
|
let DecoderNamespace = "Mips64", Predicates = [HasMips64] in {
|
|
|
|
def DMFC0 : MFC3OP<"dmfc0", GPR64Opnd>, MFC3OP_FM<0x10, 1>;
|
|
|
|
def DMTC0 : MFC3OP<"dmtc0", GPR64Opnd>, MFC3OP_FM<0x10, 5>;
|
|
|
|
def DMFC2 : MFC3OP<"dmfc2", GPR64Opnd>, MFC3OP_FM<0x12, 1>;
|
|
|
|
def DMTC2 : MFC3OP<"dmtc2", GPR64Opnd>, MFC3OP_FM<0x12, 5>;
|
2012-10-11 10:21:34 +00:00
|
|
|
}
|
2013-01-18 20:15:06 +00:00
|
|
|
|
2012-10-11 10:21:34 +00:00
|
|
|
// Two operand (implicit 0 selector) versions:
|
2013-08-28 00:42:50 +00:00
|
|
|
def : InstAlias<"dmfc0 $rt, $rd", (DMFC0 GPR64Opnd:$rt, GPR64Opnd:$rd, 0), 0>;
|
|
|
|
def : InstAlias<"dmtc0 $rt, $rd", (DMTC0 GPR64Opnd:$rt, GPR64Opnd:$rd, 0), 0>;
|
|
|
|
def : InstAlias<"dmfc2 $rt, $rd", (DMFC2 GPR64Opnd:$rt, GPR64Opnd:$rd, 0), 0>;
|
|
|
|
def : InstAlias<"dmtc2 $rt, $rd", (DMTC2 GPR64Opnd:$rt, GPR64Opnd:$rd, 0), 0>;
|
2012-10-11 10:21:34 +00:00
|
|
|
|