|
0
|
1 /* Sets (bit vectors) of hard registers, and operations on them.
|
|
|
2 Copyright (C) 1987, 1992, 1994, 2000, 2003, 2004, 2005, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #ifndef GCC_HARD_REG_SET_H
|
|
|
22 #define GCC_HARD_REG_SET_H
|
|
|
23
|
|
|
24 /* Define the type of a set of hard registers. */
|
|
|
25
|
|
|
26 /* HARD_REG_ELT_TYPE is a typedef of the unsigned integral type which
|
|
|
27 will be used for hard reg sets, either alone or in an array.
|
|
|
28
|
|
|
29 If HARD_REG_SET is a macro, its definition is HARD_REG_ELT_TYPE,
|
|
|
30 and it has enough bits to represent all the target machine's hard
|
|
|
31 registers. Otherwise, it is a typedef for a suitably sized array
|
|
|
32 of HARD_REG_ELT_TYPEs. HARD_REG_SET_LONGS is defined as how many.
|
|
|
33
|
|
|
34 Note that lots of code assumes that the first part of a regset is
|
|
|
35 the same format as a HARD_REG_SET. To help make sure this is true,
|
|
|
36 we only try the widest fast integer mode (HOST_WIDEST_FAST_INT)
|
|
|
37 instead of all the smaller types. This approach loses only if
|
|
|
38 there are very few registers and then only in the few cases where
|
|
|
39 we have an array of HARD_REG_SETs, so it needn't be as complex as
|
|
|
40 it used to be. */
|
|
|
41
|
|
|
42 typedef unsigned HOST_WIDEST_FAST_INT HARD_REG_ELT_TYPE;
|
|
|
43
|
|
|
44 #if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
|
|
|
45
|
|
|
46 #define HARD_REG_SET HARD_REG_ELT_TYPE
|
|
|
47
|
|
|
48 #else
|
|
|
49
|
|
|
50 #define HARD_REG_SET_LONGS \
|
|
|
51 ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1) \
|
|
|
52 / HOST_BITS_PER_WIDEST_FAST_INT)
|
|
|
53 typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS];
|
|
|
54
|
|
|
55 #endif
|
|
|
56
|
|
|
57 /* HARD_CONST is used to cast a constant to the appropriate type
|
|
|
58 for use with a HARD_REG_SET. */
|
|
|
59
|
|
|
60 #define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X))
|
|
|
61
|
|
|
62 /* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT
|
|
|
63 to set, clear or test one bit in a hard reg set of type HARD_REG_SET.
|
|
|
64 All three take two arguments: the set and the register number.
|
|
|
65
|
|
|
66 In the case where sets are arrays of longs, the first argument
|
|
|
67 is actually a pointer to a long.
|
|
|
68
|
|
|
69 Define two macros for initializing a set:
|
|
|
70 CLEAR_HARD_REG_SET and SET_HARD_REG_SET.
|
|
|
71 These take just one argument.
|
|
|
72
|
|
|
73 Also define macros for copying hard reg sets:
|
|
|
74 COPY_HARD_REG_SET and COMPL_HARD_REG_SET.
|
|
|
75 These take two arguments TO and FROM; they read from FROM
|
|
|
76 and store into TO. COMPL_HARD_REG_SET complements each bit.
|
|
|
77
|
|
|
78 Also define macros for combining hard reg sets:
|
|
|
79 IOR_HARD_REG_SET and AND_HARD_REG_SET.
|
|
|
80 These take two arguments TO and FROM; they read from FROM
|
|
|
81 and combine bitwise into TO. Define also two variants
|
|
|
82 IOR_COMPL_HARD_REG_SET and AND_COMPL_HARD_REG_SET
|
|
|
83 which use the complement of the set FROM.
|
|
|
84
|
|
|
85 Also define:
|
|
|
86
|
|
|
87 hard_reg_set_subset_p (X, Y), which returns true if X is a subset of Y.
|
|
|
88 hard_reg_set_equal_p (X, Y), which returns true if X and Y are equal.
|
|
|
89 hard_reg_set_intersect_p (X, Y), which returns true if X and Y intersect.
|
|
|
90 hard_reg_set_empty_p (X), which returns true if X is empty. */
|
|
|
91
|
|
|
92 #define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
|
|
|
93
|
|
|
94 #ifdef HARD_REG_SET
|
|
|
95
|
|
|
96 #define SET_HARD_REG_BIT(SET, BIT) \
|
|
|
97 ((SET) |= HARD_CONST (1) << (BIT))
|
|
|
98 #define CLEAR_HARD_REG_BIT(SET, BIT) \
|
|
|
99 ((SET) &= ~(HARD_CONST (1) << (BIT)))
|
|
|
100 #define TEST_HARD_REG_BIT(SET, BIT) \
|
|
|
101 (!!((SET) & (HARD_CONST (1) << (BIT))))
|
|
|
102
|
|
|
103 #define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0))
|
|
|
104 #define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0))
|
|
|
105
|
|
|
106 #define COPY_HARD_REG_SET(TO, FROM) ((TO) = (FROM))
|
|
|
107 #define COMPL_HARD_REG_SET(TO, FROM) ((TO) = ~(FROM))
|
|
|
108
|
|
|
109 #define IOR_HARD_REG_SET(TO, FROM) ((TO) |= (FROM))
|
|
|
110 #define IOR_COMPL_HARD_REG_SET(TO, FROM) ((TO) |= ~ (FROM))
|
|
|
111 #define AND_HARD_REG_SET(TO, FROM) ((TO) &= (FROM))
|
|
|
112 #define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM))
|
|
|
113
|
|
|
114 static inline bool
|
|
|
115 hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
116 {
|
|
|
117 return (x & ~y) == HARD_CONST (0);
|
|
|
118 }
|
|
|
119
|
|
|
120 static inline bool
|
|
|
121 hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
122 {
|
|
|
123 return x == y;
|
|
|
124 }
|
|
|
125
|
|
|
126 static inline bool
|
|
|
127 hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
128 {
|
|
|
129 return (x & y) != HARD_CONST (0);
|
|
|
130 }
|
|
|
131
|
|
|
132 static inline bool
|
|
|
133 hard_reg_set_empty_p (const HARD_REG_SET x)
|
|
|
134 {
|
|
|
135 return x == HARD_CONST (0);
|
|
|
136 }
|
|
|
137
|
|
|
138 #else
|
|
|
139
|
|
|
140 #define SET_HARD_REG_BIT(SET, BIT) \
|
|
|
141 ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \
|
|
|
142 |= HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))
|
|
|
143
|
|
|
144 #define CLEAR_HARD_REG_BIT(SET, BIT) \
|
|
|
145 ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \
|
|
|
146 &= ~(HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))
|
|
|
147
|
|
|
148 #define TEST_HARD_REG_BIT(SET, BIT) \
|
|
|
149 (!!((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT] \
|
|
|
150 & (HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))))
|
|
|
151
|
|
|
152 #if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDEST_FAST_INT
|
|
|
153 #define CLEAR_HARD_REG_SET(TO) \
|
|
|
154 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
155 scan_tp_[0] = 0; \
|
|
|
156 scan_tp_[1] = 0; } while (0)
|
|
|
157
|
|
|
158 #define SET_HARD_REG_SET(TO) \
|
|
|
159 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
160 scan_tp_[0] = -1; \
|
|
|
161 scan_tp_[1] = -1; } while (0)
|
|
|
162
|
|
|
163 #define COPY_HARD_REG_SET(TO, FROM) \
|
|
|
164 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
165 scan_tp_[0] = scan_fp_[0]; \
|
|
|
166 scan_tp_[1] = scan_fp_[1]; } while (0)
|
|
|
167
|
|
|
168 #define COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
169 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
170 scan_tp_[0] = ~ scan_fp_[0]; \
|
|
|
171 scan_tp_[1] = ~ scan_fp_[1]; } while (0)
|
|
|
172
|
|
|
173 #define AND_HARD_REG_SET(TO, FROM) \
|
|
|
174 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
175 scan_tp_[0] &= scan_fp_[0]; \
|
|
|
176 scan_tp_[1] &= scan_fp_[1]; } while (0)
|
|
|
177
|
|
|
178 #define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
179 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
180 scan_tp_[0] &= ~ scan_fp_[0]; \
|
|
|
181 scan_tp_[1] &= ~ scan_fp_[1]; } while (0)
|
|
|
182
|
|
|
183 #define IOR_HARD_REG_SET(TO, FROM) \
|
|
|
184 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
185 scan_tp_[0] |= scan_fp_[0]; \
|
|
|
186 scan_tp_[1] |= scan_fp_[1]; } while (0)
|
|
|
187
|
|
|
188 #define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
189 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
190 scan_tp_[0] |= ~ scan_fp_[0]; \
|
|
|
191 scan_tp_[1] |= ~ scan_fp_[1]; } while (0)
|
|
|
192
|
|
|
193 static inline bool
|
|
|
194 hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
195 {
|
|
|
196 return (x[0] & ~y[0]) == 0 && (x[1] & ~y[1]) == 0;
|
|
|
197 }
|
|
|
198
|
|
|
199 static inline bool
|
|
|
200 hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
201 {
|
|
|
202 return x[0] == y[0] && x[1] == y[1];
|
|
|
203 }
|
|
|
204
|
|
|
205 static inline bool
|
|
|
206 hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
207 {
|
|
|
208 return (x[0] & y[0]) != 0 || (x[1] & y[1]) != 0;
|
|
|
209 }
|
|
|
210
|
|
|
211 static inline bool
|
|
|
212 hard_reg_set_empty_p (const HARD_REG_SET x)
|
|
|
213 {
|
|
|
214 return x[0] == 0 && x[1] == 0;
|
|
|
215 }
|
|
|
216
|
|
|
217 #else
|
|
|
218 #if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDEST_FAST_INT
|
|
|
219 #define CLEAR_HARD_REG_SET(TO) \
|
|
|
220 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
221 scan_tp_[0] = 0; \
|
|
|
222 scan_tp_[1] = 0; \
|
|
|
223 scan_tp_[2] = 0; } while (0)
|
|
|
224
|
|
|
225 #define SET_HARD_REG_SET(TO) \
|
|
|
226 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
227 scan_tp_[0] = -1; \
|
|
|
228 scan_tp_[1] = -1; \
|
|
|
229 scan_tp_[2] = -1; } while (0)
|
|
|
230
|
|
|
231 #define COPY_HARD_REG_SET(TO, FROM) \
|
|
|
232 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
233 scan_tp_[0] = scan_fp_[0]; \
|
|
|
234 scan_tp_[1] = scan_fp_[1]; \
|
|
|
235 scan_tp_[2] = scan_fp_[2]; } while (0)
|
|
|
236
|
|
|
237 #define COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
238 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
239 scan_tp_[0] = ~ scan_fp_[0]; \
|
|
|
240 scan_tp_[1] = ~ scan_fp_[1]; \
|
|
|
241 scan_tp_[2] = ~ scan_fp_[2]; } while (0)
|
|
|
242
|
|
|
243 #define AND_HARD_REG_SET(TO, FROM) \
|
|
|
244 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
245 scan_tp_[0] &= scan_fp_[0]; \
|
|
|
246 scan_tp_[1] &= scan_fp_[1]; \
|
|
|
247 scan_tp_[2] &= scan_fp_[2]; } while (0)
|
|
|
248
|
|
|
249 #define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
250 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
251 scan_tp_[0] &= ~ scan_fp_[0]; \
|
|
|
252 scan_tp_[1] &= ~ scan_fp_[1]; \
|
|
|
253 scan_tp_[2] &= ~ scan_fp_[2]; } while (0)
|
|
|
254
|
|
|
255 #define IOR_HARD_REG_SET(TO, FROM) \
|
|
|
256 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
257 scan_tp_[0] |= scan_fp_[0]; \
|
|
|
258 scan_tp_[1] |= scan_fp_[1]; \
|
|
|
259 scan_tp_[2] |= scan_fp_[2]; } while (0)
|
|
|
260
|
|
|
261 #define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
262 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
263 scan_tp_[0] |= ~ scan_fp_[0]; \
|
|
|
264 scan_tp_[1] |= ~ scan_fp_[1]; \
|
|
|
265 scan_tp_[2] |= ~ scan_fp_[2]; } while (0)
|
|
|
266
|
|
|
267 static inline bool
|
|
|
268 hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
269 {
|
|
|
270 return ((x[0] & ~y[0]) == 0
|
|
|
271 && (x[1] & ~y[1]) == 0
|
|
|
272 && (x[2] & ~y[2]) == 0);
|
|
|
273 }
|
|
|
274
|
|
|
275 static inline bool
|
|
|
276 hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
277 {
|
|
|
278 return x[0] == y[0] && x[1] == y[1] && x[2] == y[2];
|
|
|
279 }
|
|
|
280
|
|
|
281 static inline bool
|
|
|
282 hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
283 {
|
|
|
284 return ((x[0] & y[0]) != 0
|
|
|
285 || (x[1] & y[1]) != 0
|
|
|
286 || (x[2] & y[2]) != 0);
|
|
|
287 }
|
|
|
288
|
|
|
289 static inline bool
|
|
|
290 hard_reg_set_empty_p (const HARD_REG_SET x)
|
|
|
291 {
|
|
|
292 return x[0] == 0 && x[1] == 0 && x[2] == 0;
|
|
|
293 }
|
|
|
294
|
|
|
295 #else
|
|
|
296 #if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDEST_FAST_INT
|
|
|
297 #define CLEAR_HARD_REG_SET(TO) \
|
|
|
298 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
299 scan_tp_[0] = 0; \
|
|
|
300 scan_tp_[1] = 0; \
|
|
|
301 scan_tp_[2] = 0; \
|
|
|
302 scan_tp_[3] = 0; } while (0)
|
|
|
303
|
|
|
304 #define SET_HARD_REG_SET(TO) \
|
|
|
305 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
306 scan_tp_[0] = -1; \
|
|
|
307 scan_tp_[1] = -1; \
|
|
|
308 scan_tp_[2] = -1; \
|
|
|
309 scan_tp_[3] = -1; } while (0)
|
|
|
310
|
|
|
311 #define COPY_HARD_REG_SET(TO, FROM) \
|
|
|
312 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
313 scan_tp_[0] = scan_fp_[0]; \
|
|
|
314 scan_tp_[1] = scan_fp_[1]; \
|
|
|
315 scan_tp_[2] = scan_fp_[2]; \
|
|
|
316 scan_tp_[3] = scan_fp_[3]; } while (0)
|
|
|
317
|
|
|
318 #define COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
319 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
320 scan_tp_[0] = ~ scan_fp_[0]; \
|
|
|
321 scan_tp_[1] = ~ scan_fp_[1]; \
|
|
|
322 scan_tp_[2] = ~ scan_fp_[2]; \
|
|
|
323 scan_tp_[3] = ~ scan_fp_[3]; } while (0)
|
|
|
324
|
|
|
325 #define AND_HARD_REG_SET(TO, FROM) \
|
|
|
326 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
327 scan_tp_[0] &= scan_fp_[0]; \
|
|
|
328 scan_tp_[1] &= scan_fp_[1]; \
|
|
|
329 scan_tp_[2] &= scan_fp_[2]; \
|
|
|
330 scan_tp_[3] &= scan_fp_[3]; } while (0)
|
|
|
331
|
|
|
332 #define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
333 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
334 scan_tp_[0] &= ~ scan_fp_[0]; \
|
|
|
335 scan_tp_[1] &= ~ scan_fp_[1]; \
|
|
|
336 scan_tp_[2] &= ~ scan_fp_[2]; \
|
|
|
337 scan_tp_[3] &= ~ scan_fp_[3]; } while (0)
|
|
|
338
|
|
|
339 #define IOR_HARD_REG_SET(TO, FROM) \
|
|
|
340 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
341 scan_tp_[0] |= scan_fp_[0]; \
|
|
|
342 scan_tp_[1] |= scan_fp_[1]; \
|
|
|
343 scan_tp_[2] |= scan_fp_[2]; \
|
|
|
344 scan_tp_[3] |= scan_fp_[3]; } while (0)
|
|
|
345
|
|
|
346 #define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
347 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
348 scan_tp_[0] |= ~ scan_fp_[0]; \
|
|
|
349 scan_tp_[1] |= ~ scan_fp_[1]; \
|
|
|
350 scan_tp_[2] |= ~ scan_fp_[2]; \
|
|
|
351 scan_tp_[3] |= ~ scan_fp_[3]; } while (0)
|
|
|
352
|
|
|
353 static inline bool
|
|
|
354 hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
355 {
|
|
|
356 return ((x[0] & ~y[0]) == 0
|
|
|
357 && (x[1] & ~y[1]) == 0
|
|
|
358 && (x[2] & ~y[2]) == 0
|
|
|
359 && (x[3] & ~y[3]) == 0);
|
|
|
360 }
|
|
|
361
|
|
|
362 static inline bool
|
|
|
363 hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
364 {
|
|
|
365 return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3];
|
|
|
366 }
|
|
|
367
|
|
|
368 static inline bool
|
|
|
369 hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
370 {
|
|
|
371 return ((x[0] & y[0]) != 0
|
|
|
372 || (x[1] & y[1]) != 0
|
|
|
373 || (x[2] & y[2]) != 0
|
|
|
374 || (x[3] & y[3]) != 0);
|
|
|
375 }
|
|
|
376
|
|
|
377 static inline bool
|
|
|
378 hard_reg_set_empty_p (const HARD_REG_SET x)
|
|
|
379 {
|
|
|
380 return x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0;
|
|
|
381 }
|
|
|
382
|
|
|
383 #else /* FIRST_PSEUDO_REGISTER > 4*HOST_BITS_PER_WIDEST_FAST_INT */
|
|
|
384
|
|
|
385 #define CLEAR_HARD_REG_SET(TO) \
|
|
|
386 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
387 int i; \
|
|
|
388 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
389 *scan_tp_++ = 0; } while (0)
|
|
|
390
|
|
|
391 #define SET_HARD_REG_SET(TO) \
|
|
|
392 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO); \
|
|
|
393 int i; \
|
|
|
394 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
395 *scan_tp_++ = -1; } while (0)
|
|
|
396
|
|
|
397 #define COPY_HARD_REG_SET(TO, FROM) \
|
|
|
398 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
399 int i; \
|
|
|
400 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
401 *scan_tp_++ = *scan_fp_++; } while (0)
|
|
|
402
|
|
|
403 #define COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
404 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
405 int i; \
|
|
|
406 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
407 *scan_tp_++ = ~ *scan_fp_++; } while (0)
|
|
|
408
|
|
|
409 #define AND_HARD_REG_SET(TO, FROM) \
|
|
|
410 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
411 int i; \
|
|
|
412 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
413 *scan_tp_++ &= *scan_fp_++; } while (0)
|
|
|
414
|
|
|
415 #define AND_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
416 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
417 int i; \
|
|
|
418 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
419 *scan_tp_++ &= ~ *scan_fp_++; } while (0)
|
|
|
420
|
|
|
421 #define IOR_HARD_REG_SET(TO, FROM) \
|
|
|
422 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
423 int i; \
|
|
|
424 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
425 *scan_tp_++ |= *scan_fp_++; } while (0)
|
|
|
426
|
|
|
427 #define IOR_COMPL_HARD_REG_SET(TO, FROM) \
|
|
|
428 do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
|
|
|
429 int i; \
|
|
|
430 for (i = 0; i < HARD_REG_SET_LONGS; i++) \
|
|
|
431 *scan_tp_++ |= ~ *scan_fp_++; } while (0)
|
|
|
432
|
|
|
433 static inline bool
|
|
|
434 hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
435 {
|
|
|
436 int i;
|
|
|
437
|
|
|
438 for (i = 0; i < HARD_REG_SET_LONGS; i++)
|
|
|
439 if ((x[i] & ~y[i]) != 0)
|
|
|
440 return false;
|
|
|
441 return true;
|
|
|
442 }
|
|
|
443
|
|
|
444 static inline bool
|
|
|
445 hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
446 {
|
|
|
447 int i;
|
|
|
448
|
|
|
449 for (i = 0; i < HARD_REG_SET_LONGS; i++)
|
|
|
450 if (x[i] != y[i])
|
|
|
451 return false;
|
|
|
452 return true;
|
|
|
453 }
|
|
|
454
|
|
|
455 static inline bool
|
|
|
456 hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
|
|
|
457 {
|
|
|
458 int i;
|
|
|
459
|
|
|
460 for (i = 0; i < HARD_REG_SET_LONGS; i++)
|
|
|
461 if ((x[i] & y[i]) != 0)
|
|
|
462 return true;
|
|
|
463 return false;
|
|
|
464 }
|
|
|
465
|
|
|
466 static inline bool
|
|
|
467 hard_reg_set_empty_p (const HARD_REG_SET x)
|
|
|
468 {
|
|
|
469 int i;
|
|
|
470
|
|
|
471 for (i = 0; i < HARD_REG_SET_LONGS; i++)
|
|
|
472 if (x[i] != 0)
|
|
|
473 return false;
|
|
|
474 return true;
|
|
|
475 }
|
|
|
476
|
|
|
477 #endif
|
|
|
478 #endif
|
|
|
479 #endif
|
|
|
480 #endif
|
|
|
481
|
|
|
482 /* Iterator for hard register sets. */
|
|
|
483
|
|
|
484 typedef struct
|
|
|
485 {
|
|
|
486 /* Pointer to the current element. */
|
|
|
487 HARD_REG_ELT_TYPE *pelt;
|
|
|
488
|
|
|
489 /* The length of the set. */
|
|
|
490 unsigned short length;
|
|
|
491
|
|
|
492 /* Word within the current element. */
|
|
|
493 unsigned short word_no;
|
|
|
494
|
|
|
495 /* Contents of the actually processed word. When finding next bit
|
|
|
496 it is shifted right, so that the actual bit is always the least
|
|
|
497 significant bit of ACTUAL. */
|
|
|
498 HARD_REG_ELT_TYPE bits;
|
|
|
499 } hard_reg_set_iterator;
|
|
|
500
|
|
|
501 #define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT
|
|
|
502
|
|
|
503 /* The implementation of the iterator functions is fully analogous to
|
|
|
504 the bitmap iterators. */
|
|
|
505 static inline void
|
|
|
506 hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set,
|
|
|
507 unsigned min, unsigned *regno)
|
|
|
508 {
|
|
|
509 #ifdef HARD_REG_SET_LONGS
|
|
|
510 iter->pelt = set;
|
|
|
511 iter->length = HARD_REG_SET_LONGS;
|
|
|
512 #else
|
|
|
513 iter->pelt = &set;
|
|
|
514 iter->length = 1;
|
|
|
515 #endif
|
|
|
516 iter->word_no = min / HARD_REG_ELT_BITS;
|
|
|
517 if (iter->word_no < iter->length)
|
|
|
518 {
|
|
|
519 iter->bits = iter->pelt[iter->word_no];
|
|
|
520 iter->bits >>= min % HARD_REG_ELT_BITS;
|
|
|
521
|
|
|
522 /* This is required for correct search of the next bit. */
|
|
|
523 min += !iter->bits;
|
|
|
524 }
|
|
|
525 *regno = min;
|
|
|
526 }
|
|
|
527
|
|
|
528 static inline bool
|
|
|
529 hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno)
|
|
|
530 {
|
|
|
531 while (1)
|
|
|
532 {
|
|
|
533 /* Return false when we're advanced past the end of the set. */
|
|
|
534 if (iter->word_no >= iter->length)
|
|
|
535 return false;
|
|
|
536
|
|
|
537 if (iter->bits)
|
|
|
538 {
|
|
|
539 /* Find the correct bit and return it. */
|
|
|
540 while (!(iter->bits & 1))
|
|
|
541 {
|
|
|
542 iter->bits >>= 1;
|
|
|
543 *regno += 1;
|
|
|
544 }
|
|
|
545 return (*regno < FIRST_PSEUDO_REGISTER);
|
|
|
546 }
|
|
|
547
|
|
|
548 /* Round to the beginning of the next word. */
|
|
|
549 *regno = (*regno + HARD_REG_ELT_BITS - 1);
|
|
|
550 *regno -= *regno % HARD_REG_ELT_BITS;
|
|
|
551
|
|
|
552 /* Find the next non-zero word. */
|
|
|
553 while (++iter->word_no < iter->length)
|
|
|
554 {
|
|
|
555 iter->bits = iter->pelt[iter->word_no];
|
|
|
556 if (iter->bits)
|
|
|
557 break;
|
|
|
558 *regno += HARD_REG_ELT_BITS;
|
|
|
559 }
|
|
|
560 }
|
|
|
561 }
|
|
|
562
|
|
|
563 static inline void
|
|
|
564 hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
|
|
|
565 {
|
|
|
566 iter->bits >>= 1;
|
|
|
567 *regno += 1;
|
|
|
568 }
|
|
|
569
|
|
|
570 #define EXECUTE_IF_SET_IN_HARD_REG_SET(SET, MIN, REGNUM, ITER) \
|
|
|
571 for (hard_reg_set_iter_init (&(ITER), (SET), (MIN), &(REGNUM)); \
|
|
|
572 hard_reg_set_iter_set (&(ITER), &(REGNUM)); \
|
|
|
573 hard_reg_set_iter_next (&(ITER), &(REGNUM)))
|
|
|
574
|
|
|
575
|
|
|
576 /* Define some standard sets of registers. */
|
|
|
577
|
|
|
578 /* Indexed by hard register number, contains 1 for registers
|
|
|
579 that are fixed use (stack pointer, pc, frame pointer, etc.).
|
|
|
580 These are the registers that cannot be used to allocate
|
|
|
581 a pseudo reg whose life does not cross calls. */
|
|
|
582
|
|
|
583 extern char fixed_regs[FIRST_PSEUDO_REGISTER];
|
|
|
584
|
|
|
585 /* The same info as a HARD_REG_SET. */
|
|
|
586
|
|
|
587 extern HARD_REG_SET fixed_reg_set;
|
|
|
588
|
|
|
589 /* Indexed by hard register number, contains 1 for registers
|
|
|
590 that are fixed use or are clobbered by function calls.
|
|
|
591 These are the registers that cannot be used to allocate
|
|
|
592 a pseudo reg whose life crosses calls. */
|
|
|
593
|
|
|
594 extern char call_used_regs[FIRST_PSEUDO_REGISTER];
|
|
|
595
|
|
|
596 #ifdef CALL_REALLY_USED_REGISTERS
|
|
|
597 extern char call_really_used_regs[];
|
|
|
598 #endif
|
|
|
599
|
|
|
600 /* The same info as a HARD_REG_SET. */
|
|
|
601
|
|
|
602 extern HARD_REG_SET call_used_reg_set;
|
|
|
603
|
|
|
604 /* Indexed by hard register number, contains 1 for registers that are
|
|
|
605 fixed use -- i.e. in fixed_regs -- or a function value return register
|
|
|
606 or TARGET_STRUCT_VALUE_RTX or STATIC_CHAIN_REGNUM. These are the
|
|
|
607 registers that cannot hold quantities across calls even if we are
|
|
|
608 willing to save and restore them. */
|
|
|
609
|
|
|
610 extern char call_fixed_regs[FIRST_PSEUDO_REGISTER];
|
|
|
611
|
|
|
612 /* The same info as a HARD_REG_SET. */
|
|
|
613
|
|
|
614 extern HARD_REG_SET call_fixed_reg_set;
|
|
|
615
|
|
|
616 /* Indexed by hard register number, contains 1 for registers
|
|
|
617 that are being used for global register decls.
|
|
|
618 These must be exempt from ordinary flow analysis
|
|
|
619 and are also considered fixed. */
|
|
|
620
|
|
|
621 extern char global_regs[FIRST_PSEUDO_REGISTER];
|
|
|
622
|
|
|
623 /* Contains 1 for registers that are set or clobbered by calls. */
|
|
|
624 /* ??? Ideally, this would be just call_used_regs plus global_regs, but
|
|
|
625 for someone's bright idea to have call_used_regs strictly include
|
|
|
626 fixed_regs. Which leaves us guessing as to the set of fixed_regs
|
|
|
627 that are actually preserved. We know for sure that those associated
|
|
|
628 with the local stack frame are safe, but scant others. */
|
|
|
629
|
|
|
630 extern HARD_REG_SET regs_invalidated_by_call;
|
|
|
631
|
|
|
632 /* Call used hard registers which can not be saved because there is no
|
|
|
633 insn for this. */
|
|
|
634
|
|
|
635 extern HARD_REG_SET no_caller_save_reg_set;
|
|
|
636
|
|
|
637 #ifdef REG_ALLOC_ORDER
|
|
|
638 /* Table of register numbers in the order in which to try to use them. */
|
|
|
639
|
|
|
640 extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
|
|
|
641
|
|
|
642 /* The inverse of reg_alloc_order. */
|
|
|
643
|
|
|
644 extern int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
|
|
|
645 #endif
|
|
|
646
|
|
|
647 /* For each reg class, a HARD_REG_SET saying which registers are in it. */
|
|
|
648
|
|
|
649 extern HARD_REG_SET reg_class_contents[N_REG_CLASSES];
|
|
|
650
|
|
|
651 /* For each reg class, number of regs it contains. */
|
|
|
652
|
|
|
653 extern unsigned int reg_class_size[N_REG_CLASSES];
|
|
|
654
|
|
|
655 /* For each reg class, table listing all the classes contained in it. */
|
|
|
656
|
|
|
657 extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
|
|
|
658
|
|
|
659 /* For each pair of reg classes,
|
|
|
660 a largest reg class contained in their union. */
|
|
|
661
|
|
|
662 extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
|
|
|
663
|
|
|
664 /* For each pair of reg classes,
|
|
|
665 the smallest reg class that contains their union. */
|
|
|
666
|
|
|
667 extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
|
|
|
668
|
|
|
669 /* Vector indexed by hardware reg giving its name. */
|
|
|
670
|
|
|
671 extern const char * reg_names[FIRST_PSEUDO_REGISTER];
|
|
|
672
|
|
|
673 /* Vector indexed by reg class giving its name. */
|
|
|
674
|
|
|
675 extern const char * reg_class_names[];
|
|
|
676
|
|
|
677 /* Given a hard REGN a FROM mode and a TO mode, return nonzero if
|
|
|
678 REGN cannot change modes between the specified modes. */
|
|
|
679 #define REG_CANNOT_CHANGE_MODE_P(REGN, FROM, TO) \
|
|
|
680 CANNOT_CHANGE_MODE_CLASS (FROM, TO, REGNO_REG_CLASS (REGN))
|
|
|
681
|
|
|
682 #endif /* ! GCC_HARD_REG_SET_H */
|
