2012-02-28 15:46:26 +08:00
|
|
|
//===-- MipsSchedule.td - Mips Scheduling Definitions ------*- tablegen -*-===//
|
2007-08-18 09:46:44 +08:00
|
|
|
//
|
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-08-18 09:46:44 +08:00
|
|
|
//
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-18 09:46:44 +08:00
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-18 09:46:44 +08:00
|
|
|
// Functional units across Mips chips sets. Based on GCC/Mips backend files.
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-18 09:46:44 +08:00
|
|
|
def ALU : FuncUnit;
|
|
|
|
|
def IMULDIV : FuncUnit;
|
|
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-03-05 01:51:39 +08:00
|
|
|
// Instruction Itinerary classes used for Mips
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-18 09:46:44 +08:00
|
|
|
def IIAlu : InstrItinClass;
|
|
|
|
|
def IIStore : InstrItinClass;
|
|
|
|
|
def IIBranch : InstrItinClass;
|
|
|
|
|
def IIPseudo : InstrItinClass;
|
|
|
|
|
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_ABS : InstrItinClass;
|
[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 II_ADDI : InstrItinClass;
|
|
|
|
|
def II_ADDIU : InstrItinClass;
|
|
|
|
|
def II_ADDU : InstrItinClass;
|
2014-01-21 20:38:07 +08:00
|
|
|
def II_ADD_D : InstrItinClass;
|
|
|
|
|
def II_ADD_S : InstrItinClass;
|
[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 II_AND : InstrItinClass;
|
2014-01-16 23:57:05 +08:00
|
|
|
def II_ANDI : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_CEIL : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_CFC1 : InstrItinClass;
|
[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 II_CLO : InstrItinClass;
|
|
|
|
|
def II_CLZ : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_CTC1 : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_CVT : InstrItinClass;
|
2014-01-21 19:42:48 +08:00
|
|
|
def II_C_CC_D : InstrItinClass; // Any c.<cc>.d instruction
|
|
|
|
|
def II_C_CC_S : InstrItinClass; // Any c.<cc>.s instruction
|
[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 II_DADDIU : InstrItinClass;
|
|
|
|
|
def II_DADDU : InstrItinClass;
|
2014-01-17 22:48:06 +08:00
|
|
|
def II_DDIV : InstrItinClass;
|
|
|
|
|
def II_DDIVU : InstrItinClass;
|
|
|
|
|
def II_DIV : InstrItinClass;
|
|
|
|
|
def II_DIVU : InstrItinClass;
|
2014-01-21 21:22:08 +08:00
|
|
|
def II_DIV_D : InstrItinClass;
|
|
|
|
|
def II_DIV_S : InstrItinClass;
|
2014-01-21 23:03:52 +08:00
|
|
|
def II_DMFC1 : InstrItinClass;
|
|
|
|
|
def II_DMTC1 : InstrItinClass;
|
2014-01-17 22:32:41 +08:00
|
|
|
def II_DMULT : InstrItinClass;
|
|
|
|
|
def II_DMULTU : InstrItinClass;
|
[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 II_DROTR : InstrItinClass;
|
|
|
|
|
def II_DROTR32 : InstrItinClass;
|
|
|
|
|
def II_DROTRV : InstrItinClass;
|
|
|
|
|
def II_DSLL : InstrItinClass;
|
|
|
|
|
def II_DSLL32 : InstrItinClass;
|
|
|
|
|
def II_DSLLV : InstrItinClass;
|
|
|
|
|
def II_DSRA : InstrItinClass;
|
|
|
|
|
def II_DSRA32 : InstrItinClass;
|
|
|
|
|
def II_DSRAV : InstrItinClass;
|
|
|
|
|
def II_DSRL : InstrItinClass;
|
|
|
|
|
def II_DSRL32 : InstrItinClass;
|
|
|
|
|
def II_DSRLV : InstrItinClass;
|
|
|
|
|
def II_DSUBU : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_FLOOR : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_LB : InstrItinClass;
|
|
|
|
|
def II_LBU : InstrItinClass;
|
|
|
|
|
def II_LD : InstrItinClass;
|
2014-01-21 21:59:56 +08:00
|
|
|
def II_LDC1 : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_LDL : InstrItinClass;
|
|
|
|
|
def II_LDR : InstrItinClass;
|
2014-01-21 21:59:56 +08:00
|
|
|
def II_LDXC1 : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_LH : InstrItinClass;
|
|
|
|
|
def II_LHU : InstrItinClass;
|
[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 II_LUI : InstrItinClass;
|
2014-01-21 21:59:56 +08:00
|
|
|
def II_LUXC1 : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_LW : InstrItinClass;
|
|
|
|
|
def II_LWU : InstrItinClass;
|
2014-01-21 21:59:56 +08:00
|
|
|
def II_LWC1 : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_LWL : InstrItinClass;
|
|
|
|
|
def II_LWR : InstrItinClass;
|
2014-01-21 21:59:56 +08:00
|
|
|
def II_LWXC1 : InstrItinClass;
|
2014-01-17 22:32:41 +08:00
|
|
|
def II_MADD : InstrItinClass;
|
|
|
|
|
def II_MADDU : InstrItinClass;
|
2014-01-21 21:07:31 +08:00
|
|
|
def II_MADD_D : InstrItinClass;
|
2014-01-21 20:51:44 +08:00
|
|
|
def II_MADD_S : InstrItinClass;
|
2014-01-21 23:03:52 +08:00
|
|
|
def II_MFC1 : InstrItinClass;
|
|
|
|
|
def II_MFHC1 : InstrItinClass;
|
2014-01-17 22:17:34 +08:00
|
|
|
def II_MFHI_MFLO : InstrItinClass; // mfhi and mflo
|
[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 II_MOVF : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_MOVF_D : InstrItinClass;
|
|
|
|
|
def II_MOVF_S : InstrItinClass;
|
[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 II_MOVN : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_MOVN_D : InstrItinClass;
|
|
|
|
|
def II_MOVN_S : InstrItinClass;
|
[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 II_MOVT : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_MOVT_D : InstrItinClass;
|
|
|
|
|
def II_MOVT_S : InstrItinClass;
|
[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 II_MOVZ : InstrItinClass;
|
2014-01-21 19:28:03 +08:00
|
|
|
def II_MOVZ_D : InstrItinClass;
|
|
|
|
|
def II_MOVZ_S : InstrItinClass;
|
|
|
|
|
def II_MOV_D : InstrItinClass;
|
|
|
|
|
def II_MOV_S : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_MSUB : InstrItinClass;
|
|
|
|
|
def II_MSUBU : InstrItinClass;
|
2014-01-21 21:07:31 +08:00
|
|
|
def II_MSUB_D : InstrItinClass;
|
2014-01-21 20:51:44 +08:00
|
|
|
def II_MSUB_S : InstrItinClass;
|
2014-01-21 23:03:52 +08:00
|
|
|
def II_MTC1 : InstrItinClass;
|
|
|
|
|
def II_MTHC1 : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_MTHI_MTLO : InstrItinClass; // mthi and mtlo
|
2014-01-17 22:32:41 +08:00
|
|
|
def II_MUL : InstrItinClass;
|
|
|
|
|
def II_MULT : InstrItinClass;
|
|
|
|
|
def II_MULTU : InstrItinClass;
|
2014-01-21 21:07:31 +08:00
|
|
|
def II_MUL_D : InstrItinClass;
|
2014-01-21 20:51:44 +08:00
|
|
|
def II_MUL_S : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_NEG : InstrItinClass;
|
2014-01-21 21:07:31 +08:00
|
|
|
def II_NMADD_D : InstrItinClass;
|
2014-01-21 20:51:44 +08:00
|
|
|
def II_NMADD_S : InstrItinClass;
|
2014-01-21 21:07:31 +08:00
|
|
|
def II_NMSUB_D : InstrItinClass;
|
2014-01-21 20:51:44 +08:00
|
|
|
def II_NMSUB_S : InstrItinClass;
|
[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 II_NOR : InstrItinClass;
|
|
|
|
|
def II_OR : InstrItinClass;
|
|
|
|
|
def II_ORI : InstrItinClass;
|
2014-01-21 23:21:14 +08:00
|
|
|
def II_RESTORE : InstrItinClass;
|
[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 II_RDHWR : InstrItinClass;
|
|
|
|
|
def II_ROTR : InstrItinClass;
|
|
|
|
|
def II_ROTRV : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_ROUND : InstrItinClass;
|
2014-01-21 22:50:20 +08:00
|
|
|
def II_SDC1 : InstrItinClass;
|
|
|
|
|
def II_SDXC1 : InstrItinClass;
|
2014-01-17 00:19:38 +08:00
|
|
|
def II_SEB : InstrItinClass;
|
|
|
|
|
def II_SEH : InstrItinClass;
|
[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 II_SLL : InstrItinClass;
|
|
|
|
|
def II_SLLV : InstrItinClass;
|
2014-01-21 18:42:13 +08:00
|
|
|
def II_SLTI_SLTIU : InstrItinClass; // slti and sltiu
|
|
|
|
|
def II_SLT_SLTU : InstrItinClass; // slt and sltu
|
2014-01-21 21:36:45 +08:00
|
|
|
def II_SQRT_D : InstrItinClass;
|
|
|
|
|
def II_SQRT_S : InstrItinClass;
|
[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 II_SRA : InstrItinClass;
|
|
|
|
|
def II_SRAV : InstrItinClass;
|
|
|
|
|
def II_SRL : InstrItinClass;
|
|
|
|
|
def II_SRLV : InstrItinClass;
|
|
|
|
|
def II_SUBU : InstrItinClass;
|
2014-01-21 20:38:07 +08:00
|
|
|
def II_SUB_D : InstrItinClass;
|
|
|
|
|
def II_SUB_S : InstrItinClass;
|
2014-01-21 22:50:20 +08:00
|
|
|
def II_SUXC1 : InstrItinClass;
|
|
|
|
|
def II_SWC1 : InstrItinClass;
|
|
|
|
|
def II_SWXC1 : InstrItinClass;
|
2014-01-21 18:56:23 +08:00
|
|
|
def II_TRUNC : InstrItinClass;
|
[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 II_XOR : InstrItinClass;
|
2014-01-16 23:57:05 +08:00
|
|
|
def II_XORI : InstrItinClass;
|
[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
|
|
|
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-08-18 09:46:44 +08:00
|
|
|
// Mips Generic instruction itineraries.
|
2011-04-16 05:51:11 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-09-29 07:50:49 +08:00
|
|
|
def MipsGenericItineraries : ProcessorItineraries<[ALU, IMULDIV], [], [
|
2007-08-18 09:46:44 +08:00
|
|
|
InstrItinData<IIAlu , [InstrStage<1, [ALU]>]>,
|
[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
|
|
|
InstrItinData<II_ADDI , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ADDIU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ADDU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_AND , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SLL , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SRA , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SRL , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ROTR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SLLV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SRAV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SRLV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ROTRV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_CLO , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_CLZ , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DADDIU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DADDU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSLL , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSRL , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSRA , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSLLV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSRLV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSRAV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DSUBU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DROTR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DROTRV , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LUI , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVF , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVN , [InstrStage<1, [ALU]>]>,
|
2014-01-21 19:28:03 +08:00
|
|
|
InstrItinData<II_MOVN_S , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVN_D , [InstrStage<1, [ALU]>]>,
|
[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
|
|
|
InstrItinData<II_MOVT , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVZ , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NOR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_OR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_RDHWR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SUBU , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_XOR , [InstrStage<1, [ALU]>]>,
|
2014-01-16 23:57:05 +08:00
|
|
|
InstrItinData<II_ANDI , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ORI , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_XORI , [InstrStage<1, [ALU]>]>,
|
2014-01-21 23:21:14 +08:00
|
|
|
InstrItinData<II_LB , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LBU , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LH , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LHU , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LW , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LWL , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LWR , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LD , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LDL , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LDR , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_RESTORE , [InstrStage<3, [ALU]>]>,
|
2007-08-18 09:46:44 +08:00
|
|
|
InstrItinData<IIStore , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<IIBranch , [InstrStage<1, [ALU]>]>,
|
2014-01-17 22:32:41 +08:00
|
|
|
InstrItinData<II_DMULT , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_DMULTU , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MADD , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MADDU , [InstrStage<17, [IMULDIV]>]>,
|
2014-01-17 22:17:34 +08:00
|
|
|
InstrItinData<II_MFHI_MFLO , [InstrStage<1, [IMULDIV]>]>,
|
2014-01-17 22:32:41 +08:00
|
|
|
InstrItinData<II_MSUB , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MSUBU , [InstrStage<17, [IMULDIV]>]>,
|
2014-01-17 22:17:34 +08:00
|
|
|
InstrItinData<II_MTHI_MTLO , [InstrStage<1, [IMULDIV]>]>,
|
2014-01-17 22:32:41 +08:00
|
|
|
InstrItinData<II_MUL , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MULT , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MULTU , [InstrStage<17, [IMULDIV]>]>,
|
2014-01-17 22:48:06 +08:00
|
|
|
InstrItinData<II_MSUB , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_MSUBU , [InstrStage<17, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_DIV , [InstrStage<38, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_DIVU , [InstrStage<38, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_DDIV , [InstrStage<38, [IMULDIV]>]>,
|
|
|
|
|
InstrItinData<II_DDIVU , [InstrStage<38, [IMULDIV]>]>,
|
2014-01-21 18:56:23 +08:00
|
|
|
InstrItinData<II_CEIL , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_CVT , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ABS , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_FLOOR , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NEG , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ROUND , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_TRUNC , [InstrStage<1, [ALU]>]>,
|
2014-01-21 19:28:03 +08:00
|
|
|
InstrItinData<II_MOV_D , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOV_S , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_CFC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_CTC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVF_D , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVF_S , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVT_D , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVT_S , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVZ_D , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MOVZ_S , [InstrStage<2, [ALU]>]>,
|
2014-01-21 19:42:48 +08:00
|
|
|
InstrItinData<II_C_CC_S , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_C_CC_D , [InstrStage<3, [ALU]>]>,
|
2014-01-21 20:38:07 +08:00
|
|
|
InstrItinData<II_ADD_D , [InstrStage<4, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_ADD_S , [InstrStage<4, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SUB_D , [InstrStage<4, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SUB_S , [InstrStage<4, [ALU]>]>,
|
2014-01-21 20:51:44 +08:00
|
|
|
InstrItinData<II_MUL_S , [InstrStage<7, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MADD_S , [InstrStage<7, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MSUB_S , [InstrStage<7, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NMADD_S , [InstrStage<7, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NMSUB_S , [InstrStage<7, [ALU]>]>,
|
2014-01-21 21:07:31 +08:00
|
|
|
InstrItinData<II_MUL_D , [InstrStage<8, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MADD_D , [InstrStage<8, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MSUB_D , [InstrStage<8, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NMADD_D , [InstrStage<8, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_NMSUB_D , [InstrStage<8, [ALU]>]>,
|
2014-01-21 21:22:08 +08:00
|
|
|
InstrItinData<II_DIV_S , [InstrStage<23, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DIV_D , [InstrStage<36, [ALU]>]>,
|
2014-01-21 21:36:45 +08:00
|
|
|
InstrItinData<II_SQRT_S , [InstrStage<54, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SQRT_D , [InstrStage<12, [ALU]>]>,
|
2014-01-21 21:59:56 +08:00
|
|
|
InstrItinData<II_LDC1 , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LWC1 , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LDXC1 , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LWXC1 , [InstrStage<3, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_LUXC1 , [InstrStage<3, [ALU]>]>,
|
2014-01-21 22:50:20 +08:00
|
|
|
InstrItinData<II_SDC1 , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SWC1 , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SDXC1 , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SWXC1 , [InstrStage<1, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_SUXC1 , [InstrStage<1, [ALU]>]>,
|
2014-01-21 23:03:52 +08:00
|
|
|
InstrItinData<II_DMFC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_DMTC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MFC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MTC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MFHC1 , [InstrStage<2, [ALU]>]>,
|
|
|
|
|
InstrItinData<II_MTHC1 , [InstrStage<2, [ALU]>]>
|
2007-08-18 09:46:44 +08:00
|
|
|
]>;
|
