VERegisterInfo.td
4.74 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
//===-- VERegisterInfo.td - VE Register defs ---------------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// Declarations that describe the VE register file
//===----------------------------------------------------------------------===//
class VEReg<bits<7> enc, string n, list<Register> subregs = [],
list<string> altNames = [], list<Register> aliases = []>
: Register<n, altNames> {
let HWEncoding{15-7} = 0;
let HWEncoding{6-0} = enc;
let Namespace = "VE";
let SubRegs = subregs;
let Aliases = aliases;
}
class VEMiscReg<bits<6> enc, string n>: Register<n> {
let HWEncoding{15-6} = 0;
let HWEncoding{5-0} = enc;
let Namespace = "VE";
}
let Namespace = "VE" in {
def sub_i32 : SubRegIndex<32, 32>; // Low 32 bit (32..63)
def sub_f32 : SubRegIndex<32>; // High 32 bit (0..31)
def sub_even : SubRegIndex<64>; // High 64 bit (0..63)
def sub_odd : SubRegIndex<64, 64>; // Low 64 bit (64..127)
def AsmName : RegAltNameIndex;
}
//-----------------------------------------------------------------------------
// Miscellaneous Registers
//-----------------------------------------------------------------------------
def USRCC : VEMiscReg<0, "usrcc">; // User clock counter
def PSW : VEMiscReg<1, "psw">; // Program status word
def SAR : VEMiscReg<2, "sar">; // Store address register
def PMMR : VEMiscReg<7, "pmmr">; // Performance monitor mode register
// Performance monitor configuration registers
foreach I = 0-3 in
def PMCR#I : VEMiscReg<!add(8,I), "pmcr"#I>;
// Performance monitor counter
foreach I = 0-14 in
def PMC#I : VEMiscReg<!add(16,I), "pmc"#I>;
// Register classes.
def MISC : RegisterClass<"VE", [i64], 64,
(add USRCC, PSW, SAR, PMMR,
(sequence "PMCR%u", 0, 3),
(sequence "PMC%u", 0, 14))>;
//-----------------------------------------------------------------------------
// Instruction Counter Register
//-----------------------------------------------------------------------------
def IC : VEMiscReg<62, "ic">;
//-----------------------------------------------------------------------------
// Generic Registers
//-----------------------------------------------------------------------------
let RegAltNameIndices = [AsmName] in {
// Generic integer registers - 32 bits wide
foreach I = 0-63 in
def SW#I : VEReg<I, "sw"#I, [], ["s"#I]>, DwarfRegNum<[I]>;
// Generic floating point registers - 32 bits wide
// NOTE: Mark SF#I as alias of SW#I temporary to avoid register allocation
// problem.
foreach I = 0-63 in
def SF#I : VEReg<I, "sf"#I, [], ["s"#I], [!cast<VEReg>("SW"#I)]>,
DwarfRegNum<[I]>;
// Generic integer registers - 64 bits wide
let SubRegIndices = [sub_i32, sub_f32], CoveredBySubRegs = 1 in
foreach I = 0-63 in
def SX#I : VEReg<I, "s"#I, [!cast<VEReg>("SW"#I), !cast<VEReg>("SF"#I)],
["s"#I]>, DwarfRegNum<[I]>;
// Aliases of the S* registers used to hold 128-bit for values (long doubles).
// Following foreach represents something like:
// def Q0 : VEReg<0, "q0", [SX0, SX1], ["s0"]>;
// def Q1 : VEReg<2, "q2", [SX2, SX3], ["s2"]>;
// ...
let SubRegIndices = [sub_even, sub_odd], CoveredBySubRegs = 1 in
foreach I = 0-31 in
def Q#I : VEReg<!shl(I,1), "q"#I,
[!cast<VEReg>("SX"#!shl(I,1)),
!cast<VEReg>("SX"#!add(!shl(I,1),1))],
["s"#!shl(I,1)]>;
} // RegAltNameIndices = [AsmName]
// Register classes.
//
// The register order is defined in terms of the preferred
// allocation order.
def I32 : RegisterClass<"VE", [i32], 32,
(add (sequence "SW%u", 0, 7),
(sequence "SW%u", 34, 63),
(sequence "SW%u", 8, 33))>;
def I64 : RegisterClass<"VE", [i64, f64], 64,
(add (sequence "SX%u", 0, 7),
(sequence "SX%u", 34, 63),
(sequence "SX%u", 8, 33))>;
def F32 : RegisterClass<"VE", [f32], 32,
(add (sequence "SF%u", 0, 7),
(sequence "SF%u", 34, 63),
(sequence "SF%u", 8, 33))>;
def F128 : RegisterClass<"VE", [f128], 128,
(add (sequence "Q%u", 0, 3),
(sequence "Q%u", 17, 31),
(sequence "Q%u", 4, 16))>;