2012-02-18 12:03:15 +00:00
|
|
|
//===-- PPCRegisterInfo.td - The PowerPC Register File -----*- tablegen -*-===//
|
|
|
|
//
|
2004-06-21 16:55:25 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2012-02-18 12:03:15 +00:00
|
|
|
//
|
2004-06-21 16:55:25 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-05-26 17:27:12 +00:00
|
|
|
let Namespace = "PPC" in {
|
|
|
|
def sub_lt : SubRegIndex;
|
|
|
|
def sub_gt : SubRegIndex;
|
|
|
|
def sub_eq : SubRegIndex;
|
|
|
|
def sub_un : SubRegIndex;
|
|
|
|
def sub_32 : SubRegIndex;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-09-14 04:17:02 +00:00
|
|
|
class PPCReg<string n> : Register<n> {
|
2004-08-10 22:47:03 +00:00
|
|
|
let Namespace = "PPC";
|
2004-06-21 16:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// We identify all our registers with a 5-bit ID, for consistency's sake.
|
|
|
|
|
|
|
|
// GPR - One of the 32 32-bit general-purpose registers
|
2004-09-14 04:17:02 +00:00
|
|
|
class GPR<bits<5> num, string n> : PPCReg<n> {
|
2004-06-21 16:55:25 +00:00
|
|
|
field bits<5> Num = num;
|
|
|
|
}
|
|
|
|
|
2005-10-19 00:05:37 +00:00
|
|
|
// GP8 - One of the 32 64-bit general-purpose registers
|
2008-07-07 22:22:07 +00:00
|
|
|
class GP8<GPR SubReg, string n> : PPCReg<n> {
|
2007-05-08 17:03:51 +00:00
|
|
|
field bits<5> Num = SubReg.Num;
|
|
|
|
let SubRegs = [SubReg];
|
2010-05-26 17:27:12 +00:00
|
|
|
let SubRegIndices = [sub_32];
|
2005-10-19 00:17:55 +00:00
|
|
|
}
|
2005-10-19 00:05:37 +00:00
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// SPR - One of the 32-bit special-purpose registers
|
2005-12-01 04:48:26 +00:00
|
|
|
class SPR<bits<10> num, string n> : PPCReg<n> {
|
|
|
|
field bits<10> Num = num;
|
2004-06-21 16:55:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// FPR - One of the 32 64-bit floating-point registers
|
2004-09-14 04:17:02 +00:00
|
|
|
class FPR<bits<5> num, string n> : PPCReg<n> {
|
2004-06-21 16:55:25 +00:00
|
|
|
field bits<5> Num = num;
|
|
|
|
}
|
|
|
|
|
2005-11-23 05:29:52 +00:00
|
|
|
// VR - One of the 32 128-bit vector registers
|
|
|
|
class VR<bits<5> num, string n> : PPCReg<n> {
|
|
|
|
field bits<5> Num = num;
|
|
|
|
}
|
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// CR - One of the 8 4-bit condition registers
|
2009-07-03 06:47:55 +00:00
|
|
|
class CR<bits<3> num, string n, list<Register> subregs> : PPCReg<n> {
|
2007-05-01 05:57:02 +00:00
|
|
|
field bits<3> Num = num;
|
2009-07-03 06:47:55 +00:00
|
|
|
let SubRegs = subregs;
|
2007-05-01 05:57:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CRBIT - One of the 32 1-bit condition register fields
|
|
|
|
class CRBIT<bits<5> num, string n> : PPCReg<n> {
|
2004-06-21 16:55:25 +00:00
|
|
|
field bits<5> Num = num;
|
|
|
|
}
|
|
|
|
|
|
|
|
// General-purpose registers
|
2013-01-24 20:43:18 +00:00
|
|
|
foreach Index = 0-31 in {
|
|
|
|
def R#Index : GPR<Index, "r"#Index>, DwarfRegNum<[-2, Index]>;
|
|
|
|
}
|
2004-06-21 16:55:25 +00:00
|
|
|
|
2005-10-19 00:05:37 +00:00
|
|
|
// 64-bit General-purpose registers
|
2013-01-24 20:43:18 +00:00
|
|
|
foreach Index = 0-31 in {
|
|
|
|
def X#Index : GP8<!cast<GPR>("R"#Index), "r"#Index>,
|
|
|
|
DwarfRegNum<[Index, -2]>;
|
|
|
|
}
|
2005-10-19 00:05:37 +00:00
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// Floating-point registers
|
2013-01-25 14:49:10 +00:00
|
|
|
foreach Index = 0-31 in {
|
|
|
|
def F#Index : FPR<Index, "f"#Index>,
|
|
|
|
DwarfRegNum<[!add(Index, 32), !add(Index, 32)]>;
|
|
|
|
}
|
2004-09-14 04:17:02 +00:00
|
|
|
|
2005-11-26 22:39:34 +00:00
|
|
|
// Vector registers
|
2013-01-25 14:49:10 +00:00
|
|
|
foreach Index = 0-31 in {
|
|
|
|
def V#Index : VR<Index, "v"#Index>,
|
|
|
|
DwarfRegNum<[!add(Index, 77), !add(Index, 77)]>;
|
|
|
|
}
|
2004-06-21 16:55:25 +00:00
|
|
|
|
Prepare to make r0 an allocatable register on PPC
Currently the PPC r0 register is unconditionally reserved. There are two reasons
for this:
1. r0 is treated specially (as the constant 0) by certain instructions, and so
cannot be used with those instructions as a regular register.
2. r0 is used as a temporary register in the CR-register spilling process
(where, under some circumstances, we require two GPRs).
This change addresses the first reason by introducing a restricted register
class (without r0) for use by those instructions that treat r0 specially. These
register classes have a new pseudo-register, ZERO, which represents the r0-as-0
use. This has the side benefit of making the existing target code simpler (and
easier to understand), and will make it clear to the register allocator that
uses of r0 as 0 don't conflict will real uses of the r0 register.
Once the CR spilling code is improved, we'll be able to allocate r0.
Adding these extra register classes, for some reason unclear to me, causes
requests to the target to copy 32-bit registers to 64-bit registers. The
resulting code seems correct (and causes no test-suite failures), and the new
test case covers this new kind of asymmetric copy.
As r0 is still reserved, no functionality change intended.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@177423 91177308-0d34-0410-b5e6-96231b3b80d8
2013-03-19 18:51:05 +00:00
|
|
|
// The reprsentation of r0 when treated as the constant 0.
|
|
|
|
def ZERO : GPR<0, "r0">;
|
|
|
|
|
2013-03-21 19:03:19 +00:00
|
|
|
// Representations of the frame pointer used by ISD::FRAMEADDR.
|
|
|
|
def FP : GPR<0 /* arbitrary */, "**FRAME POINTER**">;
|
|
|
|
def FP8 : GP8<FP, "**FRAME POINTER**">;
|
|
|
|
|
2007-05-01 05:57:02 +00:00
|
|
|
// Condition register bits
|
2011-05-27 16:15:27 +00:00
|
|
|
def CR0LT : CRBIT< 0, "0">;
|
|
|
|
def CR0GT : CRBIT< 1, "1">;
|
|
|
|
def CR0EQ : CRBIT< 2, "2">;
|
|
|
|
def CR0UN : CRBIT< 3, "3">;
|
|
|
|
def CR1LT : CRBIT< 4, "4">;
|
|
|
|
def CR1GT : CRBIT< 5, "5">;
|
|
|
|
def CR1EQ : CRBIT< 6, "6">;
|
|
|
|
def CR1UN : CRBIT< 7, "7">;
|
|
|
|
def CR2LT : CRBIT< 8, "8">;
|
|
|
|
def CR2GT : CRBIT< 9, "9">;
|
|
|
|
def CR2EQ : CRBIT<10, "10">;
|
|
|
|
def CR2UN : CRBIT<11, "11">;
|
|
|
|
def CR3LT : CRBIT<12, "12">;
|
|
|
|
def CR3GT : CRBIT<13, "13">;
|
|
|
|
def CR3EQ : CRBIT<14, "14">;
|
|
|
|
def CR3UN : CRBIT<15, "15">;
|
|
|
|
def CR4LT : CRBIT<16, "16">;
|
|
|
|
def CR4GT : CRBIT<17, "17">;
|
|
|
|
def CR4EQ : CRBIT<18, "18">;
|
|
|
|
def CR4UN : CRBIT<19, "19">;
|
|
|
|
def CR5LT : CRBIT<20, "20">;
|
|
|
|
def CR5GT : CRBIT<21, "21">;
|
|
|
|
def CR5EQ : CRBIT<22, "22">;
|
|
|
|
def CR5UN : CRBIT<23, "23">;
|
|
|
|
def CR6LT : CRBIT<24, "24">;
|
|
|
|
def CR6GT : CRBIT<25, "25">;
|
|
|
|
def CR6EQ : CRBIT<26, "26">;
|
|
|
|
def CR6UN : CRBIT<27, "27">;
|
|
|
|
def CR7LT : CRBIT<28, "28">;
|
|
|
|
def CR7GT : CRBIT<29, "29">;
|
|
|
|
def CR7EQ : CRBIT<30, "30">;
|
|
|
|
def CR7UN : CRBIT<31, "31">;
|
2007-05-01 05:57:02 +00:00
|
|
|
|
2009-07-03 06:47:55 +00:00
|
|
|
// Condition registers
|
2010-05-26 17:27:12 +00:00
|
|
|
let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
|
2011-05-30 18:24:44 +00:00
|
|
|
def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68, 68]>;
|
|
|
|
def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69, 69]>;
|
|
|
|
def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70, 70]>;
|
|
|
|
def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71, 71]>;
|
|
|
|
def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72, 72]>;
|
|
|
|
def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73, 73]>;
|
|
|
|
def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74, 74]>;
|
|
|
|
def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75, 75]>;
|
2010-05-24 17:55:38 +00:00
|
|
|
}
|
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// Link register
|
2011-05-30 18:24:44 +00:00
|
|
|
def LR : SPR<8, "lr">, DwarfRegNum<[-2, 65]>;
|
2006-11-14 18:44:47 +00:00
|
|
|
//let Aliases = [LR] in
|
2011-05-30 18:24:44 +00:00
|
|
|
def LR8 : SPR<8, "lr">, DwarfRegNum<[65, -2]>;
|
2006-11-14 18:44:47 +00:00
|
|
|
|
2004-06-21 16:55:25 +00:00
|
|
|
// Count register
|
2011-05-30 18:24:44 +00:00
|
|
|
def CTR : SPR<9, "ctr">, DwarfRegNum<[-2, 66]>;
|
|
|
|
def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66, -2]>;
|
2006-11-14 18:44:47 +00:00
|
|
|
|
2005-11-23 05:29:52 +00:00
|
|
|
// VRsave register
|
2011-05-26 19:25:47 +00:00
|
|
|
def VRSAVE: SPR<256, "VRsave">, DwarfRegNum<[109]>;
|
2004-09-14 04:17:02 +00:00
|
|
|
|
2009-09-18 20:15:22 +00:00
|
|
|
// Carry bit. In the architecture this is really bit 0 of the XER register
|
|
|
|
// (which really is SPR register 1); this is the only bit interesting to a
|
|
|
|
// compiler.
|
2011-05-29 03:17:01 +00:00
|
|
|
def CARRY: SPR<1, "ca">;
|
2009-09-18 20:15:22 +00:00
|
|
|
|
2008-10-29 18:26:45 +00:00
|
|
|
// FP rounding mode: bits 30 and 31 of the FP status and control register
|
|
|
|
// This is not allocated as a normal register; it appears only in
|
|
|
|
// Uses and Defs. The ABI says it needs to be preserved by a function,
|
|
|
|
// but this is not achieved by saving and restoring it as with
|
|
|
|
// most registers, it has to be done in code; to make this work all the
|
|
|
|
// return and call instructions are described as Uses of RM, so instructions
|
|
|
|
// that do nothing but change RM will not get deleted.
|
|
|
|
// Also, in the architecture it is not really a SPR; 512 is arbitrary.
|
2011-05-29 03:17:01 +00:00
|
|
|
def RM: SPR<512, "**ROUNDING MODE**">;
|
2008-10-29 18:26:45 +00:00
|
|
|
|
2005-10-14 18:58:46 +00:00
|
|
|
/// Register classes
|
|
|
|
// Allocate volatiles first
|
|
|
|
// then nonvolatiles in reverse order since stmw/lmw save from rN to r31
|
2011-06-15 23:28:14 +00:00
|
|
|
def GPRC : RegisterClass<"PPC", [i32], 32, (add (sequence "R%u", 2, 12),
|
|
|
|
(sequence "R%u", 30, 13),
|
2013-03-21 19:03:19 +00:00
|
|
|
R31, R0, R1, LR, FP)>;
|
2011-06-09 16:56:59 +00:00
|
|
|
|
2011-06-15 23:28:14 +00:00
|
|
|
def G8RC : RegisterClass<"PPC", [i64], 64, (add (sequence "X%u", 2, 12),
|
|
|
|
(sequence "X%u", 30, 14),
|
2013-03-21 19:03:19 +00:00
|
|
|
X31, X13, X0, X1, LR8, FP8)>;
|
2005-10-18 00:28:58 +00:00
|
|
|
|
Prepare to make r0 an allocatable register on PPC
Currently the PPC r0 register is unconditionally reserved. There are two reasons
for this:
1. r0 is treated specially (as the constant 0) by certain instructions, and so
cannot be used with those instructions as a regular register.
2. r0 is used as a temporary register in the CR-register spilling process
(where, under some circumstances, we require two GPRs).
This change addresses the first reason by introducing a restricted register
class (without r0) for use by those instructions that treat r0 specially. These
register classes have a new pseudo-register, ZERO, which represents the r0-as-0
use. This has the side benefit of making the existing target code simpler (and
easier to understand), and will make it clear to the register allocator that
uses of r0 as 0 don't conflict will real uses of the r0 register.
Once the CR spilling code is improved, we'll be able to allocate r0.
Adding these extra register classes, for some reason unclear to me, causes
requests to the target to copy 32-bit registers to 64-bit registers. The
resulting code seems correct (and causes no test-suite failures), and the new
test case covers this new kind of asymmetric copy.
As r0 is still reserved, no functionality change intended.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@177423 91177308-0d34-0410-b5e6-96231b3b80d8
2013-03-19 18:51:05 +00:00
|
|
|
// For some instructions r0 is special (representing the value 0 instead of
|
|
|
|
// the value in the r0 register), and we use these register subclasses to
|
|
|
|
// prevent r0 from being allocated for use by those instructions.
|
|
|
|
def GPRC_NOR0 : RegisterClass<"PPC", [i32], 32, (add (sub GPRC, R0), ZERO)>;
|
|
|
|
def G8RC_NOX0 : RegisterClass<"PPC", [i64], 64, (add (sub G8RC, X0), ZERO)>;
|
|
|
|
|
2009-07-03 06:45:56 +00:00
|
|
|
// Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
|
|
|
|
// ABI the size of the Floating-point register save area is determined by the
|
|
|
|
// allocated non-volatile register with the lowest register number, as FP
|
|
|
|
// register N is spilled to offset 8 * (32 - N) below the back chain word of the
|
|
|
|
// previous stack frame. By allocating non-volatiles in reverse order we make
|
|
|
|
// sure that the Floating-point register save area is always as small as
|
|
|
|
// possible because there aren't any unused spill slots.
|
2011-06-15 23:28:14 +00:00
|
|
|
def F8RC : RegisterClass<"PPC", [f64], 64, (add (sequence "F%u", 0, 13),
|
|
|
|
(sequence "F%u", 31, 14))>;
|
|
|
|
def F4RC : RegisterClass<"PPC", [f32], 32, (add F8RC)>;
|
2005-10-14 18:58:46 +00:00
|
|
|
|
2006-03-25 07:36:56 +00:00
|
|
|
def VRRC : RegisterClass<"PPC", [v16i8,v8i16,v4i32,v4f32], 128,
|
2011-06-15 23:28:14 +00:00
|
|
|
(add V2, V3, V4, V5, V0, V1, V6, V7, V8, V9, V10, V11,
|
|
|
|
V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
|
|
|
|
V29, V28, V27, V26, V25, V24, V23, V22, V21, V20)>;
|
2005-10-14 18:58:46 +00:00
|
|
|
|
2008-03-10 14:12:10 +00:00
|
|
|
def CRBITRC : RegisterClass<"PPC", [i32], 32,
|
2011-06-15 23:28:14 +00:00
|
|
|
(add CR0LT, CR0GT, CR0EQ, CR0UN,
|
|
|
|
CR1LT, CR1GT, CR1EQ, CR1UN,
|
|
|
|
CR2LT, CR2GT, CR2EQ, CR2UN,
|
|
|
|
CR3LT, CR3GT, CR3EQ, CR3UN,
|
|
|
|
CR4LT, CR4GT, CR4EQ, CR4UN,
|
|
|
|
CR5LT, CR5GT, CR5EQ, CR5UN,
|
|
|
|
CR6LT, CR6GT, CR6EQ, CR6UN,
|
|
|
|
CR7LT, CR7GT, CR7EQ, CR7UN)>
|
2008-03-10 14:12:10 +00:00
|
|
|
{
|
|
|
|
let CopyCost = -1;
|
|
|
|
}
|
|
|
|
|
2011-06-15 23:28:14 +00:00
|
|
|
def CRRC : RegisterClass<"PPC", [i32], 32, (add CR0, CR1, CR5, CR6,
|
2012-05-04 03:30:34 +00:00
|
|
|
CR7, CR2, CR3, CR4)>;
|
2008-04-30 09:16:33 +00:00
|
|
|
|
2012-06-08 19:02:08 +00:00
|
|
|
// The CTR registers are not allocatable because they're used by the
|
|
|
|
// decrement-and-branch instructions, and thus need to stay live across
|
|
|
|
// multiple basic blocks.
|
|
|
|
def CTRRC : RegisterClass<"PPC", [i32], 32, (add CTR)> {
|
|
|
|
let isAllocatable = 0;
|
|
|
|
}
|
|
|
|
def CTRRC8 : RegisterClass<"PPC", [i64], 64, (add CTR8)> {
|
|
|
|
let isAllocatable = 0;
|
|
|
|
}
|
|
|
|
|
2011-06-15 23:28:14 +00:00
|
|
|
def VRSAVERC : RegisterClass<"PPC", [i32], 32, (add VRSAVE)>;
|
|
|
|
def CARRYRC : RegisterClass<"PPC", [i32], 32, (add CARRY)> {
|
2009-09-18 20:15:22 +00:00
|
|
|
let CopyCost = -1;
|
|
|
|
}
|