]>
Commit | Line | Data |
---|---|---|
ed8d2920 MM |
1 | /* Graph coloring register allocator |
2 | Copyright (C) 2001, 2002 Free Software Foundation, Inc. | |
3 | Contributed by Michael Matz <matz@suse.de> | |
4 | and Daniel Berlin <dan@cgsoftware.com>. | |
5 | ||
6 | This file is part of GCC. | |
7 | ||
8 | GCC is free software; you can redistribute it and/or modify it under the | |
9 | terms of the GNU General Public License as published by the Free Software | |
10 | Foundation; either version 2, or (at your option) any later 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 FITNESS | |
14 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for more | |
15 | details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License along | |
18 | with GCC; see the file COPYING. If not, write to the Free Software | |
19 | Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | /* Double linked list to implement the per-type lists of webs | |
22 | and moves. */ | |
23 | struct dlist | |
24 | { | |
25 | struct dlist *prev; | |
26 | struct dlist *next; | |
27 | union | |
28 | { | |
29 | struct web *web; | |
30 | struct move *move; | |
31 | } value; | |
32 | }; | |
33 | /* Simple helper macros for ease of misuse. */ | |
34 | #define DLIST_WEB(l) ((l)->value.web) | |
35 | #define DLIST_MOVE(l) ((l)->value.move) | |
36 | ||
37 | /* Classification of a given node (i.e. what state it's in). */ | |
38 | enum node_type | |
39 | { | |
40 | INITIAL = 0, FREE, | |
41 | PRECOLORED, | |
42 | SIMPLIFY, SIMPLIFY_SPILL, SIMPLIFY_FAT, FREEZE, SPILL, | |
43 | SELECT, | |
44 | SPILLED, COALESCED, COLORED, | |
45 | LAST_NODE_TYPE | |
46 | }; | |
47 | ||
48 | /* A list of conflict bitmaps, factorized on the exact part of | |
49 | the source, which conflicts with the DEFs, whose ID are noted in | |
50 | the bitmap. This is used while building web-parts with conflicts. */ | |
51 | struct tagged_conflict | |
52 | { | |
53 | struct tagged_conflict *next; | |
54 | bitmap conflicts; | |
55 | ||
56 | /* If the part of source identified by size S, byteoffset O conflicts, | |
57 | then size_word == S | (O << 16). */ | |
58 | unsigned int size_word; | |
59 | }; | |
60 | ||
61 | /* Such a structure is allocated initially for each def and use. | |
62 | In the process of building the interference graph web parts are | |
63 | connected together, if they have common instructions and reference the | |
64 | same register. That way live ranges are build (by connecting defs and | |
d55d8fc7 | 65 | uses) and implicitly complete webs (by connecting web parts in common |
ed8d2920 MM |
66 | uses). */ |
67 | struct web_part | |
68 | { | |
69 | /* The def or use for this web part. */ | |
70 | struct ref *ref; | |
71 | /* The uplink implementing the disjoint set. */ | |
72 | struct web_part *uplink; | |
73 | ||
74 | /* Here dynamic information associated with each def/use is saved. | |
75 | This all is only valid for root web parts (uplink==NULL). | |
76 | That's the information we need to merge, if web parts are unioned. */ | |
77 | ||
78 | /* Number of spanned insns containing any deaths. */ | |
79 | unsigned int spanned_deaths; | |
80 | /* The list of bitmaps of DEF ID's with which this part conflicts. */ | |
81 | struct tagged_conflict *sub_conflicts; | |
82 | /* If there's any call_insn, while this part is live. */ | |
83 | unsigned int crosses_call : 1; | |
84 | }; | |
85 | ||
86 | /* Web structure used to store info about connected live ranges. | |
87 | This represents the nodes of the interference graph, which gets | |
88 | colored. It can also hold subwebs, which are contained in webs | |
89 | and represent subregs. */ | |
90 | struct web | |
91 | { | |
92 | /* Unique web ID. */ | |
93 | unsigned int id; | |
94 | ||
95 | /* Register number of the live range's variable. */ | |
96 | unsigned int regno; | |
97 | ||
98 | /* How many insns containing deaths do we span? */ | |
99 | unsigned int span_deaths; | |
100 | ||
101 | /* Spill_temp indicates if this web was part of a web spilled in the | |
102 | last iteration, or or reasons why this shouldn't be spilled again. | |
103 | 1 spill web, can't be spilled. | |
104 | 2 big spill web (live over some deaths). Discouraged, but not | |
105 | impossible to spill again. | |
106 | 3 short web (spans no deaths), can't be spilled. */ | |
107 | unsigned int spill_temp; | |
108 | ||
109 | /* When coalescing we might change spill_temp. If breaking aliases we | |
110 | need to restore it. */ | |
111 | unsigned int orig_spill_temp; | |
112 | ||
113 | /* Cost of spilling. */ | |
114 | unsigned HOST_WIDE_INT spill_cost; | |
115 | unsigned HOST_WIDE_INT orig_spill_cost; | |
116 | ||
117 | /* How many webs are aliased to us? */ | |
118 | unsigned int num_aliased; | |
119 | ||
120 | /* The color we got. This is a hardreg number. */ | |
121 | int color; | |
122 | /* 1 + the color this web got in the last pass. If it hadn't got a color, | |
123 | or we are in the first pass, or this web is a new one, this is zero. */ | |
124 | int old_color; | |
125 | ||
126 | /* Now follow some flags characterizing the web. */ | |
127 | ||
128 | /* Nonzero, if we should use usable_regs for this web, instead of | |
129 | preferred_class() or alternate_class(). */ | |
130 | unsigned int use_my_regs:1; | |
131 | ||
132 | /* Nonzero if we selected this web as possible spill candidate in | |
133 | select_spill(). */ | |
134 | unsigned int was_spilled:1; | |
135 | ||
136 | /* We need to distinguish also webs which are targets of coalescing | |
137 | (all x with some y, so that x==alias(y)), but the alias field is | |
138 | only set for sources of coalescing. This flag is set for all webs | |
139 | involved in coalescing in some way. */ | |
140 | unsigned int is_coalesced:1; | |
141 | ||
142 | /* Nonzero, if this web (or subweb) doesn't correspond with any of | |
143 | the current functions actual use of reg rtx. Happens e.g. with | |
144 | conflicts to a web, of which only a part was still undefined at the | |
145 | point of that conflict. In this case we construct a subweb | |
146 | representing these yet undefined bits to have a target for the | |
147 | conflict. Suppose e.g. this sequence: | |
148 | (set (reg:DI x) ...) | |
149 | (set (reg:SI y) ...) | |
150 | (set (subreg:SI (reg:DI x) 0) ...) | |
151 | (use (reg:DI x)) | |
152 | Here x only partly conflicts with y. Namely only (subreg:SI (reg:DI x) | |
153 | 1) conflicts with it, but this rtx doesn't show up in the program. For | |
154 | such things an "artificial" subweb is built, and this flag is true for | |
155 | them. */ | |
156 | unsigned int artificial:1; | |
157 | ||
158 | /* Nonzero if we span a call_insn. */ | |
159 | unsigned int crosses_call:1; | |
160 | ||
161 | /* Wether the web is involved in a move insn. */ | |
162 | unsigned int move_related:1; | |
163 | ||
164 | /* 1 when this web (or parts thereof) are live over an abnormal edge. */ | |
165 | unsigned int live_over_abnormal:1; | |
166 | ||
167 | /* Nonzero if this web is used in subregs where the mode change | |
168 | was illegal for hardregs in CLASS_CANNOT_CHANGE_MODE. */ | |
169 | unsigned int mode_changed:1; | |
170 | ||
171 | /* Nonzero, when this web stems from the last pass of the allocator, | |
172 | and all info is still valid (i.e. it wasn't spilled). */ | |
173 | unsigned int old_web:1; | |
174 | ||
175 | /* Used in rewrite_program2() to remember webs, which | |
176 | are already marked for (re)loading. */ | |
177 | unsigned int in_load:1; | |
178 | ||
179 | /* If in_load is != 0, then this is nonzero, if only one use was seen | |
180 | since insertion in loadlist. Zero if more uses currently need a | |
181 | reload. Used to differentiate between inserting register loads or | |
182 | directly substituting the stackref. */ | |
183 | unsigned int one_load:1; | |
184 | ||
185 | /* When using rewrite_program2() this flag gets set if some insns | |
186 | were inserted on behalf of this web. IR spilling might ignore some | |
187 | deaths up to the def, so no code might be emitted and we need not to | |
188 | spill such a web again. */ | |
189 | unsigned int changed:1; | |
190 | ||
191 | /* With interference region spilling it's sometimes the case, that a | |
192 | bb border is also an IR border for webs, which were targets of moves, | |
193 | which are already removed due to coalescing. All webs, which are | |
194 | a destination of such a removed move, have this flag set. */ | |
195 | unsigned int target_of_spilled_move:1; | |
196 | ||
197 | /* For optimistic coalescing we need to be able to break aliases, which | |
198 | includes restoring conflicts to those before coalescing. This flag | |
199 | is set, if we have a list of conflicts before coalescing. It's needed | |
200 | because that list is lazily constructed only when actually needed. */ | |
201 | unsigned int have_orig_conflicts:1; | |
202 | ||
203 | /* Current state of the node. */ | |
204 | ENUM_BITFIELD(node_type) type:5; | |
205 | ||
206 | /* A regclass, combined from preferred and alternate class, or calculated | |
207 | from usable_regs. Used only for debugging, and to determine | |
208 | add_hardregs. */ | |
209 | ENUM_BITFIELD(reg_class) regclass:10; | |
210 | ||
211 | /* Additional consecutive hardregs needed for this web. */ | |
212 | int add_hardregs; | |
213 | ||
214 | /* Number of conflicts currently. */ | |
215 | int num_conflicts; | |
216 | ||
217 | /* Numbers of uses and defs, which belong to this web. */ | |
218 | unsigned int num_uses; | |
219 | unsigned int num_defs; | |
220 | ||
221 | /* The (reg:M a) or (subreg:M1 (reg:M2 a) x) rtx which this | |
222 | web is based on. This is used to distinguish subreg webs | |
223 | from it's reg parents, and to get hold of the mode. */ | |
224 | rtx orig_x; | |
225 | ||
226 | /* If this web is a subweb, this point to the super web. Otherwise | |
227 | it's NULL. */ | |
228 | struct web *parent_web; | |
229 | ||
230 | /* If this web is a subweb, but not the last one, this points to the | |
231 | next subweb of the same super web. Otherwise it's NULL. */ | |
232 | struct web *subreg_next; | |
233 | ||
234 | /* The set of webs (or subwebs), this web conflicts with. */ | |
235 | struct conflict_link *conflict_list; | |
236 | ||
237 | /* If have_orig_conflicts is set this contains a copy of conflict_list, | |
238 | as it was right after building the interference graph. | |
239 | It's used for incremental i-graph building and for breaking | |
240 | coalescings again. */ | |
241 | struct conflict_link *orig_conflict_list; | |
242 | ||
243 | /* Bitmap of all conflicts which don't count this pass, because of | |
244 | non-intersecting hardregs of the conflicting webs. See also | |
245 | record_conflict(). */ | |
246 | bitmap useless_conflicts; | |
247 | ||
248 | /* Different sets of hard registers, for all usable registers, ... */ | |
249 | HARD_REG_SET usable_regs; | |
250 | /* ... the same before coalescing, ... */ | |
251 | HARD_REG_SET orig_usable_regs; | |
252 | /* ... colors of all already colored neighbors (used when biased coloring | |
253 | is active), and ... */ | |
254 | HARD_REG_SET bias_colors; | |
255 | /* ... colors of PRECOLORED webs this web is connected to by a move. */ | |
256 | HARD_REG_SET prefer_colors; | |
257 | ||
258 | /* Number of usable colors in usable_regs. */ | |
259 | int num_freedom; | |
260 | ||
261 | /* After successfull coloring the graph each web gets a new reg rtx, | |
262 | with which the original uses and defs are replaced. This is it. */ | |
263 | rtx reg_rtx; | |
264 | ||
265 | /* While spilling this is the rtx of the home of spilled webs. | |
266 | It can be a mem ref (a stack slot), or a pseudo register. */ | |
267 | rtx stack_slot; | |
268 | ||
269 | /* Used in rewrite_program2() to remember the using | |
270 | insn last seen for webs needing (re)loads. */ | |
271 | rtx last_use_insn; | |
272 | ||
273 | /* If this web is rematerializable, this contains the RTL pattern | |
274 | usable as source for that. Otherwise it's NULL. */ | |
275 | rtx pattern; | |
276 | ||
277 | /* All the defs and uses. There are num_defs, resp. | |
278 | num_uses elements. */ | |
279 | struct ref **defs; /* [0..num_defs-1] */ | |
280 | struct ref **uses; /* [0..num_uses-1] */ | |
281 | ||
282 | /* The web to which this web is aliased (coalesced). If NULL, this | |
283 | web is not coalesced into some other (but might still be a target | |
284 | for other webs). */ | |
285 | struct web *alias; | |
286 | ||
287 | /* With iterated coalescing this is a list of active moves this web | |
288 | is involved in. */ | |
289 | struct move_list *moves; | |
290 | ||
291 | /* The list implementation. */ | |
292 | struct dlist *dlink; | |
293 | ||
294 | /* While building webs, out of web-parts, this holds a (partial) | |
295 | list of all refs for this web seen so far. */ | |
296 | struct df_link *temp_refs; | |
297 | }; | |
298 | ||
299 | /* For implementing a single linked list. */ | |
300 | struct web_link | |
301 | { | |
302 | struct web_link *next; | |
303 | struct web *web; | |
304 | }; | |
305 | ||
09da1532 | 306 | /* A subconflict is part of a conflict edge to track precisely, |
ed8d2920 MM |
307 | which parts of two webs conflict, in case not all of both webs do. */ |
308 | struct sub_conflict | |
309 | { | |
310 | /* The next partial conflict. For one such list the parent-web of | |
311 | all the S webs, resp. the parent of all the T webs are constant. */ | |
312 | struct sub_conflict *next; | |
313 | struct web *s; | |
314 | struct web *t; | |
315 | }; | |
316 | ||
317 | /* This represents an edge in the conflict graph. */ | |
318 | struct conflict_link | |
319 | { | |
320 | struct conflict_link *next; | |
321 | ||
322 | /* The web we conflict with (the Target of the edge). */ | |
323 | struct web *t; | |
324 | ||
325 | /* If not the complete source web and T conflict, this points to | |
326 | the list of parts which really conflict. */ | |
327 | struct sub_conflict *sub; | |
328 | }; | |
329 | ||
330 | /* For iterated coalescing the moves can be in these states. */ | |
331 | enum move_type | |
332 | { | |
333 | WORKLIST, MV_COALESCED, CONSTRAINED, FROZEN, ACTIVE, | |
334 | LAST_MOVE_TYPE | |
335 | }; | |
336 | ||
337 | /* Structure of a move we are considering coalescing. */ | |
338 | struct move | |
339 | { | |
340 | rtx insn; | |
341 | struct web *source_web; | |
342 | struct web *target_web; | |
343 | enum move_type type; | |
344 | struct dlist *dlink; | |
345 | }; | |
346 | ||
347 | /* List of moves. */ | |
348 | struct move_list | |
349 | { | |
350 | struct move_list *next; | |
351 | struct move *move; | |
352 | }; | |
353 | ||
354 | /* To have fast access to the defs and uses per insn, we have one such | |
355 | structure per insn. The difference to the normal df.c structures is, | |
356 | that it doesn't contain any NULL refs, which df.c produces in case | |
357 | an insn was modified and it only contains refs to pseudo regs, or to | |
358 | hardregs which matter for allocation, i.e. those not in | |
359 | never_use_colors. */ | |
360 | struct ra_insn_info | |
361 | { | |
362 | unsigned int num_defs, num_uses; | |
363 | struct ref **defs, **uses; | |
364 | }; | |
365 | ||
366 | /* The above structures are stored in this array, indexed by UID... */ | |
367 | extern struct ra_insn_info *insn_df; | |
368 | /* ... and the size of that array, as we add insn after setting it up. */ | |
369 | extern int insn_df_max_uid; | |
370 | ||
371 | /* The interference graph. */ | |
372 | extern sbitmap igraph; | |
373 | /* And how to access it. I and J are web indices. If the bit | |
374 | igraph_index(I, J) is set, then they conflict. Note, that | |
375 | if only parts of webs conflict, then also only those parts | |
376 | are noted in the I-graph (i.e. the parent webs not). */ | |
377 | #define igraph_index(i, j) ((i) < (j) ? ((j)*((j)-1)/2)+(i) : ((i)*((i)-1)/2)+(j)) | |
378 | /* This is the bitmap of all (even partly) conflicting super webs. | |
379 | If bit I*num_webs+J or J*num_webs+I is set, then I and J (both being | |
380 | super web indices) conflict, maybe only partially. Note the | |
d55d8fc7 | 381 | asymmetry. */ |
ed8d2920 MM |
382 | extern sbitmap sup_igraph; |
383 | ||
384 | /* After the first pass, and when interference region spilling is | |
385 | activated, bit I is set, when the insn with UID I contains some | |
386 | refs to pseudos which die at the insn. */ | |
387 | extern sbitmap insns_with_deaths; | |
388 | /* The size of that sbitmap. */ | |
389 | extern int death_insns_max_uid; | |
390 | ||
391 | /* All the web-parts. There are exactly as many web-parts as there | |
392 | are register refs in the insn stream. */ | |
393 | extern struct web_part *web_parts; | |
394 | ||
395 | /* The number of all webs, including subwebs. */ | |
396 | extern unsigned int num_webs; | |
397 | /* The number of just the subwebs. */ | |
398 | extern unsigned int num_subwebs; | |
399 | /* The number of all webs, including subwebs. */ | |
400 | extern unsigned int num_allwebs; | |
401 | ||
402 | /* For easy access when given a web ID: id2web[W->id] == W. */ | |
403 | extern struct web **id2web; | |
404 | /* For each hardreg, the web which represents it. */ | |
405 | extern struct web *hardreg2web[FIRST_PSEUDO_REGISTER]; | |
406 | ||
407 | /* Given the ID of a df_ref, which represent a DEF, def2web[ID] is | |
408 | the web, to which this def belongs. */ | |
409 | extern struct web **def2web; | |
410 | /* The same as def2web, just for uses. */ | |
411 | extern struct web **use2web; | |
412 | ||
413 | /* The list of all recognized and coalescable move insns. */ | |
414 | extern struct move_list *wl_moves; | |
415 | ||
416 | ||
417 | /* Some parts of the compiler which we run after colorizing | |
418 | clean reg_renumber[], so we need another place for the colors. | |
419 | This is copied to reg_renumber[] just before returning to toplev. */ | |
420 | extern short *ra_reg_renumber; | |
421 | /* The size of that array. Some passes after coloring might have created | |
422 | new pseudos, which will get no color. */ | |
423 | extern int ra_max_regno; | |
424 | ||
425 | /* The dataflow structure of the current function, while regalloc | |
426 | runs. */ | |
427 | extern struct df *df; | |
428 | ||
429 | /* For each basic block B we have a bitmap of DF_REF_ID's of uses, | |
430 | which backward reach the end of B. */ | |
431 | extern bitmap *live_at_end; | |
432 | ||
d55d8fc7 | 433 | /* One pass is: collecting registers refs, building I-graph, spilling. |
ed8d2920 MM |
434 | And this is how often we already ran that for the current function. */ |
435 | extern int ra_pass; | |
436 | ||
437 | /* The maximum pseudo regno, just before register allocation starts. | |
438 | While regalloc runs all pseudos with a larger number represent | |
439 | potentially stack slots or hardregs. I call them stackwebs or | |
440 | stackpseudos. */ | |
441 | extern unsigned int max_normal_pseudo; | |
442 | ||
443 | /* One of the fixed colors. It must be < FIRST_PSEUDO_REGISTER, because | |
444 | we sometimes want to check the color against a HARD_REG_SET. It must | |
445 | be >= 0, because negative values mean "no color". | |
446 | This color is used for the above stackwebs, when they can't be colored. | |
447 | I.e. normally they would be spilled, but they already represent | |
448 | stackslots. So they are colored with an invalid color. It has | |
449 | the property that even webs which conflict can have that color at the | |
450 | same time. I.e. a stackweb with that color really represents a | |
451 | stackslot. */ | |
452 | extern int an_unusable_color; | |
453 | ||
454 | /* While building the I-graph, every time insn UID is looked at, | |
455 | number_seen[UID] is incremented. For debugging. */ | |
456 | extern int *number_seen; | |
457 | ||
458 | /* The different lists on which a web can be (based on the type). */ | |
459 | extern struct dlist *web_lists[(int) LAST_NODE_TYPE]; | |
460 | #define WEBS(type) (web_lists[(int)(type)]) | |
461 | ||
462 | /* The largest DF_REF_ID of defs resp. uses, as it was in the | |
463 | last pass. In the first pass this is zero. Used to distinguish new | |
464 | from old refrences. */ | |
465 | extern unsigned int last_def_id; | |
466 | extern unsigned int last_use_id; | |
467 | ||
468 | /* Similar for UIDs and number of webs. */ | |
469 | extern int last_max_uid; | |
470 | extern unsigned int last_num_webs; | |
471 | ||
472 | /* If I is the ID of an old use, and last_check_uses[I] is set, | |
473 | then we must reevaluate it's flow while building the new I-graph. */ | |
474 | extern sbitmap last_check_uses; | |
475 | ||
476 | /* If nonzero, record_conflict() saves the current conflict list of | |
477 | webs in orig_conflict_list, when not already done so, and the conflict | |
478 | list is going to be changed. It is set, after initially building the | |
479 | I-graph. I.e. new conflicts due to coalescing trigger that copying. */ | |
480 | extern unsigned int remember_conflicts; | |
481 | ||
482 | /* The maximum UID right before calling regalloc(). | |
483 | Used to detect any instructions inserted by the allocator. */ | |
484 | extern int orig_max_uid; | |
485 | ||
486 | /* A HARD_REG_SET of those color, which can't be used for coalescing. | |
487 | Includes e.g. fixed_regs. */ | |
488 | extern HARD_REG_SET never_use_colors; | |
489 | /* For each class C this is reg_class_contents[C] \ never_use_colors. */ | |
490 | extern HARD_REG_SET usable_regs[N_REG_CLASSES]; | |
491 | /* For each class C the count of hardregs in usable_regs[C]. */ | |
492 | extern unsigned int num_free_regs[N_REG_CLASSES]; | |
493 | /* For each mode M the hardregs, which are MODE_OK for M, and have | |
d55d8fc7 | 494 | enough space behind them to hold an M value. Additionally |
ed8d2920 MM |
495 | if reg R is OK for mode M, but it needs two hardregs, then R+1 will |
496 | also be set here, even if R+1 itself is not OK for M. I.e. this | |
497 | represent the possible resources which could be taken away be a value | |
498 | in mode M. */ | |
499 | extern HARD_REG_SET hardregs_for_mode[NUM_MACHINE_MODES]; | |
500 | /* For 0 <= I <= 255, the number of bits set in I. Used to calculate | |
501 | the number of set bits in a HARD_REG_SET. */ | |
502 | extern unsigned char byte2bitcount[256]; | |
503 | ||
504 | /* Expressive helper macros. */ | |
505 | #define ID2WEB(I) id2web[I] | |
506 | #define NUM_REGS(W) (((W)->type == PRECOLORED) ? 1 : (W)->num_freedom) | |
507 | #define SUBWEB_P(W) (GET_CODE ((W)->orig_x) == SUBREG) | |
508 | ||
509 | /* Constant usable as debug area to ra_debug_msg. */ | |
510 | #define DUMP_COSTS 0x0001 | |
511 | #define DUMP_WEBS 0x0002 | |
512 | #define DUMP_IGRAPH 0x0004 | |
513 | #define DUMP_PROCESS 0x0008 | |
514 | #define DUMP_COLORIZE 0x0010 | |
515 | #define DUMP_ASM 0x0020 | |
516 | #define DUMP_CONSTRAINTS 0x0040 | |
517 | #define DUMP_RESULTS 0x0080 | |
518 | #define DUMP_DF 0x0100 | |
519 | #define DUMP_RTL 0x0200 | |
520 | #define DUMP_FINAL_RTL 0x0400 | |
521 | #define DUMP_REGCLASS 0x0800 | |
522 | #define DUMP_SM 0x1000 | |
523 | #define DUMP_LAST_FLOW 0x2000 | |
524 | #define DUMP_LAST_RTL 0x4000 | |
525 | #define DUMP_REBUILD 0x8000 | |
526 | #define DUMP_IGRAPH_M 0x10000 | |
527 | #define DUMP_VALIDIFY 0x20000 | |
528 | #define DUMP_EVER ((unsigned int)-1) | |
529 | #define DUMP_NEARLY_EVER (DUMP_EVER - DUMP_COSTS - DUMP_IGRAPH_M) | |
530 | ||
531 | /* All the wanted debug levels as ORing of the various DUMP_xxx | |
532 | constants. */ | |
533 | extern unsigned int debug_new_regalloc; | |
534 | ||
535 | /* Nonzero means we want biased coloring. */ | |
536 | extern int flag_ra_biased; | |
537 | ||
538 | /* Nonzero if we want to use improved (and slow) spilling. This | |
539 | includes also interference region spilling (see below). */ | |
540 | extern int flag_ra_improved_spilling; | |
541 | ||
542 | /* Nonzero for using interference region spilling. Zero for improved | |
543 | Chaintin style spilling (only at deaths). */ | |
544 | extern int flag_ra_ir_spilling; | |
545 | ||
546 | /* Nonzero if we use optimistic coalescing, zero for iterated | |
547 | coalescing. */ | |
548 | extern int flag_ra_optimistic_coalescing; | |
549 | ||
550 | /* Nonzero if we want to break aliases of spilled webs. Forced to | |
551 | nonzero, when flag_ra_optimistic_coalescing is. */ | |
552 | extern int flag_ra_break_aliases; | |
553 | ||
554 | /* Nonzero if we want to merge the spill costs of webs which | |
555 | are coalesced. */ | |
556 | extern int flag_ra_merge_spill_costs; | |
557 | ||
558 | /* Nonzero if we want to spill at every use, instead of at deaths, | |
559 | or intereference region borders. */ | |
560 | extern int flag_ra_spill_every_use; | |
561 | ||
562 | /* Nonzero to output all notes in the debug dumps. */ | |
563 | extern int flag_ra_dump_notes; | |
564 | ||
565 | extern inline void * ra_alloc PARAMS ((size_t)); | |
566 | extern inline void * ra_calloc PARAMS ((size_t)); | |
567 | extern int hard_regs_count PARAMS ((HARD_REG_SET)); | |
568 | extern rtx ra_emit_move_insn PARAMS ((rtx, rtx)); | |
569 | extern void ra_debug_msg PARAMS ((unsigned int, | |
570 | const char *, ...)) ATTRIBUTE_PRINTF_2; | |
571 | extern int hard_regs_intersect_p PARAMS ((HARD_REG_SET *, HARD_REG_SET *)); | |
572 | extern unsigned int rtx_to_bits PARAMS ((rtx)); | |
573 | extern struct web * find_subweb PARAMS ((struct web *, rtx)); | |
574 | extern struct web * find_subweb_2 PARAMS ((struct web *, unsigned int)); | |
575 | extern struct web * find_web_for_subweb_1 PARAMS ((struct web *)); | |
576 | ||
577 | #define find_web_for_subweb(w) (((w)->parent_web) \ | |
578 | ? find_web_for_subweb_1 ((w)->parent_web) \ | |
579 | : (w)) | |
580 | ||
581 | extern void ra_build_realloc PARAMS ((struct df *)); | |
582 | extern void ra_build_free PARAMS ((void)); | |
583 | extern void ra_build_free_all PARAMS ((struct df *)); | |
584 | extern void ra_colorize_init PARAMS ((void)); | |
585 | extern void ra_colorize_free_all PARAMS ((void)); | |
586 | extern void ra_rewrite_init PARAMS ((void)); | |
587 | ||
588 | extern void ra_print_rtx PARAMS ((FILE *, rtx, int)); | |
589 | extern void ra_print_rtx_top PARAMS ((FILE *, rtx, int)); | |
590 | extern void ra_debug_rtx PARAMS ((rtx)); | |
591 | extern void ra_debug_insns PARAMS ((rtx, int)); | |
592 | extern void ra_debug_bbi PARAMS ((int)); | |
593 | extern void ra_print_rtl_with_bb PARAMS ((FILE *, rtx)); | |
594 | extern void dump_igraph PARAMS ((struct df *)); | |
595 | extern void dump_igraph_machine PARAMS ((void)); | |
596 | extern void dump_constraints PARAMS ((void)); | |
597 | extern void dump_cost PARAMS ((unsigned int)); | |
598 | extern void dump_graph_cost PARAMS ((unsigned int, const char *)); | |
599 | extern void dump_ra PARAMS ((struct df *)); | |
600 | extern void dump_number_seen PARAMS ((void)); | |
601 | extern void dump_static_insn_cost PARAMS ((FILE *, const char *, | |
602 | const char *)); | |
603 | extern void dump_web_conflicts PARAMS ((struct web *)); | |
604 | extern void dump_web_insns PARAMS ((struct web*)); | |
605 | extern int web_conflicts_p PARAMS ((struct web *, struct web *)); | |
606 | extern void debug_hard_reg_set PARAMS ((HARD_REG_SET)); | |
607 | ||
608 | extern void remove_list PARAMS ((struct dlist *, struct dlist **)); | |
609 | extern struct dlist * pop_list PARAMS ((struct dlist **)); | |
610 | extern void record_conflict PARAMS ((struct web *, struct web *)); | |
611 | extern int memref_is_stack_slot PARAMS ((rtx)); | |
612 | extern void build_i_graph PARAMS ((struct df *)); | |
613 | extern void put_web PARAMS ((struct web *, enum node_type)); | |
614 | extern void remove_web_from_list PARAMS ((struct web *)); | |
615 | extern void reset_lists PARAMS ((void)); | |
616 | extern struct web * alias PARAMS ((struct web *)); | |
617 | extern void merge_moves PARAMS ((struct web *, struct web *)); | |
618 | extern void ra_colorize_graph PARAMS ((struct df *)); | |
619 | ||
620 | extern void actual_spill PARAMS ((void)); | |
621 | extern void emit_colors PARAMS ((struct df *)); | |
622 | extern void delete_moves PARAMS ((void)); | |
623 | extern void setup_renumber PARAMS ((int)); | |
624 | extern void remove_suspicious_death_notes PARAMS ((void)); |