1 /* IRA conflict builder.
2 Copyright (C) 2006-2015 Free Software Foundation, Inc.
3 Contributed by Vladimir Makarov <vmakarov@redhat.com>.
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
30 #include "hard-reg-set.h"
37 #include "basic-block.h"
38 #include "insn-config.h"
40 #include "diagnostic-core.h"
43 #include "sparseset.h"
45 #include "addresses.h"
47 /* This file contains code responsible for allocno conflict creation,
48 allocno copy creation and allocno info accumulation on upper level
51 /* ira_allocnos_num array of arrays of bits, recording whether two
52 allocno's conflict (can't go in the same hardware register).
54 Some arrays will be used as conflict bit vector of the
55 corresponding allocnos see function build_object_conflicts. */
56 static IRA_INT_TYPE
**conflicts
;
58 /* Macro to test a conflict of C1 and C2 in `conflicts'. */
59 #define OBJECTS_CONFLICT_P(C1, C2) \
60 (OBJECT_MIN (C1) <= OBJECT_CONFLICT_ID (C2) \
61 && OBJECT_CONFLICT_ID (C2) <= OBJECT_MAX (C1) \
62 && TEST_MINMAX_SET_BIT (conflicts[OBJECT_CONFLICT_ID (C1)], \
63 OBJECT_CONFLICT_ID (C2), \
64 OBJECT_MIN (C1), OBJECT_MAX (C1)))
67 /* Record a conflict between objects OBJ1 and OBJ2. If necessary,
68 canonicalize the conflict by recording it for lower-order subobjects
69 of the corresponding allocnos. */
71 record_object_conflict (ira_object_t obj1
, ira_object_t obj2
)
73 ira_allocno_t a1
= OBJECT_ALLOCNO (obj1
);
74 ira_allocno_t a2
= OBJECT_ALLOCNO (obj2
);
75 int w1
= OBJECT_SUBWORD (obj1
);
76 int w2
= OBJECT_SUBWORD (obj2
);
79 /* Canonicalize the conflict. If two identically-numbered words
80 conflict, always record this as a conflict between words 0. That
81 is the only information we need, and it is easier to test for if
82 it is collected in each allocno's lowest-order object. */
83 if (w1
== w2
&& w1
> 0)
85 obj1
= ALLOCNO_OBJECT (a1
, 0);
86 obj2
= ALLOCNO_OBJECT (a2
, 0);
88 id1
= OBJECT_CONFLICT_ID (obj1
);
89 id2
= OBJECT_CONFLICT_ID (obj2
);
91 SET_MINMAX_SET_BIT (conflicts
[id1
], id2
, OBJECT_MIN (obj1
),
93 SET_MINMAX_SET_BIT (conflicts
[id2
], id1
, OBJECT_MIN (obj2
),
97 /* Build allocno conflict table by processing allocno live ranges.
98 Return true if the table was built. The table is not built if it
101 build_conflict_bit_table (void)
105 enum reg_class aclass
;
106 int object_set_words
, allocated_words_num
, conflict_bit_vec_words_num
;
108 ira_allocno_t allocno
;
109 ira_allocno_iterator ai
;
110 sparseset objects_live
;
112 ira_allocno_object_iterator aoi
;
114 allocated_words_num
= 0;
115 FOR_EACH_ALLOCNO (allocno
, ai
)
116 FOR_EACH_ALLOCNO_OBJECT (allocno
, obj
, aoi
)
118 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
120 conflict_bit_vec_words_num
121 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
123 allocated_words_num
+= conflict_bit_vec_words_num
;
124 if ((uint64_t) allocated_words_num
* sizeof (IRA_INT_TYPE
)
125 > (uint64_t) IRA_MAX_CONFLICT_TABLE_SIZE
* 1024 * 1024)
127 if (internal_flag_ira_verbose
> 0 && ira_dump_file
!= NULL
)
130 "+++Conflict table will be too big(>%dMB) -- don't use it\n",
131 IRA_MAX_CONFLICT_TABLE_SIZE
);
136 conflicts
= (IRA_INT_TYPE
**) ira_allocate (sizeof (IRA_INT_TYPE
*)
138 allocated_words_num
= 0;
139 FOR_EACH_ALLOCNO (allocno
, ai
)
140 FOR_EACH_ALLOCNO_OBJECT (allocno
, obj
, aoi
)
142 int id
= OBJECT_CONFLICT_ID (obj
);
143 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
145 conflicts
[id
] = NULL
;
148 conflict_bit_vec_words_num
149 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
151 allocated_words_num
+= conflict_bit_vec_words_num
;
153 = (IRA_INT_TYPE
*) ira_allocate (sizeof (IRA_INT_TYPE
)
154 * conflict_bit_vec_words_num
);
155 memset (conflicts
[id
], 0,
156 sizeof (IRA_INT_TYPE
) * conflict_bit_vec_words_num
);
159 object_set_words
= (ira_objects_num
+ IRA_INT_BITS
- 1) / IRA_INT_BITS
;
160 if (internal_flag_ira_verbose
> 0 && ira_dump_file
!= NULL
)
163 "+++Allocating %ld bytes for conflict table (uncompressed size %ld)\n",
164 (long) allocated_words_num
* sizeof (IRA_INT_TYPE
),
165 (long) object_set_words
* ira_objects_num
* sizeof (IRA_INT_TYPE
));
167 objects_live
= sparseset_alloc (ira_objects_num
);
168 for (i
= 0; i
< ira_max_point
; i
++)
170 for (r
= ira_start_point_ranges
[i
]; r
!= NULL
; r
= r
->start_next
)
172 ira_object_t obj
= r
->object
;
173 ira_allocno_t allocno
= OBJECT_ALLOCNO (obj
);
174 int id
= OBJECT_CONFLICT_ID (obj
);
176 gcc_assert (id
< ira_objects_num
);
178 aclass
= ALLOCNO_CLASS (allocno
);
179 EXECUTE_IF_SET_IN_SPARSESET (objects_live
, j
)
181 ira_object_t live_obj
= ira_object_id_map
[j
];
182 ira_allocno_t live_a
= OBJECT_ALLOCNO (live_obj
);
183 enum reg_class live_aclass
= ALLOCNO_CLASS (live_a
);
185 if (ira_reg_classes_intersect_p
[aclass
][live_aclass
]
186 /* Don't set up conflict for the allocno with itself. */
187 && live_a
!= allocno
)
189 record_object_conflict (obj
, live_obj
);
192 sparseset_set_bit (objects_live
, id
);
195 for (r
= ira_finish_point_ranges
[i
]; r
!= NULL
; r
= r
->finish_next
)
196 sparseset_clear_bit (objects_live
, OBJECT_CONFLICT_ID (r
->object
));
198 sparseset_free (objects_live
);
202 /* Return true iff allocnos A1 and A2 cannot be allocated to the same
203 register due to conflicts. */
206 allocnos_conflict_for_copy_p (ira_allocno_t a1
, ira_allocno_t a2
)
208 /* Due to the fact that we canonicalize conflicts (see
209 record_object_conflict), we only need to test for conflicts of
210 the lowest order words. */
211 ira_object_t obj1
= ALLOCNO_OBJECT (a1
, 0);
212 ira_object_t obj2
= ALLOCNO_OBJECT (a2
, 0);
214 return OBJECTS_CONFLICT_P (obj1
, obj2
);
217 /* Check that X is REG or SUBREG of REG. */
218 #define REG_SUBREG_P(x) \
219 (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))))
221 /* Return X if X is a REG, otherwise it should be SUBREG of REG and
222 the function returns the reg in this case. *OFFSET will be set to
223 0 in the first case or the regno offset in the first case. */
225 go_through_subreg (rtx x
, int *offset
)
232 ira_assert (GET_CODE (x
) == SUBREG
);
233 reg
= SUBREG_REG (x
);
234 ira_assert (REG_P (reg
));
235 if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
236 *offset
= subreg_regno_offset (REGNO (reg
), GET_MODE (reg
),
237 SUBREG_BYTE (x
), GET_MODE (x
));
239 *offset
= (SUBREG_BYTE (x
) / REGMODE_NATURAL_SIZE (GET_MODE (x
)));
243 /* Process registers REG1 and REG2 in move INSN with execution
244 frequency FREQ. The function also processes the registers in a
245 potential move insn (INSN == NULL in this case) with frequency
246 FREQ. The function can modify hard register costs of the
247 corresponding allocnos or create a copy involving the corresponding
248 allocnos. The function does nothing if the both registers are hard
249 registers. When nothing is changed, the function returns
252 process_regs_for_copy (rtx reg1
, rtx reg2
, bool constraint_p
,
253 rtx_insn
*insn
, int freq
)
255 int allocno_preferenced_hard_regno
, cost
, index
, offset1
, offset2
;
258 reg_class_t rclass
, aclass
;
262 gcc_assert (REG_SUBREG_P (reg1
) && REG_SUBREG_P (reg2
));
263 only_regs_p
= REG_P (reg1
) && REG_P (reg2
);
264 reg1
= go_through_subreg (reg1
, &offset1
);
265 reg2
= go_through_subreg (reg2
, &offset2
);
266 /* Set up hard regno preferenced by allocno. If allocno gets the
267 hard regno the copy (or potential move) insn will be removed. */
268 if (HARD_REGISTER_P (reg1
))
270 if (HARD_REGISTER_P (reg2
))
272 allocno_preferenced_hard_regno
= REGNO (reg1
) + offset1
- offset2
;
273 a
= ira_curr_regno_allocno_map
[REGNO (reg2
)];
275 else if (HARD_REGISTER_P (reg2
))
277 allocno_preferenced_hard_regno
= REGNO (reg2
) + offset2
- offset1
;
278 a
= ira_curr_regno_allocno_map
[REGNO (reg1
)];
282 ira_allocno_t a1
= ira_curr_regno_allocno_map
[REGNO (reg1
)];
283 ira_allocno_t a2
= ira_curr_regno_allocno_map
[REGNO (reg2
)];
285 if (!allocnos_conflict_for_copy_p (a1
, a2
) && offset1
== offset2
)
287 cp
= ira_add_allocno_copy (a1
, a2
, freq
, constraint_p
, insn
,
288 ira_curr_loop_tree_node
);
289 bitmap_set_bit (ira_curr_loop_tree_node
->local_copies
, cp
->num
);
296 if (! IN_RANGE (allocno_preferenced_hard_regno
,
297 0, FIRST_PSEUDO_REGISTER
- 1))
298 /* Can not be tied. */
300 rclass
= REGNO_REG_CLASS (allocno_preferenced_hard_regno
);
301 mode
= ALLOCNO_MODE (a
);
302 aclass
= ALLOCNO_CLASS (a
);
303 if (only_regs_p
&& insn
!= NULL_RTX
304 && reg_class_size
[rclass
] <= ira_reg_class_max_nregs
[rclass
][mode
])
305 /* It is already taken into account in ira-costs.c. */
307 index
= ira_class_hard_reg_index
[aclass
][allocno_preferenced_hard_regno
];
309 /* Can not be tied. It is not in the allocno class. */
311 ira_init_register_move_cost_if_necessary (mode
);
312 if (HARD_REGISTER_P (reg1
))
313 cost
= ira_register_move_cost
[mode
][aclass
][rclass
] * freq
;
315 cost
= ira_register_move_cost
[mode
][rclass
][aclass
] * freq
;
318 ira_allocate_and_set_costs
319 (&ALLOCNO_HARD_REG_COSTS (a
), aclass
,
320 ALLOCNO_CLASS_COST (a
));
321 ira_allocate_and_set_costs
322 (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a
), aclass
, 0);
323 ALLOCNO_HARD_REG_COSTS (a
)[index
] -= cost
;
324 ALLOCNO_CONFLICT_HARD_REG_COSTS (a
)[index
] -= cost
;
325 if (ALLOCNO_HARD_REG_COSTS (a
)[index
] < ALLOCNO_CLASS_COST (a
))
326 ALLOCNO_CLASS_COST (a
) = ALLOCNO_HARD_REG_COSTS (a
)[index
];
327 ira_add_allocno_pref (a
, allocno_preferenced_hard_regno
, freq
);
328 a
= ira_parent_or_cap_allocno (a
);
334 /* Process all of the output registers of the current insn which are
335 not bound (BOUND_P) and the input register REG (its operand number
336 OP_NUM) which dies in the insn as if there were a move insn between
337 them with frequency FREQ. */
339 process_reg_shuffles (rtx reg
, int op_num
, int freq
, bool *bound_p
)
344 gcc_assert (REG_SUBREG_P (reg
));
345 for (i
= 0; i
< recog_data
.n_operands
; i
++)
347 another_reg
= recog_data
.operand
[i
];
349 if (!REG_SUBREG_P (another_reg
) || op_num
== i
350 || recog_data
.operand_type
[i
] != OP_OUT
354 process_regs_for_copy (reg
, another_reg
, false, NULL
, freq
);
358 /* Process INSN and create allocno copies if necessary. For example,
359 it might be because INSN is a pseudo-register move or INSN is two
362 add_insn_allocno_copies (rtx_insn
*insn
)
364 rtx set
, operand
, dup
;
365 bool bound_p
[MAX_RECOG_OPERANDS
];
369 freq
= REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn
));
372 if ((set
= single_set (insn
)) != NULL_RTX
373 && REG_SUBREG_P (SET_DEST (set
)) && REG_SUBREG_P (SET_SRC (set
))
374 && ! side_effects_p (set
)
375 && find_reg_note (insn
, REG_DEAD
,
376 REG_P (SET_SRC (set
))
378 : SUBREG_REG (SET_SRC (set
))) != NULL_RTX
)
380 process_regs_for_copy (SET_SRC (set
), SET_DEST (set
),
384 /* Fast check of possibility of constraint or shuffle copies. If
385 there are no dead registers, there will be no such copies. */
386 if (! find_reg_note (insn
, REG_DEAD
, NULL_RTX
))
388 ira_setup_alts (insn
, alts
);
389 for (i
= 0; i
< recog_data
.n_operands
; i
++)
391 for (i
= 0; i
< recog_data
.n_operands
; i
++)
393 operand
= recog_data
.operand
[i
];
394 if (! REG_SUBREG_P (operand
))
396 if ((n
= ira_get_dup_out_num (i
, alts
)) >= 0)
399 dup
= recog_data
.operand
[n
];
400 if (REG_SUBREG_P (dup
)
401 && find_reg_note (insn
, REG_DEAD
,
404 : SUBREG_REG (operand
)) != NULL_RTX
)
405 process_regs_for_copy (operand
, dup
, true, NULL
,
409 for (i
= 0; i
< recog_data
.n_operands
; i
++)
411 operand
= recog_data
.operand
[i
];
412 if (REG_SUBREG_P (operand
)
413 && find_reg_note (insn
, REG_DEAD
,
415 ? operand
: SUBREG_REG (operand
)) != NULL_RTX
)
416 /* If an operand dies, prefer its hard register for the output
417 operands by decreasing the hard register cost or creating
418 the corresponding allocno copies. The cost will not
419 correspond to a real move insn cost, so make the frequency
421 process_reg_shuffles (operand
, i
, freq
< 8 ? 1 : freq
/ 8, bound_p
);
425 /* Add copies originated from BB given by LOOP_TREE_NODE. */
427 add_copies (ira_loop_tree_node_t loop_tree_node
)
432 bb
= loop_tree_node
->bb
;
435 FOR_BB_INSNS (bb
, insn
)
436 if (NONDEBUG_INSN_P (insn
))
437 add_insn_allocno_copies (insn
);
440 /* Propagate copies the corresponding allocnos on upper loop tree
443 propagate_copies (void)
446 ira_copy_iterator ci
;
447 ira_allocno_t a1
, a2
, parent_a1
, parent_a2
;
449 FOR_EACH_COPY (cp
, ci
)
453 if (ALLOCNO_LOOP_TREE_NODE (a1
) == ira_loop_tree_root
)
455 ira_assert ((ALLOCNO_LOOP_TREE_NODE (a2
) != ira_loop_tree_root
));
456 parent_a1
= ira_parent_or_cap_allocno (a1
);
457 parent_a2
= ira_parent_or_cap_allocno (a2
);
458 ira_assert (parent_a1
!= NULL
&& parent_a2
!= NULL
);
459 if (! allocnos_conflict_for_copy_p (parent_a1
, parent_a2
))
460 ira_add_allocno_copy (parent_a1
, parent_a2
, cp
->freq
,
461 cp
->constraint_p
, cp
->insn
, cp
->loop_tree_node
);
465 /* Array used to collect all conflict allocnos for given allocno. */
466 static ira_object_t
*collected_conflict_objects
;
468 /* Build conflict vectors or bit conflict vectors (whatever is more
469 profitable) for object OBJ from the conflict table. */
471 build_object_conflicts (ira_object_t obj
)
473 int i
, px
, parent_num
;
474 ira_allocno_t parent_a
, another_parent_a
;
475 ira_object_t parent_obj
;
476 ira_allocno_t a
= OBJECT_ALLOCNO (obj
);
477 IRA_INT_TYPE
*object_conflicts
;
478 minmax_set_iterator asi
;
479 int parent_min
, parent_max ATTRIBUTE_UNUSED
;
481 object_conflicts
= conflicts
[OBJECT_CONFLICT_ID (obj
)];
483 FOR_EACH_BIT_IN_MINMAX_SET (object_conflicts
,
484 OBJECT_MIN (obj
), OBJECT_MAX (obj
), i
, asi
)
486 ira_object_t another_obj
= ira_object_id_map
[i
];
487 ira_allocno_t another_a
= OBJECT_ALLOCNO (obj
);
489 ira_assert (ira_reg_classes_intersect_p
490 [ALLOCNO_CLASS (a
)][ALLOCNO_CLASS (another_a
)]);
491 collected_conflict_objects
[px
++] = another_obj
;
493 if (ira_conflict_vector_profitable_p (obj
, px
))
496 ira_allocate_conflict_vec (obj
, px
);
497 vec
= OBJECT_CONFLICT_VEC (obj
);
498 memcpy (vec
, collected_conflict_objects
, sizeof (ira_object_t
) * px
);
500 OBJECT_NUM_CONFLICTS (obj
) = px
;
504 int conflict_bit_vec_words_num
;
506 OBJECT_CONFLICT_ARRAY (obj
) = object_conflicts
;
507 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
508 conflict_bit_vec_words_num
= 0;
510 conflict_bit_vec_words_num
511 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
513 OBJECT_CONFLICT_ARRAY_SIZE (obj
)
514 = conflict_bit_vec_words_num
* sizeof (IRA_INT_TYPE
);
517 parent_a
= ira_parent_or_cap_allocno (a
);
518 if (parent_a
== NULL
)
520 ira_assert (ALLOCNO_CLASS (a
) == ALLOCNO_CLASS (parent_a
));
521 ira_assert (ALLOCNO_NUM_OBJECTS (a
) == ALLOCNO_NUM_OBJECTS (parent_a
));
522 parent_obj
= ALLOCNO_OBJECT (parent_a
, OBJECT_SUBWORD (obj
));
523 parent_num
= OBJECT_CONFLICT_ID (parent_obj
);
524 parent_min
= OBJECT_MIN (parent_obj
);
525 parent_max
= OBJECT_MAX (parent_obj
);
526 FOR_EACH_BIT_IN_MINMAX_SET (object_conflicts
,
527 OBJECT_MIN (obj
), OBJECT_MAX (obj
), i
, asi
)
529 ira_object_t another_obj
= ira_object_id_map
[i
];
530 ira_allocno_t another_a
= OBJECT_ALLOCNO (another_obj
);
531 int another_word
= OBJECT_SUBWORD (another_obj
);
533 ira_assert (ira_reg_classes_intersect_p
534 [ALLOCNO_CLASS (a
)][ALLOCNO_CLASS (another_a
)]);
536 another_parent_a
= ira_parent_or_cap_allocno (another_a
);
537 if (another_parent_a
== NULL
)
539 ira_assert (ALLOCNO_NUM (another_parent_a
) >= 0);
540 ira_assert (ALLOCNO_CLASS (another_a
)
541 == ALLOCNO_CLASS (another_parent_a
));
542 ira_assert (ALLOCNO_NUM_OBJECTS (another_a
)
543 == ALLOCNO_NUM_OBJECTS (another_parent_a
));
544 SET_MINMAX_SET_BIT (conflicts
[parent_num
],
545 OBJECT_CONFLICT_ID (ALLOCNO_OBJECT (another_parent_a
,
547 parent_min
, parent_max
);
551 /* Build conflict vectors or bit conflict vectors (whatever is more
552 profitable) of all allocnos from the conflict table. */
554 build_conflicts (void)
557 ira_allocno_t a
, cap
;
559 collected_conflict_objects
560 = (ira_object_t
*) ira_allocate (sizeof (ira_object_t
)
562 for (i
= max_reg_num () - 1; i
>= FIRST_PSEUDO_REGISTER
; i
--)
563 for (a
= ira_regno_allocno_map
[i
];
565 a
= ALLOCNO_NEXT_REGNO_ALLOCNO (a
))
567 int j
, nregs
= ALLOCNO_NUM_OBJECTS (a
);
568 for (j
= 0; j
< nregs
; j
++)
570 ira_object_t obj
= ALLOCNO_OBJECT (a
, j
);
571 build_object_conflicts (obj
);
572 for (cap
= ALLOCNO_CAP (a
); cap
!= NULL
; cap
= ALLOCNO_CAP (cap
))
574 ira_object_t cap_obj
= ALLOCNO_OBJECT (cap
, j
);
575 gcc_assert (ALLOCNO_NUM_OBJECTS (cap
) == ALLOCNO_NUM_OBJECTS (a
));
576 build_object_conflicts (cap_obj
);
580 ira_free (collected_conflict_objects
);
585 /* Print hard reg set SET with TITLE to FILE. */
587 print_hard_reg_set (FILE *file
, const char *title
, HARD_REG_SET set
)
592 for (start
= -1, i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
594 if (TEST_HARD_REG_BIT (set
, i
))
596 if (i
== 0 || ! TEST_HARD_REG_BIT (set
, i
- 1))
600 && (i
== FIRST_PSEUDO_REGISTER
- 1 || ! TEST_HARD_REG_BIT (set
, i
)))
603 fprintf (file
, " %d", start
);
604 else if (start
== i
- 2)
605 fprintf (file
, " %d %d", start
, start
+ 1);
607 fprintf (file
, " %d-%d", start
, i
- 1);
615 print_allocno_conflicts (FILE * file
, bool reg_p
, ira_allocno_t a
)
617 HARD_REG_SET conflicting_hard_regs
;
622 fprintf (file
, ";; r%d", ALLOCNO_REGNO (a
));
625 fprintf (file
, ";; a%d(r%d,", ALLOCNO_NUM (a
), ALLOCNO_REGNO (a
));
626 if ((bb
= ALLOCNO_LOOP_TREE_NODE (a
)->bb
) != NULL
)
627 fprintf (file
, "b%d", bb
->index
);
629 fprintf (file
, "l%d", ALLOCNO_LOOP_TREE_NODE (a
)->loop_num
);
633 fputs (" conflicts:", file
);
634 n
= ALLOCNO_NUM_OBJECTS (a
);
635 for (i
= 0; i
< n
; i
++)
637 ira_object_t obj
= ALLOCNO_OBJECT (a
, i
);
638 ira_object_t conflict_obj
;
639 ira_object_conflict_iterator oci
;
641 if (OBJECT_CONFLICT_ARRAY (obj
) == NULL
)
644 fprintf (file
, "\n;; subobject %d:", i
);
645 FOR_EACH_OBJECT_CONFLICT (obj
, conflict_obj
, oci
)
647 ira_allocno_t conflict_a
= OBJECT_ALLOCNO (conflict_obj
);
649 fprintf (file
, " r%d,", ALLOCNO_REGNO (conflict_a
));
652 fprintf (file
, " a%d(r%d", ALLOCNO_NUM (conflict_a
),
653 ALLOCNO_REGNO (conflict_a
));
654 if (ALLOCNO_NUM_OBJECTS (conflict_a
) > 1)
655 fprintf (file
, ",w%d", OBJECT_SUBWORD (conflict_obj
));
656 if ((bb
= ALLOCNO_LOOP_TREE_NODE (conflict_a
)->bb
) != NULL
)
657 fprintf (file
, ",b%d", bb
->index
);
659 fprintf (file
, ",l%d",
660 ALLOCNO_LOOP_TREE_NODE (conflict_a
)->loop_num
);
664 COPY_HARD_REG_SET (conflicting_hard_regs
, OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
));
665 AND_COMPL_HARD_REG_SET (conflicting_hard_regs
, ira_no_alloc_regs
);
666 AND_HARD_REG_SET (conflicting_hard_regs
,
667 reg_class_contents
[ALLOCNO_CLASS (a
)]);
668 print_hard_reg_set (file
, "\n;; total conflict hard regs:",
669 conflicting_hard_regs
);
671 COPY_HARD_REG_SET (conflicting_hard_regs
, OBJECT_CONFLICT_HARD_REGS (obj
));
672 AND_COMPL_HARD_REG_SET (conflicting_hard_regs
, ira_no_alloc_regs
);
673 AND_HARD_REG_SET (conflicting_hard_regs
,
674 reg_class_contents
[ALLOCNO_CLASS (a
)]);
675 print_hard_reg_set (file
, ";; conflict hard regs:",
676 conflicting_hard_regs
);
682 /* Print information about allocno or only regno (if REG_P) conflicts
685 print_conflicts (FILE *file
, bool reg_p
)
688 ira_allocno_iterator ai
;
690 FOR_EACH_ALLOCNO (a
, ai
)
691 print_allocno_conflicts (file
, reg_p
, a
);
694 /* Print information about allocno or only regno (if REG_P) conflicts
697 ira_debug_conflicts (bool reg_p
)
699 print_conflicts (stderr
, reg_p
);
704 /* Entry function which builds allocno conflicts and allocno copies
705 and accumulate some allocno info on upper level regions. */
707 ira_build_conflicts (void)
711 ira_allocno_iterator ai
;
712 HARD_REG_SET temp_hard_reg_set
;
716 ira_conflicts_p
= build_conflict_bit_table ();
720 ira_object_iterator oi
;
723 ira_traverse_loop_tree (true, ira_loop_tree_root
, add_copies
, NULL
);
724 /* We need finished conflict table for the subsequent call. */
725 if (flag_ira_region
== IRA_REGION_ALL
726 || flag_ira_region
== IRA_REGION_MIXED
)
729 /* Now we can free memory for the conflict table (see function
730 build_object_conflicts for details). */
731 FOR_EACH_OBJECT (obj
, oi
)
733 if (OBJECT_CONFLICT_ARRAY (obj
) != conflicts
[OBJECT_CONFLICT_ID (obj
)])
734 ira_free (conflicts
[OBJECT_CONFLICT_ID (obj
)]);
736 ira_free (conflicts
);
739 base
= base_reg_class (VOIDmode
, ADDR_SPACE_GENERIC
, ADDRESS
, SCRATCH
);
740 if (! targetm
.class_likely_spilled_p (base
))
741 CLEAR_HARD_REG_SET (temp_hard_reg_set
);
744 COPY_HARD_REG_SET (temp_hard_reg_set
, reg_class_contents
[base
]);
745 AND_COMPL_HARD_REG_SET (temp_hard_reg_set
, ira_no_alloc_regs
);
746 AND_HARD_REG_SET (temp_hard_reg_set
, call_used_reg_set
);
748 FOR_EACH_ALLOCNO (a
, ai
)
750 int i
, n
= ALLOCNO_NUM_OBJECTS (a
);
752 for (i
= 0; i
< n
; i
++)
754 ira_object_t obj
= ALLOCNO_OBJECT (a
, i
);
755 rtx allocno_reg
= regno_reg_rtx
[ALLOCNO_REGNO (a
)];
757 if ((! flag_caller_saves
&& ALLOCNO_CALLS_CROSSED_NUM (a
) != 0)
758 /* For debugging purposes don't put user defined variables in
759 callee-clobbered registers. However, do allow parameters
760 in callee-clobbered registers to improve debugging. This
761 is a bit of a fragile hack. */
763 && REG_USERVAR_P (allocno_reg
)
764 && ! reg_is_parm_p (allocno_reg
)))
766 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
),
768 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
),
771 else if (ALLOCNO_CALLS_CROSSED_NUM (a
) != 0)
773 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
),
774 no_caller_save_reg_set
);
775 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
),
777 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
),
778 no_caller_save_reg_set
);
779 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
),
783 /* Now we deal with paradoxical subreg cases where certain registers
784 cannot be accessed in the widest mode. */
785 machine_mode outer_mode
= ALLOCNO_WMODE (a
);
786 machine_mode inner_mode
= ALLOCNO_MODE (a
);
787 if (GET_MODE_SIZE (outer_mode
) > GET_MODE_SIZE (inner_mode
))
789 enum reg_class aclass
= ALLOCNO_CLASS (a
);
790 for (int j
= ira_class_hard_regs_num
[aclass
] - 1; j
>= 0; --j
)
792 int inner_regno
= ira_class_hard_regs
[aclass
][j
];
793 int outer_regno
= simplify_subreg_regno (inner_regno
,
797 || !in_hard_reg_set_p (reg_class_contents
[aclass
],
798 outer_mode
, outer_regno
))
799 SET_HARD_REG_BIT (OBJECT_CONFLICT_HARD_REGS (obj
),
804 if (ALLOCNO_CALLS_CROSSED_NUM (a
) != 0)
808 /* Allocnos bigger than the saved part of call saved
809 regs must conflict with them. */
810 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
811 if (!TEST_HARD_REG_BIT (call_used_reg_set
, regno
)
812 && HARD_REGNO_CALL_PART_CLOBBERED (regno
,
815 SET_HARD_REG_BIT (OBJECT_CONFLICT_HARD_REGS (obj
), regno
);
816 SET_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
),
822 if (optimize
&& ira_conflicts_p
823 && internal_flag_ira_verbose
> 2 && ira_dump_file
!= NULL
)
824 print_conflicts (ira_dump_file
, false);