* ira-int.h (struct ira_loop_tree_node): Improve comments for
[official-gcc.git] / gcc / ira-int.h
blob0b2e9280388c2b3116fd69fb034cbf07e7d34cb9
1 /* Integrated Register Allocator (IRA) intercommunication header file.
2 Copyright (C) 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Vladimir Makarov <vmakarov@redhat.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "cfgloop.h"
23 #include "ira.h"
24 #include "alloc-pool.h"
26 /* To provide consistency in naming, all IRA external variables,
27 functions, common typedefs start with prefix ira_. */
29 #ifdef ENABLE_CHECKING
30 #define ENABLE_IRA_CHECKING
31 #endif
33 #ifdef ENABLE_IRA_CHECKING
34 #define ira_assert(c) gcc_assert (c)
35 #else
36 #define ira_assert(c)
37 #endif
39 /* Compute register frequency from edge frequency FREQ. It is
40 analogous to REG_FREQ_FROM_BB. When optimizing for size, or
41 profile driven feedback is available and the function is never
42 executed, frequency is always equivalent. Otherwise rescale the
43 edge frequency. */
44 #define REG_FREQ_FROM_EDGE_FREQ(freq) \
45 (optimize_size || (flag_branch_probabilities && !ENTRY_BLOCK_PTR->count) \
46 ? REG_FREQ_MAX : (freq * REG_FREQ_MAX / BB_FREQ_MAX) \
47 ? (freq * REG_FREQ_MAX / BB_FREQ_MAX) : 1)
49 /* All natural loops. */
50 extern struct loops ira_loops;
52 /* A modified value of flag `-fira-verbose' used internally. */
53 extern int internal_flag_ira_verbose;
55 /* Dump file of the allocator if it is not NULL. */
56 extern FILE *ira_dump_file;
58 /* Typedefs for pointers to allocno live range, allocno, and copy of
59 allocnos. */
60 typedef struct ira_allocno_live_range *allocno_live_range_t;
61 typedef struct ira_allocno *ira_allocno_t;
62 typedef struct ira_allocno_copy *ira_copy_t;
64 /* Definition of vector of allocnos and copies. */
65 DEF_VEC_P(ira_allocno_t);
66 DEF_VEC_ALLOC_P(ira_allocno_t, heap);
67 DEF_VEC_P(ira_copy_t);
68 DEF_VEC_ALLOC_P(ira_copy_t, heap);
70 /* Typedef for pointer to the subsequent structure. */
71 typedef struct ira_loop_tree_node *ira_loop_tree_node_t;
73 /* In general case, IRA is a regional allocator. The regions are
74 nested and form a tree. Currently regions are natural loops. The
75 following structure describes loop tree node (representing basic
76 block or loop). We need such tree because the loop tree from
77 cfgloop.h is not convenient for the optimization: basic blocks are
78 not a part of the tree from cfgloop.h. We also use the nodes for
79 storing additional information about basic blocks/loops for the
80 register allocation purposes. */
81 struct ira_loop_tree_node
83 /* The node represents basic block if children == NULL. */
84 basic_block bb; /* NULL for loop. */
85 struct loop *loop; /* NULL for BB. */
86 /* NEXT/SUBLOOP_NEXT is the next node/loop-node of the same parent.
87 SUBLOOP_NEXT is always NULL for BBs. */
88 ira_loop_tree_node_t subloop_next, next;
89 /* CHILDREN/SUBLOOPS is the first node/loop-node immediately inside
90 the node. They are NULL for BBs. */
91 ira_loop_tree_node_t subloops, children;
92 /* The node immediately containing given node. */
93 ira_loop_tree_node_t parent;
95 /* Loop level in range [0, ira_loop_tree_height). */
96 int level;
98 /* All the following members are defined only for nodes representing
99 loops. */
101 /* Allocnos in the loop corresponding to their regnos. If it is
102 NULL the loop does not form a separate register allocation region
103 (e.g. because it has abnormal enter/exit edges and we can not put
104 code for register shuffling on the edges if a different
105 allocation is used for a pseudo-register on different sides of
106 the edges). Caps are not in the map (remember we can have more
107 one cap with the same regno in a region). */
108 ira_allocno_t *regno_allocno_map;
110 /* Maximal register pressure inside loop for given register class
111 (defined only for the cover classes). */
112 int reg_pressure[N_REG_CLASSES];
114 /* Numbers of allocnos referred or living in the loop node (except
115 for its subloops). */
116 bitmap all_allocnos;
118 /* Numbers of allocnos living at the loop borders. */
119 bitmap border_allocnos;
121 /* Regnos of pseudos modified in the loop node (including its
122 subloops). */
123 bitmap modified_regnos;
125 /* Numbers of copies referred in the corresponding loop. */
126 bitmap local_copies;
129 /* The root of the loop tree corresponding to the all function. */
130 extern ira_loop_tree_node_t ira_loop_tree_root;
132 /* Height of the loop tree. */
133 extern int ira_loop_tree_height;
135 /* All nodes representing basic blocks are referred through the
136 following array. We can not use basic block member `aux' for this
137 because it is used for insertion of insns on edges. */
138 extern ira_loop_tree_node_t ira_bb_nodes;
140 /* Two access macros to the nodes representing basic blocks. */
141 #if defined ENABLE_IRA_CHECKING && (GCC_VERSION >= 2007)
142 #define IRA_BB_NODE_BY_INDEX(index) __extension__ \
143 (({ ira_loop_tree_node_t _node = (&ira_bb_nodes[index]); \
144 if (_node->children != NULL || _node->loop != NULL || _node->bb == NULL)\
146 fprintf (stderr, \
147 "\n%s: %d: error in %s: it is not a block node\n", \
148 __FILE__, __LINE__, __FUNCTION__); \
149 gcc_unreachable (); \
151 _node; }))
152 #else
153 #define IRA_BB_NODE_BY_INDEX(index) (&ira_bb_nodes[index])
154 #endif
156 #define IRA_BB_NODE(bb) IRA_BB_NODE_BY_INDEX ((bb)->index)
158 /* All nodes representing loops are referred through the following
159 array. */
160 extern ira_loop_tree_node_t ira_loop_nodes;
162 /* Two access macros to the nodes representing loops. */
163 #if defined ENABLE_IRA_CHECKING && (GCC_VERSION >= 2007)
164 #define IRA_LOOP_NODE_BY_INDEX(index) __extension__ \
165 (({ ira_loop_tree_node_t const _node = (&ira_loop_nodes[index]);\
166 if (_node->children == NULL || _node->bb != NULL || _node->loop == NULL)\
168 fprintf (stderr, \
169 "\n%s: %d: error in %s: it is not a loop node\n", \
170 __FILE__, __LINE__, __FUNCTION__); \
171 gcc_unreachable (); \
173 _node; }))
174 #else
175 #define IRA_LOOP_NODE_BY_INDEX(index) (&ira_loop_nodes[index])
176 #endif
178 #define IRA_LOOP_NODE(loop) IRA_LOOP_NODE_BY_INDEX ((loop)->num)
182 /* The structure describes program points where a given allocno lives.
183 To save memory we store allocno conflicts only for the same cover
184 class allocnos which is enough to assign hard registers. To find
185 conflicts for other allocnos (e.g. to assign stack memory slot) we
186 use the live ranges. If the live ranges of two allocnos are
187 intersected, the allocnos are in conflict. */
188 struct ira_allocno_live_range
190 /* Allocno whose live range is described by given structure. */
191 ira_allocno_t allocno;
192 /* Program point range. */
193 int start, finish;
194 /* Next structure describing program points where the allocno
195 lives. */
196 allocno_live_range_t next;
197 /* Pointer to structures with the same start/finish. */
198 allocno_live_range_t start_next, finish_next;
201 /* Program points are enumerated by numbers from range
202 0..IRA_MAX_POINT-1. There are approximately two times more program
203 points than insns. Program points are places in the program where
204 liveness info can be changed. In most general case (there are more
205 complicated cases too) some program points correspond to places
206 where input operand dies and other ones correspond to places where
207 output operands are born. */
208 extern int ira_max_point;
210 /* Arrays of size IRA_MAX_POINT mapping a program point to the allocno
211 live ranges with given start/finish point. */
212 extern allocno_live_range_t *ira_start_point_ranges, *ira_finish_point_ranges;
214 /* A structure representing an allocno (allocation entity). Allocno
215 represents a pseudo-register in an allocation region. If
216 pseudo-register does not live in a region but it lives in the
217 nested regions, it is represented in the region by special allocno
218 called *cap*. There may be more one cap representing the same
219 pseudo-register in region. It means that the corresponding
220 pseudo-register lives in more one non-intersected subregion. */
221 struct ira_allocno
223 /* The allocno order number starting with 0. Each allocno has an
224 unique number and the number is never changed for the
225 allocno. */
226 int num;
227 /* Regno for allocno or cap. */
228 int regno;
229 /* Mode of the allocno which is the mode of the corresponding
230 pseudo-register. */
231 enum machine_mode mode;
232 /* Final rtx representation of the allocno. */
233 rtx reg;
234 /* Hard register assigned to given allocno. Negative value means
235 that memory was allocated to the allocno. During the reload,
236 spilled allocno has value equal to the corresponding stack slot
237 number (0, ...) - 2. Value -1 is used for allocnos spilled by the
238 reload (at this point pseudo-register has only one allocno) which
239 did not get stack slot yet. */
240 int hard_regno;
241 /* Allocnos with the same regno are linked by the following member.
242 Allocnos corresponding to inner loops are first in the list (it
243 corresponds to depth-first traverse of the loops). */
244 ira_allocno_t next_regno_allocno;
245 /* There may be different allocnos with the same regno in different
246 regions. Allocnos are bound to the corresponding loop tree node.
247 Pseudo-register may have only one regular allocno with given loop
248 tree node but more than one cap (see comments above). */
249 ira_loop_tree_node_t loop_tree_node;
250 /* Accumulated usage references of the allocno. Here and below,
251 word 'accumulated' means info for given region and all nested
252 subregions. In this case, 'accumulated' means sum of references
253 of the corresponding pseudo-register in this region and in all
254 nested subregions recursively. */
255 int nrefs;
256 /* Accumulated frequency of usage of the allocno. */
257 int freq;
258 /* Register class which should be used for allocation for given
259 allocno. NO_REGS means that we should use memory. */
260 enum reg_class cover_class;
261 /* Minimal accumulated and updated costs of usage register of the
262 cover class for the allocno. */
263 int cover_class_cost, updated_cover_class_cost;
264 /* Minimal accumulated, and updated costs of memory for the allocno.
265 At the allocation start, the original and updated costs are
266 equal. The updated cost may be changed after finishing
267 allocation in a region and starting allocation in a subregion.
268 The change reflects the cost of spill/restore code on the
269 subregion border if we assign memory to the pseudo in the
270 subregion. */
271 int memory_cost, updated_memory_cost;
272 /* Accumulated number of points where the allocno lives and there is
273 excess pressure for its class. Excess pressure for a register
274 class at some point means that there are more allocnos of given
275 register class living at the point than number of hard-registers
276 of the class available for the allocation. */
277 int excess_pressure_points_num;
278 /* Copies to other non-conflicting allocnos. The copies can
279 represent move insn or potential move insn usually because of two
280 operand insn constraints. */
281 ira_copy_t allocno_copies;
282 /* It is a allocno (cap) representing given allocno on upper loop tree
283 level. */
284 ira_allocno_t cap;
285 /* It is a link to allocno (cap) on lower loop level represented by
286 given cap. Null if given allocno is not a cap. */
287 ira_allocno_t cap_member;
288 /* Coalesced allocnos form a cyclic list. One allocno given by
289 FIRST_COALESCED_ALLOCNO represents all coalesced allocnos. The
290 list is chained by NEXT_COALESCED_ALLOCNO. */
291 ira_allocno_t first_coalesced_allocno;
292 ira_allocno_t next_coalesced_allocno;
293 /* Pointer to structures describing at what program point the
294 allocno lives. We always maintain the list in such way that *the
295 ranges in the list are not intersected and ordered by decreasing
296 their program points*. */
297 allocno_live_range_t live_ranges;
298 /* Before building conflicts the two member values are
299 correspondingly minimal and maximal points of the accumulated
300 allocno live ranges. After building conflicts the values are
301 correspondingly minimal and maximal conflict ids of allocnos with
302 which given allocno can conflict. */
303 int min, max;
304 /* The unique member value represents given allocno in conflict bit
305 vectors. */
306 int conflict_id;
307 /* Vector of accumulated conflicting allocnos with NULL end marker
308 (if CONFLICT_VEC_P is true) or conflict bit vector otherwise.
309 Only allocnos with the same cover class are in the vector or in
310 the bit vector. */
311 void *conflict_allocno_array;
312 /* Allocated size of the previous array. */
313 unsigned int conflict_allocno_array_size;
314 /* Number of accumulated conflicts in the vector of conflicting
315 allocnos. */
316 int conflict_allocnos_num;
317 /* Initial and accumulated hard registers conflicting with this
318 allocno and as a consequences can not be assigned to the allocno.
319 All non-allocatable hard regs and hard regs of cover classes
320 different from given allocno one are included in the sets. */
321 HARD_REG_SET conflict_hard_regs, total_conflict_hard_regs;
322 /* Accumulated frequency of calls which given allocno
323 intersects. */
324 int call_freq;
325 /* Length of the previous array (number of the intersected calls). */
326 int calls_crossed_num;
327 /* Non NULL if we remove restoring value from given allocno to
328 MEM_OPTIMIZED_DEST at loop exit (see ira-emit.c) because the
329 allocno value is not changed inside the loop. */
330 ira_allocno_t mem_optimized_dest;
331 /* TRUE if the allocno assigned to memory was a destination of
332 removed move (see ira-emit.c) at loop exit because the value of
333 the corresponding pseudo-register is not changed inside the
334 loop. */
335 unsigned int mem_optimized_dest_p : 1;
336 /* TRUE if the corresponding pseudo-register has disjoint live
337 ranges and the other allocnos of the pseudo-register except this
338 one changed REG. */
339 unsigned int somewhere_renamed_p : 1;
340 /* TRUE if allocno with the same REGNO in a subregion has been
341 renamed, in other words, got a new pseudo-register. */
342 unsigned int child_renamed_p : 1;
343 /* During the reload, value TRUE means that we should not reassign a
344 hard register to the allocno got memory earlier. It is set up
345 when we removed memory-memory move insn before each iteration of
346 the reload. */
347 unsigned int dont_reassign_p : 1;
348 #ifdef STACK_REGS
349 /* Set to TRUE if allocno can't be assigned to the stack hard
350 register correspondingly in this region and area including the
351 region and all its subregions recursively. */
352 unsigned int no_stack_reg_p : 1, total_no_stack_reg_p : 1;
353 #endif
354 /* TRUE value means that there is no sense to spill the allocno
355 during coloring because the spill will result in additional
356 reloads in reload pass. */
357 unsigned int bad_spill_p : 1;
358 /* TRUE value means that the allocno was not removed yet from the
359 conflicting graph during colouring. */
360 unsigned int in_graph_p : 1;
361 /* TRUE if a hard register or memory has been assigned to the
362 allocno. */
363 unsigned int assigned_p : 1;
364 /* TRUE if it is put on the stack to make other allocnos
365 colorable. */
366 unsigned int may_be_spilled_p : 1;
367 /* TRUE if the allocno was removed from the splay tree used to
368 choose allocn for spilling (see ira-color.c::. */
369 unsigned int splay_removed_p : 1;
370 /* TRUE if conflicts for given allocno are represented by vector of
371 pointers to the conflicting allocnos. Otherwise, we use a bit
372 vector where a bit with given index represents allocno with the
373 same number. */
374 unsigned int conflict_vec_p : 1;
375 /* Array of usage costs (accumulated and the one updated during
376 coloring) for each hard register of the allocno cover class. The
377 member value can be NULL if all costs are the same and equal to
378 COVER_CLASS_COST. For example, the costs of two different hard
379 registers can be different if one hard register is callee-saved
380 and another one is callee-used and the allocno lives through
381 calls. Another example can be case when for some insn the
382 corresponding pseudo-register value should be put in specific
383 register class (e.g. AREG for x86) which is a strict subset of
384 the allocno cover class (GENERAL_REGS for x86). We have updated
385 costs to reflect the situation when the usage cost of a hard
386 register is decreased because the allocno is connected to another
387 allocno by a copy and the another allocno has been assigned to
388 the hard register. */
389 int *hard_reg_costs, *updated_hard_reg_costs;
390 /* Array of decreasing costs (accumulated and the one updated during
391 coloring) for allocnos conflicting with given allocno for hard
392 regno of the allocno cover class. The member value can be NULL
393 if all costs are the same. These costs are used to reflect
394 preferences of other allocnos not assigned yet during assigning
395 to given allocno. */
396 int *conflict_hard_reg_costs, *updated_conflict_hard_reg_costs;
397 /* Number of the same cover class allocnos with TRUE in_graph_p
398 value and conflicting with given allocno during each point of
399 graph coloring. */
400 int left_conflicts_num;
401 /* Number of hard registers of the allocno cover class really
402 available for the allocno allocation. */
403 int available_regs_num;
404 /* Allocnos in a bucket (used in coloring) chained by the following
405 two members. */
406 ira_allocno_t next_bucket_allocno;
407 ira_allocno_t prev_bucket_allocno;
408 /* Used for temporary purposes. */
409 int temp;
412 /* All members of the allocno structures should be accessed only
413 through the following macros. */
414 #define ALLOCNO_NUM(A) ((A)->num)
415 #define ALLOCNO_REGNO(A) ((A)->regno)
416 #define ALLOCNO_REG(A) ((A)->reg)
417 #define ALLOCNO_NEXT_REGNO_ALLOCNO(A) ((A)->next_regno_allocno)
418 #define ALLOCNO_LOOP_TREE_NODE(A) ((A)->loop_tree_node)
419 #define ALLOCNO_CAP(A) ((A)->cap)
420 #define ALLOCNO_CAP_MEMBER(A) ((A)->cap_member)
421 #define ALLOCNO_CONFLICT_ALLOCNO_ARRAY(A) ((A)->conflict_allocno_array)
422 #define ALLOCNO_CONFLICT_ALLOCNO_ARRAY_SIZE(A) \
423 ((A)->conflict_allocno_array_size)
424 #define ALLOCNO_CONFLICT_ALLOCNOS_NUM(A) \
425 ((A)->conflict_allocnos_num)
426 #define ALLOCNO_CONFLICT_HARD_REGS(A) ((A)->conflict_hard_regs)
427 #define ALLOCNO_TOTAL_CONFLICT_HARD_REGS(A) ((A)->total_conflict_hard_regs)
428 #define ALLOCNO_NREFS(A) ((A)->nrefs)
429 #define ALLOCNO_FREQ(A) ((A)->freq)
430 #define ALLOCNO_HARD_REGNO(A) ((A)->hard_regno)
431 #define ALLOCNO_CALL_FREQ(A) ((A)->call_freq)
432 #define ALLOCNO_CALLS_CROSSED_NUM(A) ((A)->calls_crossed_num)
433 #define ALLOCNO_MEM_OPTIMIZED_DEST(A) ((A)->mem_optimized_dest)
434 #define ALLOCNO_MEM_OPTIMIZED_DEST_P(A) ((A)->mem_optimized_dest_p)
435 #define ALLOCNO_SOMEWHERE_RENAMED_P(A) ((A)->somewhere_renamed_p)
436 #define ALLOCNO_CHILD_RENAMED_P(A) ((A)->child_renamed_p)
437 #define ALLOCNO_DONT_REASSIGN_P(A) ((A)->dont_reassign_p)
438 #ifdef STACK_REGS
439 #define ALLOCNO_NO_STACK_REG_P(A) ((A)->no_stack_reg_p)
440 #define ALLOCNO_TOTAL_NO_STACK_REG_P(A) ((A)->total_no_stack_reg_p)
441 #endif
442 #define ALLOCNO_BAD_SPILL_P(A) ((A)->bad_spill_p)
443 #define ALLOCNO_IN_GRAPH_P(A) ((A)->in_graph_p)
444 #define ALLOCNO_ASSIGNED_P(A) ((A)->assigned_p)
445 #define ALLOCNO_MAY_BE_SPILLED_P(A) ((A)->may_be_spilled_p)
446 #define ALLOCNO_SPLAY_REMOVED_P(A) ((A)->splay_removed_p)
447 #define ALLOCNO_CONFLICT_VEC_P(A) ((A)->conflict_vec_p)
448 #define ALLOCNO_MODE(A) ((A)->mode)
449 #define ALLOCNO_COPIES(A) ((A)->allocno_copies)
450 #define ALLOCNO_HARD_REG_COSTS(A) ((A)->hard_reg_costs)
451 #define ALLOCNO_UPDATED_HARD_REG_COSTS(A) ((A)->updated_hard_reg_costs)
452 #define ALLOCNO_CONFLICT_HARD_REG_COSTS(A) \
453 ((A)->conflict_hard_reg_costs)
454 #define ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS(A) \
455 ((A)->updated_conflict_hard_reg_costs)
456 #define ALLOCNO_LEFT_CONFLICTS_NUM(A) ((A)->left_conflicts_num)
457 #define ALLOCNO_COVER_CLASS(A) ((A)->cover_class)
458 #define ALLOCNO_COVER_CLASS_COST(A) ((A)->cover_class_cost)
459 #define ALLOCNO_UPDATED_COVER_CLASS_COST(A) ((A)->updated_cover_class_cost)
460 #define ALLOCNO_MEMORY_COST(A) ((A)->memory_cost)
461 #define ALLOCNO_UPDATED_MEMORY_COST(A) ((A)->updated_memory_cost)
462 #define ALLOCNO_EXCESS_PRESSURE_POINTS_NUM(A) ((A)->excess_pressure_points_num)
463 #define ALLOCNO_AVAILABLE_REGS_NUM(A) ((A)->available_regs_num)
464 #define ALLOCNO_NEXT_BUCKET_ALLOCNO(A) ((A)->next_bucket_allocno)
465 #define ALLOCNO_PREV_BUCKET_ALLOCNO(A) ((A)->prev_bucket_allocno)
466 #define ALLOCNO_TEMP(A) ((A)->temp)
467 #define ALLOCNO_FIRST_COALESCED_ALLOCNO(A) ((A)->first_coalesced_allocno)
468 #define ALLOCNO_NEXT_COALESCED_ALLOCNO(A) ((A)->next_coalesced_allocno)
469 #define ALLOCNO_LIVE_RANGES(A) ((A)->live_ranges)
470 #define ALLOCNO_MIN(A) ((A)->min)
471 #define ALLOCNO_MAX(A) ((A)->max)
472 #define ALLOCNO_CONFLICT_ID(A) ((A)->conflict_id)
474 /* Map regno -> allocnos with given regno (see comments for
475 allocno member `next_regno_allocno'). */
476 extern ira_allocno_t *ira_regno_allocno_map;
478 /* Array of references to all allocnos. The order number of the
479 allocno corresponds to the index in the array. Removed allocnos
480 have NULL element value. */
481 extern ira_allocno_t *ira_allocnos;
483 /* Sizes of the previous array. */
484 extern int ira_allocnos_num;
486 /* Map conflict id -> allocno with given conflict id (see comments for
487 allocno member `conflict_id'). */
488 extern ira_allocno_t *ira_conflict_id_allocno_map;
490 /* The following structure represents a copy of two allocnos. The
491 copies represent move insns or potential move insns usually because
492 of two operand insn constraints. To remove register shuffle, we
493 also create copies between allocno which is output of an insn and
494 allocno becoming dead in the insn. */
495 struct ira_allocno_copy
497 /* The unique order number of the copy node starting with 0. */
498 int num;
499 /* Allocnos connected by the copy. The first allocno should have
500 smaller order number than the second one. */
501 ira_allocno_t first, second;
502 /* Execution frequency of the copy. */
503 int freq;
504 bool constraint_p;
505 /* It is a move insn which is an origin of the copy. The member
506 value for the copy representing two operand insn constraints or
507 for the copy created to remove register shuffle is NULL. In last
508 case the copy frequency is smaller than the corresponding insn
509 execution frequency. */
510 rtx insn;
511 /* All copies with the same allocno as FIRST are linked by the two
512 following members. */
513 ira_copy_t prev_first_allocno_copy, next_first_allocno_copy;
514 /* All copies with the same allocno as SECOND are linked by the two
515 following members. */
516 ira_copy_t prev_second_allocno_copy, next_second_allocno_copy;
517 /* Region from which given copy is originated. */
518 ira_loop_tree_node_t loop_tree_node;
521 /* Array of references to all copies. The order number of the copy
522 corresponds to the index in the array. Removed copies have NULL
523 element value. */
524 extern ira_copy_t *ira_copies;
526 /* Size of the previous array. */
527 extern int ira_copies_num;
529 /* The following structure describes a stack slot used for spilled
530 pseudo-registers. */
531 struct ira_spilled_reg_stack_slot
533 /* pseudo-registers assigned to the stack slot. */
534 regset_head spilled_regs;
535 /* RTL representation of the stack slot. */
536 rtx mem;
537 /* Size of the stack slot. */
538 unsigned int width;
541 /* The number of elements in the following array. */
542 extern int ira_spilled_reg_stack_slots_num;
544 /* The following array contains info about spilled pseudo-registers
545 stack slots used in current function so far. */
546 extern struct ira_spilled_reg_stack_slot *ira_spilled_reg_stack_slots;
548 /* Correspondingly overall cost of the allocation, cost of the
549 allocnos assigned to hard-registers, cost of the allocnos assigned
550 to memory, cost of loads, stores and register move insns generated
551 for pseudo-register live range splitting (see ira-emit.c). */
552 extern int ira_overall_cost;
553 extern int ira_reg_cost, ira_mem_cost;
554 extern int ira_load_cost, ira_store_cost, ira_shuffle_cost;
555 extern int ira_move_loops_num, ira_additional_jumps_num;
557 /* Map: hard register number -> cover class it belongs to. If the
558 corresponding class is NO_REGS, the hard register is not available
559 for allocation. */
560 extern enum reg_class ira_hard_regno_cover_class[FIRST_PSEUDO_REGISTER];
562 /* Map: register class x machine mode -> number of hard registers of
563 given class needed to store value of given mode. If the number for
564 some hard-registers of the register class is different, the size
565 will be negative. */
566 extern int ira_reg_class_nregs[N_REG_CLASSES][MAX_MACHINE_MODE];
568 /* Maximal value of the previous array elements. */
569 extern int ira_max_nregs;
571 /* The number of bits in each element of array used to implement a bit
572 vector of allocnos and what type that element has. We use the
573 largest integer format on the host machine. */
574 #define IRA_INT_BITS HOST_BITS_PER_WIDE_INT
575 #define IRA_INT_TYPE HOST_WIDE_INT
577 /* Set, clear or test bit number I in R, a bit vector of elements with
578 minimal index and maximal index equal correspondingly to MIN and
579 MAX. */
580 #if defined ENABLE_IRA_CHECKING && (GCC_VERSION >= 2007)
582 #define SET_ALLOCNO_SET_BIT(R, I, MIN, MAX) __extension__ \
583 (({ int _min = (MIN), _max = (MAX), _i = (I); \
584 if (_i < _min || _i > _max) \
586 fprintf (stderr, \
587 "\n%s: %d: error in %s: %d not in range [%d,%d]\n", \
588 __FILE__, __LINE__, __FUNCTION__, _i, _min, _max); \
589 gcc_unreachable (); \
591 ((R)[(unsigned) (_i - _min) / IRA_INT_BITS] \
592 |= ((IRA_INT_TYPE) 1 << ((unsigned) (_i - _min) % IRA_INT_BITS))); }))
595 #define CLEAR_ALLOCNO_SET_BIT(R, I, MIN, MAX) __extension__ \
596 (({ int _min = (MIN), _max = (MAX), _i = (I); \
597 if (_i < _min || _i > _max) \
599 fprintf (stderr, \
600 "\n%s: %d: error in %s: %d not in range [%d,%d]\n", \
601 __FILE__, __LINE__, __FUNCTION__, _i, _min, _max); \
602 gcc_unreachable (); \
604 ((R)[(unsigned) (_i - _min) / IRA_INT_BITS] \
605 &= ~((IRA_INT_TYPE) 1 << ((unsigned) (_i - _min) % IRA_INT_BITS))); }))
607 #define TEST_ALLOCNO_SET_BIT(R, I, MIN, MAX) __extension__ \
608 (({ int _min = (MIN), _max = (MAX), _i = (I); \
609 if (_i < _min || _i > _max) \
611 fprintf (stderr, \
612 "\n%s: %d: error in %s: %d not in range [%d,%d]\n", \
613 __FILE__, __LINE__, __FUNCTION__, _i, _min, _max); \
614 gcc_unreachable (); \
616 ((R)[(unsigned) (_i - _min) / IRA_INT_BITS] \
617 & ((IRA_INT_TYPE) 1 << ((unsigned) (_i - _min) % IRA_INT_BITS))); }))
619 #else
621 #define SET_ALLOCNO_SET_BIT(R, I, MIN, MAX) \
622 ((R)[(unsigned) ((I) - (MIN)) / IRA_INT_BITS] \
623 |= ((IRA_INT_TYPE) 1 << ((unsigned) ((I) - (MIN)) % IRA_INT_BITS)))
625 #define CLEAR_ALLOCNO_SET_BIT(R, I, MIN, MAX) \
626 ((R)[(unsigned) ((I) - (MIN)) / IRA_INT_BITS] \
627 &= ~((IRA_INT_TYPE) 1 << ((unsigned) ((I) - (MIN)) % IRA_INT_BITS)))
629 #define TEST_ALLOCNO_SET_BIT(R, I, MIN, MAX) \
630 ((R)[(unsigned) ((I) - (MIN)) / IRA_INT_BITS] \
631 & ((IRA_INT_TYPE) 1 << ((unsigned) ((I) - (MIN)) % IRA_INT_BITS)))
633 #endif
635 /* The iterator for allocno set implemented ed as allocno bit
636 vector. */
637 typedef struct {
639 /* Array containing the allocno bit vector. */
640 IRA_INT_TYPE *vec;
642 /* The number of the current element in the vector. */
643 unsigned int word_num;
645 /* The number of bits in the bit vector. */
646 unsigned int nel;
648 /* The current bit index of the bit vector. */
649 unsigned int bit_num;
651 /* Index corresponding to the 1st bit of the bit vector. */
652 int start_val;
654 /* The word of the bit vector currently visited. */
655 unsigned IRA_INT_TYPE word;
656 } ira_allocno_set_iterator;
658 /* Initialize the iterator I for allocnos bit vector VEC containing
659 minimal and maximal values MIN and MAX. */
660 static inline void
661 ira_allocno_set_iter_init (ira_allocno_set_iterator *i,
662 IRA_INT_TYPE *vec, int min, int max)
664 i->vec = vec;
665 i->word_num = 0;
666 i->nel = max < min ? 0 : max - min + 1;
667 i->start_val = min;
668 i->bit_num = 0;
669 i->word = i->nel == 0 ? 0 : vec[0];
672 /* Return TRUE if we have more allocnos to visit, in which case *N is
673 set to the allocno number to be visited. Otherwise, return
674 FALSE. */
675 static inline bool
676 ira_allocno_set_iter_cond (ira_allocno_set_iterator *i, int *n)
678 /* Skip words that are zeros. */
679 for (; i->word == 0; i->word = i->vec[i->word_num])
681 i->word_num++;
682 i->bit_num = i->word_num * IRA_INT_BITS;
684 /* If we have reached the end, break. */
685 if (i->bit_num >= i->nel)
686 return false;
689 /* Skip bits that are zero. */
690 for (; (i->word & 1) == 0; i->word >>= 1)
691 i->bit_num++;
693 *n = (int) i->bit_num + i->start_val;
695 return true;
698 /* Advance to the next allocno in the set. */
699 static inline void
700 ira_allocno_set_iter_next (ira_allocno_set_iterator *i)
702 i->word >>= 1;
703 i->bit_num++;
706 /* Loop over all elements of allocno set given by bit vector VEC and
707 their minimal and maximal values MIN and MAX. In each iteration, N
708 is set to the number of next allocno. ITER is an instance of
709 ira_allocno_set_iterator used to iterate the allocnos in the set. */
710 #define FOR_EACH_ALLOCNO_IN_SET(VEC, MIN, MAX, N, ITER) \
711 for (ira_allocno_set_iter_init (&(ITER), (VEC), (MIN), (MAX)); \
712 ira_allocno_set_iter_cond (&(ITER), &(N)); \
713 ira_allocno_set_iter_next (&(ITER)))
715 /* ira.c: */
717 /* Map: hard regs X modes -> set of hard registers for storing value
718 of given mode starting with given hard register. */
719 extern HARD_REG_SET ira_reg_mode_hard_regset
720 [FIRST_PSEUDO_REGISTER][NUM_MACHINE_MODES];
722 /* Arrays analogous to macros MEMORY_MOVE_COST and
723 REGISTER_MOVE_COST. */
724 extern short ira_memory_move_cost[MAX_MACHINE_MODE][N_REG_CLASSES][2];
725 extern move_table *ira_register_move_cost[MAX_MACHINE_MODE];
727 /* Similar to may_move_in_cost but it is calculated in IRA instead of
728 regclass. Another difference we take only available hard registers
729 into account to figure out that one register class is a subset of
730 the another one. */
731 extern move_table *ira_may_move_in_cost[MAX_MACHINE_MODE];
733 /* Similar to may_move_out_cost but it is calculated in IRA instead of
734 regclass. Another difference we take only available hard registers
735 into account to figure out that one register class is a subset of
736 the another one. */
737 extern move_table *ira_may_move_out_cost[MAX_MACHINE_MODE];
739 /* Register class subset relation: TRUE if the first class is a subset
740 of the second one considering only hard registers available for the
741 allocation. */
742 extern int ira_class_subset_p[N_REG_CLASSES][N_REG_CLASSES];
744 /* Array of number of hard registers of given class which are
745 available for the allocation. The order is defined by the
746 allocation order. */
747 extern short ira_class_hard_regs[N_REG_CLASSES][FIRST_PSEUDO_REGISTER];
749 /* The number of elements of the above array for given register
750 class. */
751 extern int ira_class_hard_regs_num[N_REG_CLASSES];
753 /* Index (in ira_class_hard_regs) for given register class and hard
754 register (in general case a hard register can belong to several
755 register classes). The index is negative for hard registers
756 unavailable for the allocation. */
757 extern short ira_class_hard_reg_index[N_REG_CLASSES][FIRST_PSEUDO_REGISTER];
759 /* Function specific hard registers can not be used for the register
760 allocation. */
761 extern HARD_REG_SET ira_no_alloc_regs;
763 /* Number of given class hard registers available for the register
764 allocation for given classes. */
765 extern int ira_available_class_regs[N_REG_CLASSES];
767 /* Array whose values are hard regset of hard registers available for
768 the allocation of given register class whose HARD_REGNO_MODE_OK
769 values for given mode are zero. */
770 extern HARD_REG_SET prohibited_class_mode_regs
771 [N_REG_CLASSES][NUM_MACHINE_MODES];
773 /* Array whose values are hard regset of hard registers for which
774 move of the hard register in given mode into itself is
775 prohibited. */
776 extern HARD_REG_SET ira_prohibited_mode_move_regs[NUM_MACHINE_MODES];
778 /* Number of cover classes. Cover classes is non-intersected register
779 classes containing all hard-registers available for the
780 allocation. */
781 extern int ira_reg_class_cover_size;
783 /* The array containing cover classes (see also comments for macro
784 IRA_COVER_CLASSES). Only first IRA_REG_CLASS_COVER_SIZE elements are
785 used for this. */
786 extern enum reg_class ira_reg_class_cover[N_REG_CLASSES];
788 /* The value is number of elements in the subsequent array. */
789 extern int ira_important_classes_num;
791 /* The array containing non-empty classes (including non-empty cover
792 classes) which are subclasses of cover classes. Such classes is
793 important for calculation of the hard register usage costs. */
794 extern enum reg_class ira_important_classes[N_REG_CLASSES];
796 /* The array containing indexes of important classes in the previous
797 array. The array elements are defined only for important
798 classes. */
799 extern int ira_important_class_nums[N_REG_CLASSES];
801 /* Map of all register classes to corresponding cover class containing
802 the given class. If given class is not a subset of a cover class,
803 we translate it into the cheapest cover class. */
804 extern enum reg_class ira_class_translate[N_REG_CLASSES];
806 /* The biggest important class inside of intersection of the two
807 classes (that is calculated taking only hard registers available
808 for allocation into account). If the both classes contain no hard
809 registers available for allocation, the value is calculated with
810 taking all hard-registers including fixed ones into account. */
811 extern enum reg_class ira_reg_class_intersect[N_REG_CLASSES][N_REG_CLASSES];
813 /* The biggest important class inside of union of the two classes
814 (that is calculated taking only hard registers available for
815 allocation into account). If the both classes contain no hard
816 registers available for allocation, the value is calculated with
817 taking all hard-registers including fixed ones into account. In
818 other words, the value is the corresponding reg_class_subunion
819 value. */
820 extern enum reg_class ira_reg_class_union[N_REG_CLASSES][N_REG_CLASSES];
822 extern void *ira_allocate (size_t);
823 extern void *ira_reallocate (void *, size_t);
824 extern void ira_free (void *addr);
825 extern bitmap ira_allocate_bitmap (void);
826 extern void ira_free_bitmap (bitmap);
827 extern void ira_print_disposition (FILE *);
828 extern void ira_debug_disposition (void);
829 extern void ira_debug_class_cover (void);
830 extern void ira_init_register_move_cost (enum machine_mode);
832 /* The length of the two following arrays. */
833 extern int ira_reg_equiv_len;
835 /* The element value is TRUE if the corresponding regno value is
836 invariant. */
837 extern bool *ira_reg_equiv_invariant_p;
839 /* The element value is equiv constant of given pseudo-register or
840 NULL_RTX. */
841 extern rtx *ira_reg_equiv_const;
843 /* ira-build.c */
845 /* The current loop tree node and its regno allocno map. */
846 extern ira_loop_tree_node_t ira_curr_loop_tree_node;
847 extern ira_allocno_t *ira_curr_regno_allocno_map;
849 extern void ira_debug_copy (ira_copy_t);
850 extern void ira_debug_copies (void);
851 extern void ira_debug_allocno_copies (ira_allocno_t);
853 extern void ira_traverse_loop_tree (bool, ira_loop_tree_node_t,
854 void (*) (ira_loop_tree_node_t),
855 void (*) (ira_loop_tree_node_t));
856 extern ira_allocno_t ira_create_allocno (int, bool, ira_loop_tree_node_t);
857 extern void ira_set_allocno_cover_class (ira_allocno_t, enum reg_class);
858 extern bool ira_conflict_vector_profitable_p (ira_allocno_t, int);
859 extern void ira_allocate_allocno_conflict_vec (ira_allocno_t, int);
860 extern void ira_allocate_allocno_conflicts (ira_allocno_t, int);
861 extern void ira_add_allocno_conflict (ira_allocno_t, ira_allocno_t);
862 extern void ira_print_expanded_allocno (ira_allocno_t);
863 extern allocno_live_range_t ira_create_allocno_live_range
864 (ira_allocno_t, int, int, allocno_live_range_t);
865 extern void ira_finish_allocno_live_range (allocno_live_range_t);
866 extern void ira_free_allocno_updated_costs (ira_allocno_t);
867 extern ira_copy_t ira_create_copy (ira_allocno_t, ira_allocno_t,
868 int, bool, rtx, ira_loop_tree_node_t);
869 extern void ira_add_allocno_copy_to_list (ira_copy_t);
870 extern void ira_swap_allocno_copy_ends_if_necessary (ira_copy_t);
871 extern void ira_remove_allocno_copy_from_list (ira_copy_t);
872 extern ira_copy_t ira_add_allocno_copy (ira_allocno_t, ira_allocno_t, int,
873 bool, rtx, ira_loop_tree_node_t);
875 extern int *ira_allocate_cost_vector (enum reg_class);
876 extern void ira_free_cost_vector (int *, enum reg_class);
878 extern void ira_flattening (int, int);
879 extern bool ira_build (bool);
880 extern void ira_destroy (void);
882 /* ira-costs.c */
883 extern void ira_init_costs_once (void);
884 extern void ira_init_costs (void);
885 extern void ira_finish_costs_once (void);
886 extern void ira_costs (void);
887 extern void ira_tune_allocno_costs_and_cover_classes (void);
889 /* ira-lives.c */
891 extern void ira_rebuild_start_finish_chains (void);
892 extern void ira_print_live_range_list (FILE *, allocno_live_range_t);
893 extern void ira_debug_live_range_list (allocno_live_range_t);
894 extern void ira_debug_allocno_live_ranges (ira_allocno_t);
895 extern void ira_debug_live_ranges (void);
896 extern void ira_create_allocno_live_ranges (void);
897 extern void ira_compress_allocno_live_ranges (void);
898 extern void ira_finish_allocno_live_ranges (void);
900 /* ira-conflicts.c */
901 extern bool ira_allocno_live_ranges_intersect_p (ira_allocno_t, ira_allocno_t);
902 extern bool ira_pseudo_live_ranges_intersect_p (int, int);
903 extern void ira_debug_conflicts (bool);
904 extern void ira_build_conflicts (void);
906 /* ira-color.c */
907 extern int ira_loop_edge_freq (ira_loop_tree_node_t, int, bool);
908 extern void ira_reassign_conflict_allocnos (int);
909 extern void ira_initiate_assign (void);
910 extern void ira_finish_assign (void);
911 extern void ira_color (void);
913 /* ira-emit.c */
914 extern void ira_emit (bool);
918 /* The iterator for all allocnos. */
919 typedef struct {
920 /* The number of the current element in IRA_ALLOCNOS. */
921 int n;
922 } ira_allocno_iterator;
924 /* Initialize the iterator I. */
925 static inline void
926 ira_allocno_iter_init (ira_allocno_iterator *i)
928 i->n = 0;
931 /* Return TRUE if we have more allocnos to visit, in which case *A is
932 set to the allocno to be visited. Otherwise, return FALSE. */
933 static inline bool
934 ira_allocno_iter_cond (ira_allocno_iterator *i, ira_allocno_t *a)
936 int n;
938 for (n = i->n; n < ira_allocnos_num; n++)
939 if (ira_allocnos[n] != NULL)
941 *a = ira_allocnos[n];
942 i->n = n + 1;
943 return true;
945 return false;
948 /* Loop over all allocnos. In each iteration, A is set to the next
949 allocno. ITER is an instance of ira_allocno_iterator used to iterate
950 the allocnos. */
951 #define FOR_EACH_ALLOCNO(A, ITER) \
952 for (ira_allocno_iter_init (&(ITER)); \
953 ira_allocno_iter_cond (&(ITER), &(A));)
958 /* The iterator for copies. */
959 typedef struct {
960 /* The number of the current element in IRA_COPIES. */
961 int n;
962 } ira_copy_iterator;
964 /* Initialize the iterator I. */
965 static inline void
966 ira_copy_iter_init (ira_copy_iterator *i)
968 i->n = 0;
971 /* Return TRUE if we have more copies to visit, in which case *CP is
972 set to the copy to be visited. Otherwise, return FALSE. */
973 static inline bool
974 ira_copy_iter_cond (ira_copy_iterator *i, ira_copy_t *cp)
976 int n;
978 for (n = i->n; n < ira_copies_num; n++)
979 if (ira_copies[n] != NULL)
981 *cp = ira_copies[n];
982 i->n = n + 1;
983 return true;
985 return false;
988 /* Loop over all copies. In each iteration, C is set to the next
989 copy. ITER is an instance of ira_copy_iterator used to iterate
990 the copies. */
991 #define FOR_EACH_COPY(C, ITER) \
992 for (ira_copy_iter_init (&(ITER)); \
993 ira_copy_iter_cond (&(ITER), &(C));)
998 /* The iterator for allocno conflicts. */
999 typedef struct {
1001 /* TRUE if the conflicts are represented by vector of allocnos. */
1002 bool allocno_conflict_vec_p;
1004 /* The conflict vector or conflict bit vector. */
1005 void *vec;
1007 /* The number of the current element in the vector (of type
1008 ira_allocno_t or IRA_INT_TYPE). */
1009 unsigned int word_num;
1011 /* The bit vector size. It is defined only if
1012 ALLOCNO_CONFLICT_VEC_P is FALSE. */
1013 unsigned int size;
1015 /* The current bit index of bit vector. It is defined only if
1016 ALLOCNO_CONFLICT_VEC_P is FALSE. */
1017 unsigned int bit_num;
1019 /* Allocno conflict id corresponding to the 1st bit of the bit
1020 vector. It is defined only if ALLOCNO_CONFLICT_VEC_P is
1021 FALSE. */
1022 int base_conflict_id;
1024 /* The word of bit vector currently visited. It is defined only if
1025 ALLOCNO_CONFLICT_VEC_P is FALSE. */
1026 unsigned IRA_INT_TYPE word;
1027 } ira_allocno_conflict_iterator;
1029 /* Initialize the iterator I with ALLOCNO conflicts. */
1030 static inline void
1031 ira_allocno_conflict_iter_init (ira_allocno_conflict_iterator *i,
1032 ira_allocno_t allocno)
1034 i->allocno_conflict_vec_p = ALLOCNO_CONFLICT_VEC_P (allocno);
1035 i->vec = ALLOCNO_CONFLICT_ALLOCNO_ARRAY (allocno);
1036 i->word_num = 0;
1037 if (i->allocno_conflict_vec_p)
1038 i->size = i->bit_num = i->base_conflict_id = i->word = 0;
1039 else
1041 if (ALLOCNO_MIN (allocno) > ALLOCNO_MAX (allocno))
1042 i->size = 0;
1043 else
1044 i->size = ((ALLOCNO_MAX (allocno) - ALLOCNO_MIN (allocno)
1045 + IRA_INT_BITS)
1046 / IRA_INT_BITS) * sizeof (IRA_INT_TYPE);
1047 i->bit_num = 0;
1048 i->base_conflict_id = ALLOCNO_MIN (allocno);
1049 i->word = (i->size == 0 ? 0 : ((IRA_INT_TYPE *) i->vec)[0]);
1053 /* Return TRUE if we have more conflicting allocnos to visit, in which
1054 case *A is set to the allocno to be visited. Otherwise, return
1055 FALSE. */
1056 static inline bool
1057 ira_allocno_conflict_iter_cond (ira_allocno_conflict_iterator *i,
1058 ira_allocno_t *a)
1060 ira_allocno_t conflict_allocno;
1062 if (i->allocno_conflict_vec_p)
1064 conflict_allocno = ((ira_allocno_t *) i->vec)[i->word_num];
1065 if (conflict_allocno == NULL)
1066 return false;
1067 *a = conflict_allocno;
1068 return true;
1070 else
1072 /* Skip words that are zeros. */
1073 for (; i->word == 0; i->word = ((IRA_INT_TYPE *) i->vec)[i->word_num])
1075 i->word_num++;
1077 /* If we have reached the end, break. */
1078 if (i->word_num * sizeof (IRA_INT_TYPE) >= i->size)
1079 return false;
1081 i->bit_num = i->word_num * IRA_INT_BITS;
1084 /* Skip bits that are zero. */
1085 for (; (i->word & 1) == 0; i->word >>= 1)
1086 i->bit_num++;
1088 *a = ira_conflict_id_allocno_map[i->bit_num + i->base_conflict_id];
1090 return true;
1094 /* Advance to the next conflicting allocno. */
1095 static inline void
1096 ira_allocno_conflict_iter_next (ira_allocno_conflict_iterator *i)
1098 if (i->allocno_conflict_vec_p)
1099 i->word_num++;
1100 else
1102 i->word >>= 1;
1103 i->bit_num++;
1107 /* Loop over all allocnos conflicting with ALLOCNO. In each
1108 iteration, A is set to the next conflicting allocno. ITER is an
1109 instance of ira_allocno_conflict_iterator used to iterate the
1110 conflicts. */
1111 #define FOR_EACH_ALLOCNO_CONFLICT(ALLOCNO, A, ITER) \
1112 for (ira_allocno_conflict_iter_init (&(ITER), (ALLOCNO)); \
1113 ira_allocno_conflict_iter_cond (&(ITER), &(A)); \
1114 ira_allocno_conflict_iter_next (&(ITER)))
1118 /* The function returns TRUE if hard registers starting with
1119 HARD_REGNO and containing value of MODE are not in set
1120 HARD_REGSET. */
1121 static inline bool
1122 ira_hard_reg_not_in_set_p (int hard_regno, enum machine_mode mode,
1123 HARD_REG_SET hard_regset)
1125 int i;
1127 ira_assert (hard_regno >= 0);
1128 for (i = hard_regno_nregs[hard_regno][mode] - 1; i >= 0; i--)
1129 if (TEST_HARD_REG_BIT (hard_regset, hard_regno + i))
1130 return false;
1131 return true;
1136 /* To save memory we use a lazy approach for allocation and
1137 initialization of the cost vectors. We do this only when it is
1138 really necessary. */
1140 /* Allocate cost vector *VEC for hard registers of COVER_CLASS and
1141 initialize the elements by VAL if it is necessary */
1142 static inline void
1143 ira_allocate_and_set_costs (int **vec, enum reg_class cover_class, int val)
1145 int i, *reg_costs;
1146 int len;
1148 if (*vec != NULL)
1149 return;
1150 *vec = reg_costs = ira_allocate_cost_vector (cover_class);
1151 len = ira_class_hard_regs_num[cover_class];
1152 for (i = 0; i < len; i++)
1153 reg_costs[i] = val;
1156 /* Allocate cost vector *VEC for hard registers of COVER_CLASS and
1157 copy values of vector SRC into the vector if it is necessary */
1158 static inline void
1159 ira_allocate_and_copy_costs (int **vec, enum reg_class cover_class, int *src)
1161 int len;
1163 if (*vec != NULL || src == NULL)
1164 return;
1165 *vec = ira_allocate_cost_vector (cover_class);
1166 len = ira_class_hard_regs_num[cover_class];
1167 memcpy (*vec, src, sizeof (int) * len);
1170 /* Allocate cost vector *VEC for hard registers of COVER_CLASS and
1171 add values of vector SRC into the vector if it is necessary */
1172 static inline void
1173 ira_allocate_and_accumulate_costs (int **vec, enum reg_class cover_class,
1174 int *src)
1176 int i, len;
1178 if (src == NULL)
1179 return;
1180 len = ira_class_hard_regs_num[cover_class];
1181 if (*vec == NULL)
1183 *vec = ira_allocate_cost_vector (cover_class);
1184 memset (*vec, 0, sizeof (int) * len);
1186 for (i = 0; i < len; i++)
1187 (*vec)[i] += src[i];
1190 /* Allocate cost vector *VEC for hard registers of COVER_CLASS and
1191 copy values of vector SRC into the vector or initialize it by VAL
1192 (if SRC is null). */
1193 static inline void
1194 ira_allocate_and_set_or_copy_costs (int **vec, enum reg_class cover_class,
1195 int val, int *src)
1197 int i, *reg_costs;
1198 int len;
1200 if (*vec != NULL)
1201 return;
1202 *vec = reg_costs = ira_allocate_cost_vector (cover_class);
1203 len = ira_class_hard_regs_num[cover_class];
1204 if (src != NULL)
1205 memcpy (reg_costs, src, sizeof (int) * len);
1206 else
1208 for (i = 0; i < len; i++)
1209 reg_costs[i] = val;