← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/PowerPC/PPCRegisterInfo.td

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/PowerPC/PPCRegisterInfo.td
 
1
//===- PPCRegisterInfo.td - The PowerPC Register File ------*- tablegen -*-===//
 
2
// 
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
// 
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
//
 
11
//===----------------------------------------------------------------------===//
 
12
 
 
13
let Namespace = "PPC" in {
 
14
def sub_lt : SubRegIndex;
 
15
def sub_gt : SubRegIndex;
 
16
def sub_eq : SubRegIndex;
 
17
def sub_un : SubRegIndex;
 
18
def sub_32 : SubRegIndex;
 
19
}
 
20
 
 
21
 
 
22
class PPCReg<string n> : Register<n> {
 
23
  let Namespace = "PPC";
 
24
}
 
25
 
 
26
// We identify all our registers with a 5-bit ID, for consistency's sake.
 
27
 
 
28
// GPR - One of the 32 32-bit general-purpose registers
 
29
class GPR<bits<5> num, string n> : PPCReg<n> {
 
30
  field bits<5> Num = num;
 
31
}
 
32
 
 
33
// GP8 - One of the 32 64-bit general-purpose registers
 
34
class GP8<GPR SubReg, string n> : PPCReg<n> {
 
35
  field bits<5> Num = SubReg.Num;
 
36
  let SubRegs = [SubReg];
 
37
  let SubRegIndices = [sub_32];
 
38
}
 
39
 
 
40
// SPR - One of the 32-bit special-purpose registers
 
41
class SPR<bits<10> num, string n> : PPCReg<n> {
 
42
  field bits<10> Num = num;
 
43
}
 
44
 
 
45
// FPR - One of the 32 64-bit floating-point registers
 
46
class FPR<bits<5> num, string n> : PPCReg<n> {
 
47
  field bits<5> Num = num;
 
48
}
 
49
 
 
50
// VR - One of the 32 128-bit vector registers
 
51
class VR<bits<5> num, string n> : PPCReg<n> {
 
52
  field bits<5> Num = num;
 
53
}
 
54
 
 
55
// CR - One of the 8 4-bit condition registers
 
56
class CR<bits<3> num, string n, list<Register> subregs> : PPCReg<n> {
 
57
  field bits<3> Num = num;
 
58
  let SubRegs = subregs;
 
59
}
 
60
 
 
61
// CRBIT - One of the 32 1-bit condition register fields
 
62
class CRBIT<bits<5> num, string n> : PPCReg<n> {
 
63
  field bits<5> Num = num;
 
64
}
 
65
 
 
66
 
 
67
// General-purpose registers
 
68
def R0  : GPR< 0,  "r0">, DwarfRegNum<[0]>;
 
69
def R1  : GPR< 1,  "r1">, DwarfRegNum<[1]>;
 
70
def R2  : GPR< 2,  "r2">, DwarfRegNum<[2]>;
 
71
def R3  : GPR< 3,  "r3">, DwarfRegNum<[3]>;
 
72
def R4  : GPR< 4,  "r4">, DwarfRegNum<[4]>;
 
73
def R5  : GPR< 5,  "r5">, DwarfRegNum<[5]>;
 
74
def R6  : GPR< 6,  "r6">, DwarfRegNum<[6]>;
 
75
def R7  : GPR< 7,  "r7">, DwarfRegNum<[7]>;
 
76
def R8  : GPR< 8,  "r8">, DwarfRegNum<[8]>;
 
77
def R9  : GPR< 9,  "r9">, DwarfRegNum<[9]>;
 
78
def R10 : GPR<10, "r10">, DwarfRegNum<[10]>;
 
79
def R11 : GPR<11, "r11">, DwarfRegNum<[11]>;
 
80
def R12 : GPR<12, "r12">, DwarfRegNum<[12]>;
 
81
def R13 : GPR<13, "r13">, DwarfRegNum<[13]>;
 
82
def R14 : GPR<14, "r14">, DwarfRegNum<[14]>;
 
83
def R15 : GPR<15, "r15">, DwarfRegNum<[15]>;
 
84
def R16 : GPR<16, "r16">, DwarfRegNum<[16]>;
 
85
def R17 : GPR<17, "r17">, DwarfRegNum<[17]>;
 
86
def R18 : GPR<18, "r18">, DwarfRegNum<[18]>;
 
87
def R19 : GPR<19, "r19">, DwarfRegNum<[19]>;
 
88
def R20 : GPR<20, "r20">, DwarfRegNum<[20]>;
 
89
def R21 : GPR<21, "r21">, DwarfRegNum<[21]>;
 
90
def R22 : GPR<22, "r22">, DwarfRegNum<[22]>;
 
91
def R23 : GPR<23, "r23">, DwarfRegNum<[23]>;
 
92
def R24 : GPR<24, "r24">, DwarfRegNum<[24]>;
 
93
def R25 : GPR<25, "r25">, DwarfRegNum<[25]>;
 
94
def R26 : GPR<26, "r26">, DwarfRegNum<[26]>;
 
95
def R27 : GPR<27, "r27">, DwarfRegNum<[27]>;
 
96
def R28 : GPR<28, "r28">, DwarfRegNum<[28]>;
 
97
def R29 : GPR<29, "r29">, DwarfRegNum<[29]>;
 
98
def R30 : GPR<30, "r30">, DwarfRegNum<[30]>;
 
99
def R31 : GPR<31, "r31">, DwarfRegNum<[31]>;
 
100
 
 
101
// 64-bit General-purpose registers
 
102
def X0  : GP8< R0,  "r0">, DwarfRegNum<[0]>;
 
103
def X1  : GP8< R1,  "r1">, DwarfRegNum<[1]>;
 
104
def X2  : GP8< R2,  "r2">, DwarfRegNum<[2]>;
 
105
def X3  : GP8< R3,  "r3">, DwarfRegNum<[3]>;
 
106
def X4  : GP8< R4,  "r4">, DwarfRegNum<[4]>;
 
107
def X5  : GP8< R5,  "r5">, DwarfRegNum<[5]>;
 
108
def X6  : GP8< R6,  "r6">, DwarfRegNum<[6]>;
 
109
def X7  : GP8< R7,  "r7">, DwarfRegNum<[7]>;
 
110
def X8  : GP8< R8,  "r8">, DwarfRegNum<[8]>;
 
111
def X9  : GP8< R9,  "r9">, DwarfRegNum<[9]>;
 
112
def X10 : GP8<R10, "r10">, DwarfRegNum<[10]>;
 
113
def X11 : GP8<R11, "r11">, DwarfRegNum<[11]>;
 
114
def X12 : GP8<R12, "r12">, DwarfRegNum<[12]>;
 
115
def X13 : GP8<R13, "r13">, DwarfRegNum<[13]>;
 
116
def X14 : GP8<R14, "r14">, DwarfRegNum<[14]>;
 
117
def X15 : GP8<R15, "r15">, DwarfRegNum<[15]>;
 
118
def X16 : GP8<R16, "r16">, DwarfRegNum<[16]>;
 
119
def X17 : GP8<R17, "r17">, DwarfRegNum<[17]>;
 
120
def X18 : GP8<R18, "r18">, DwarfRegNum<[18]>;
 
121
def X19 : GP8<R19, "r19">, DwarfRegNum<[19]>;
 
122
def X20 : GP8<R20, "r20">, DwarfRegNum<[20]>;
 
123
def X21 : GP8<R21, "r21">, DwarfRegNum<[21]>;
 
124
def X22 : GP8<R22, "r22">, DwarfRegNum<[22]>;
 
125
def X23 : GP8<R23, "r23">, DwarfRegNum<[23]>;
 
126
def X24 : GP8<R24, "r24">, DwarfRegNum<[24]>;
 
127
def X25 : GP8<R25, "r25">, DwarfRegNum<[25]>;
 
128
def X26 : GP8<R26, "r26">, DwarfRegNum<[26]>;
 
129
def X27 : GP8<R27, "r27">, DwarfRegNum<[27]>;
 
130
def X28 : GP8<R28, "r28">, DwarfRegNum<[28]>;
 
131
def X29 : GP8<R29, "r29">, DwarfRegNum<[29]>;
 
132
def X30 : GP8<R30, "r30">, DwarfRegNum<[30]>;
 
133
def X31 : GP8<R31, "r31">, DwarfRegNum<[31]>;
 
134
 
 
135
// Floating-point registers
 
136
def F0  : FPR< 0,  "f0">, DwarfRegNum<[32]>;
 
137
def F1  : FPR< 1,  "f1">, DwarfRegNum<[33]>;
 
138
def F2  : FPR< 2,  "f2">, DwarfRegNum<[34]>;
 
139
def F3  : FPR< 3,  "f3">, DwarfRegNum<[35]>;
 
140
def F4  : FPR< 4,  "f4">, DwarfRegNum<[36]>;
 
141
def F5  : FPR< 5,  "f5">, DwarfRegNum<[37]>;
 
142
def F6  : FPR< 6,  "f6">, DwarfRegNum<[38]>;
 
143
def F7  : FPR< 7,  "f7">, DwarfRegNum<[39]>;
 
144
def F8  : FPR< 8,  "f8">, DwarfRegNum<[40]>;
 
145
def F9  : FPR< 9,  "f9">, DwarfRegNum<[41]>;
 
146
def F10 : FPR<10, "f10">, DwarfRegNum<[42]>;
 
147
def F11 : FPR<11, "f11">, DwarfRegNum<[43]>;
 
148
def F12 : FPR<12, "f12">, DwarfRegNum<[44]>;
 
149
def F13 : FPR<13, "f13">, DwarfRegNum<[45]>;
 
150
def F14 : FPR<14, "f14">, DwarfRegNum<[46]>;
 
151
def F15 : FPR<15, "f15">, DwarfRegNum<[47]>;
 
152
def F16 : FPR<16, "f16">, DwarfRegNum<[48]>;
 
153
def F17 : FPR<17, "f17">, DwarfRegNum<[49]>;
 
154
def F18 : FPR<18, "f18">, DwarfRegNum<[50]>;
 
155
def F19 : FPR<19, "f19">, DwarfRegNum<[51]>;
 
156
def F20 : FPR<20, "f20">, DwarfRegNum<[52]>;
 
157
def F21 : FPR<21, "f21">, DwarfRegNum<[53]>;
 
158
def F22 : FPR<22, "f22">, DwarfRegNum<[54]>;
 
159
def F23 : FPR<23, "f23">, DwarfRegNum<[55]>;
 
160
def F24 : FPR<24, "f24">, DwarfRegNum<[56]>;
 
161
def F25 : FPR<25, "f25">, DwarfRegNum<[57]>;
 
162
def F26 : FPR<26, "f26">, DwarfRegNum<[58]>;
 
163
def F27 : FPR<27, "f27">, DwarfRegNum<[59]>;
 
164
def F28 : FPR<28, "f28">, DwarfRegNum<[60]>;
 
165
def F29 : FPR<29, "f29">, DwarfRegNum<[61]>;
 
166
def F30 : FPR<30, "f30">, DwarfRegNum<[62]>;
 
167
def F31 : FPR<31, "f31">, DwarfRegNum<[63]>;
 
168
 
 
169
// Vector registers
 
170
def V0  : VR< 0,  "v0">, DwarfRegNum<[77]>;
 
171
def V1  : VR< 1,  "v1">, DwarfRegNum<[78]>;
 
172
def V2  : VR< 2,  "v2">, DwarfRegNum<[79]>;
 
173
def V3  : VR< 3,  "v3">, DwarfRegNum<[80]>;
 
174
def V4  : VR< 4,  "v4">, DwarfRegNum<[81]>;
 
175
def V5  : VR< 5,  "v5">, DwarfRegNum<[82]>;
 
176
def V6  : VR< 6,  "v6">, DwarfRegNum<[83]>;
 
177
def V7  : VR< 7,  "v7">, DwarfRegNum<[84]>;
 
178
def V8  : VR< 8,  "v8">, DwarfRegNum<[85]>;
 
179
def V9  : VR< 9,  "v9">, DwarfRegNum<[86]>;
 
180
def V10 : VR<10, "v10">, DwarfRegNum<[87]>;
 
181
def V11 : VR<11, "v11">, DwarfRegNum<[88]>;
 
182
def V12 : VR<12, "v12">, DwarfRegNum<[89]>;
 
183
def V13 : VR<13, "v13">, DwarfRegNum<[90]>;
 
184
def V14 : VR<14, "v14">, DwarfRegNum<[91]>;
 
185
def V15 : VR<15, "v15">, DwarfRegNum<[92]>;
 
186
def V16 : VR<16, "v16">, DwarfRegNum<[93]>;
 
187
def V17 : VR<17, "v17">, DwarfRegNum<[94]>;
 
188
def V18 : VR<18, "v18">, DwarfRegNum<[95]>;
 
189
def V19 : VR<19, "v19">, DwarfRegNum<[96]>;
 
190
def V20 : VR<20, "v20">, DwarfRegNum<[97]>;
 
191
def V21 : VR<21, "v21">, DwarfRegNum<[98]>;
 
192
def V22 : VR<22, "v22">, DwarfRegNum<[99]>;
 
193
def V23 : VR<23, "v23">, DwarfRegNum<[100]>;
 
194
def V24 : VR<24, "v24">, DwarfRegNum<[101]>;
 
195
def V25 : VR<25, "v25">, DwarfRegNum<[102]>;
 
196
def V26 : VR<26, "v26">, DwarfRegNum<[103]>;
 
197
def V27 : VR<27, "v27">, DwarfRegNum<[104]>;
 
198
def V28 : VR<28, "v28">, DwarfRegNum<[105]>;
 
199
def V29 : VR<29, "v29">, DwarfRegNum<[106]>;
 
200
def V30 : VR<30, "v30">, DwarfRegNum<[107]>;
 
201
def V31 : VR<31, "v31">, DwarfRegNum<[108]>;
 
202
 
 
203
// Condition register bits
 
204
def CR0LT : CRBIT< 0, "0">, DwarfRegNum<[0]>;
 
205
def CR0GT : CRBIT< 1, "1">, DwarfRegNum<[0]>;
 
206
def CR0EQ : CRBIT< 2, "2">, DwarfRegNum<[0]>;
 
207
def CR0UN : CRBIT< 3, "3">, DwarfRegNum<[0]>;
 
208
def CR1LT : CRBIT< 4, "4">, DwarfRegNum<[0]>;
 
209
def CR1GT : CRBIT< 5, "5">, DwarfRegNum<[0]>;
 
210
def CR1EQ : CRBIT< 6, "6">, DwarfRegNum<[0]>;
 
211
def CR1UN : CRBIT< 7, "7">, DwarfRegNum<[0]>;
 
212
def CR2LT : CRBIT< 8, "8">, DwarfRegNum<[0]>;
 
213
def CR2GT : CRBIT< 9, "9">, DwarfRegNum<[0]>;
 
214
def CR2EQ : CRBIT<10, "10">, DwarfRegNum<[0]>;
 
215
def CR2UN : CRBIT<11, "11">, DwarfRegNum<[0]>;
 
216
def CR3LT : CRBIT<12, "12">, DwarfRegNum<[0]>;
 
217
def CR3GT : CRBIT<13, "13">, DwarfRegNum<[0]>;
 
218
def CR3EQ : CRBIT<14, "14">, DwarfRegNum<[0]>;
 
219
def CR3UN : CRBIT<15, "15">, DwarfRegNum<[0]>;
 
220
def CR4LT : CRBIT<16, "16">, DwarfRegNum<[0]>;
 
221
def CR4GT : CRBIT<17, "17">, DwarfRegNum<[0]>;
 
222
def CR4EQ : CRBIT<18, "18">, DwarfRegNum<[0]>;
 
223
def CR4UN : CRBIT<19, "19">, DwarfRegNum<[0]>;
 
224
def CR5LT : CRBIT<20, "20">, DwarfRegNum<[0]>;
 
225
def CR5GT : CRBIT<21, "21">, DwarfRegNum<[0]>;
 
226
def CR5EQ : CRBIT<22, "22">, DwarfRegNum<[0]>;
 
227
def CR5UN : CRBIT<23, "23">, DwarfRegNum<[0]>;
 
228
def CR6LT : CRBIT<24, "24">, DwarfRegNum<[0]>;
 
229
def CR6GT : CRBIT<25, "25">, DwarfRegNum<[0]>;
 
230
def CR6EQ : CRBIT<26, "26">, DwarfRegNum<[0]>;
 
231
def CR6UN : CRBIT<27, "27">, DwarfRegNum<[0]>;
 
232
def CR7LT : CRBIT<28, "28">, DwarfRegNum<[0]>;
 
233
def CR7GT : CRBIT<29, "29">, DwarfRegNum<[0]>;
 
234
def CR7EQ : CRBIT<30, "30">, DwarfRegNum<[0]>;
 
235
def CR7UN : CRBIT<31, "31">, DwarfRegNum<[0]>;
 
236
 
 
237
// Condition registers
 
238
let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
 
239
def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68]>;
 
240
def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69]>;
 
241
def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70]>;
 
242
def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71]>;
 
243
def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72]>;
 
244
def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73]>;
 
245
def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74]>;
 
246
def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75]>;
 
247
}
 
248
 
 
249
// Link register
 
250
def LR  : SPR<8, "lr">, DwarfRegNum<[65]>;
 
251
//let Aliases = [LR] in
 
252
def LR8 : SPR<8, "lr">, DwarfRegNum<[65]>;
 
253
 
 
254
// Count register
 
255
def CTR  : SPR<9, "ctr">, DwarfRegNum<[66]>;
 
256
def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66]>;
 
257
 
 
258
// VRsave register
 
259
def VRSAVE: SPR<256, "VRsave">, DwarfRegNum<[107]>;
 
260
 
 
261
// Carry bit.  In the architecture this is really bit 0 of the XER register
 
262
// (which really is SPR register 1);  this is the only bit interesting to a
 
263
// compiler.
 
264
def CARRY: SPR<1, "ca">, DwarfRegNum<[0]>;
 
265
 
 
266
// FP rounding mode:  bits 30 and 31 of the FP status and control register
 
267
// This is not allocated as a normal register; it appears only in
 
268
// Uses and Defs.  The ABI says it needs to be preserved by a function,
 
269
// but this is not achieved by saving and restoring it as with
 
270
// most registers, it has to be done in code; to make this work all the
 
271
// return and call instructions are described as Uses of RM, so instructions
 
272
// that do nothing but change RM will not get deleted.
 
273
// Also, in the architecture it is not really a SPR; 512 is arbitrary.
 
274
def RM: SPR<512, "**ROUNDING MODE**">, DwarfRegNum<[0]>;
 
275
 
 
276
/// Register classes
 
277
// Allocate volatiles first
 
278
// then nonvolatiles in reverse order since stmw/lmw save from rN to r31
 
279
def GPRC : RegisterClass<"PPC", [i32], 32,
 
280
     [R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12,
 
281
      R30, R29, R28, R27, R26, R25, R24, R23, R22, R21, R20, R19, R18, R17,
 
282
      R16, R15, R14, R13, R31, R0, R1, LR]>
 
283
{
 
284
  let MethodProtos = [{
 
285
    iterator allocation_order_begin(const MachineFunction &MF) const;
 
286
    iterator allocation_order_end(const MachineFunction &MF) const;
 
287
  }];
 
288
  let MethodBodies = [{
 
289
    GPRCClass::iterator
 
290
    GPRCClass::allocation_order_begin(const MachineFunction &MF) const {
 
291
      // 32-bit SVR4 ABI: r2 is reserved for the OS.
 
292
      // 64-bit SVR4 ABI: r2 is reserved for the TOC pointer.
 
293
      // Darwin: R2 is reserved for CR save/restore sequence.
 
294
      return begin()+1;
 
295
    }
 
296
    GPRCClass::iterator
 
297
    GPRCClass::allocation_order_end(const MachineFunction &MF) const {
 
298
      // On PPC64, r13 is the thread pointer.  Never allocate this register.
 
299
      // Note that this is overconservative, as it also prevents allocation of
 
300
      // R31 when the FP is not needed.
 
301
      // When using the 32-bit SVR4 ABI, r13 is reserved for the Small Data Area
 
302
      // pointer.
 
303
      const PPCSubtarget &Subtarget
 
304
        = MF.getTarget().getSubtarget<PPCSubtarget>();
 
305
         
 
306
      if (Subtarget.isPPC64() || Subtarget.isSVR4ABI())
 
307
        return end()-5;  // don't allocate R13, R31, R0, R1, LR
 
308
        
 
309
      if (needsFP(MF))
 
310
        return end()-4;  // don't allocate R31, R0, R1, LR
 
311
      else
 
312
        return end()-3;  // don't allocate R0, R1, LR
 
313
    }
 
314
  }];
 
315
}
 
316
def G8RC : RegisterClass<"PPC", [i64], 64,
 
317
     [X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12,
 
318
      X30, X29, X28, X27, X26, X25, X24, X23, X22, X21, X20, X19, X18, X17,
 
319
      X16, X15, X14, X31, X13, X0, X1, LR8]>
 
320
{
 
321
  let MethodProtos = [{
 
322
    iterator allocation_order_begin(const MachineFunction &MF) const;
 
323
    iterator allocation_order_end(const MachineFunction &MF) const;
 
324
  }];
 
325
  let MethodBodies = [{
 
326
    G8RCClass::iterator
 
327
    G8RCClass::allocation_order_begin(const MachineFunction &MF) const {
 
328
      // 64-bit SVR4 ABI: r2 is reserved for the TOC pointer.
 
329
      // Darwin: r2 is reserved for CR save/restore sequence.
 
330
      return begin()+1;
 
331
    }
 
332
    G8RCClass::iterator
 
333
    G8RCClass::allocation_order_end(const MachineFunction &MF) const {
 
334
      if (needsFP(MF))
 
335
        return end()-5;
 
336
      else
 
337
        return end()-4;
 
338
    }
 
339
  }];
 
340
}
 
341
 
 
342
// Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
 
343
// ABI the size of the Floating-point register save area is determined by the
 
344
// allocated non-volatile register with the lowest register number, as FP
 
345
// register N is spilled to offset 8 * (32 - N) below the back chain word of the
 
346
// previous stack frame. By allocating non-volatiles in reverse order we make
 
347
// sure that the Floating-point register save area is always as small as
 
348
// possible because there aren't any unused spill slots.
 
349
def F8RC : RegisterClass<"PPC", [f64], 64, [F0, F1, F2, F3, F4, F5, F6, F7,
 
350
  F8, F9, F10, F11, F12, F13, F31, F30, F29, F28, F27, F26, F25, F24, F23,
 
351
  F22, F21, F20, F19, F18, F17, F16, F15, F14]>;
 
352
def F4RC : RegisterClass<"PPC", [f32], 32, [F0, F1, F2, F3, F4, F5, F6, F7,
 
353
  F8, F9, F10, F11, F12, F13, F31, F30, F29, F28, F27, F26, F25, F24, F23,
 
354
  F22, F21, F20, F19, F18, F17, F16, F15, F14]>;
 
355
 
 
356
def VRRC : RegisterClass<"PPC", [v16i8,v8i16,v4i32,v4f32], 128,
 
357
 [V2, V3, V4, V5, V0, V1, 
 
358
  V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
 
359
  V29, V28, V27, V26, V25, V24, V23, V22, V21, V20]>;
 
360
 
 
361
def CRBITRC : RegisterClass<"PPC", [i32], 32,
 
362
  [CR0LT, CR0GT, CR0EQ, CR0UN,
 
363
   CR1LT, CR1GT, CR1EQ, CR1UN,
 
364
   CR2LT, CR2GT, CR2EQ, CR2UN,
 
365
   CR3LT, CR3GT, CR3EQ, CR3UN,
 
366
   CR4LT, CR4GT, CR4EQ, CR4UN,
 
367
   CR5LT, CR5GT, CR5EQ, CR5UN,
 
368
   CR6LT, CR6GT, CR6EQ, CR6UN,
 
369
   CR7LT, CR7GT, CR7EQ, CR7UN
 
370
  ]>
 
371
{
 
372
  let CopyCost = -1;
 
373
}
 
374
 
 
375
def CRRC : RegisterClass<"PPC", [i32], 32, [CR0, CR1, CR5, CR6, CR7, CR2, 
 
376
  CR3, CR4]>
 
377
{
 
378
  let SubRegClasses = [(CRBITRC sub_lt, sub_gt, sub_eq, sub_un)];
 
379
}
 
380
 
 
381
def CTRRC : RegisterClass<"PPC", [i32], 32, [CTR]>;
 
382
def CTRRC8 : RegisterClass<"PPC", [i64], 64, [CTR8]>;
 
383
def VRSAVERC : RegisterClass<"PPC", [i32], 32, [VRSAVE]>;
 
384
def CARRYRC : RegisterClass<"PPC", [i32], 32, [CARRY]> {
 
385
  let CopyCost = -1;
 
386
}