1 /* IRA conflict builder.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010
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
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
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/>. */
24 #include "coretypes.h"
31 #include "hard-reg-set.h"
32 #include "basic-block.h"
33 #include "insn-config.h"
35 #include "diagnostic-core.h"
39 #include "sparseset.h"
41 #include "addresses.h"
43 /* This file contains code responsible for allocno conflict creation,
44 allocno copy creation and allocno info accumulation on upper level
47 /* ira_allocnos_num array of arrays of bits, recording whether two
48 allocno's conflict (can't go in the same hardware register).
50 Some arrays will be used as conflict bit vector of the
51 corresponding allocnos see function build_allocno_conflicts. */
52 static IRA_INT_TYPE
**conflicts
;
54 /* Macro to test a conflict of C1 and C2 in `conflicts'. */
55 #define OBJECTS_CONFLICT_P(C1, C2) \
56 (OBJECT_MIN (C1) <= OBJECT_CONFLICT_ID (C2) \
57 && OBJECT_CONFLICT_ID (C2) <= OBJECT_MAX (C1) \
58 && TEST_MINMAX_SET_BIT (conflicts[OBJECT_CONFLICT_ID (C1)], \
59 OBJECT_CONFLICT_ID (C2), \
60 OBJECT_MIN (C1), OBJECT_MAX (C1)))
63 /* Build allocno conflict table by processing allocno live ranges.
64 Return true if the table was built. The table is not built if it
67 build_conflict_bit_table (void)
71 enum reg_class cover_class
;
72 int object_set_words
, allocated_words_num
, conflict_bit_vec_words_num
;
74 ira_allocno_t allocno
;
75 ira_allocno_iterator ai
;
76 sparseset objects_live
;
78 allocated_words_num
= 0;
79 FOR_EACH_ALLOCNO (allocno
, ai
)
81 ira_object_t obj
= ALLOCNO_OBJECT (allocno
);
82 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
84 conflict_bit_vec_words_num
85 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
87 allocated_words_num
+= conflict_bit_vec_words_num
;
88 if ((unsigned long long) allocated_words_num
* sizeof (IRA_INT_TYPE
)
89 > (unsigned long long) IRA_MAX_CONFLICT_TABLE_SIZE
* 1024 * 1024)
91 if (internal_flag_ira_verbose
> 0 && ira_dump_file
!= NULL
)
94 "+++Conflict table will be too big(>%dMB) -- don't use it\n",
95 IRA_MAX_CONFLICT_TABLE_SIZE
);
100 conflicts
= (IRA_INT_TYPE
**) ira_allocate (sizeof (IRA_INT_TYPE
*)
102 allocated_words_num
= 0;
103 FOR_EACH_ALLOCNO (allocno
, ai
)
105 ira_object_t obj
= ALLOCNO_OBJECT (allocno
);
106 int id
= OBJECT_CONFLICT_ID (obj
);
107 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
109 conflicts
[id
] = NULL
;
112 conflict_bit_vec_words_num
113 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
115 allocated_words_num
+= conflict_bit_vec_words_num
;
117 = (IRA_INT_TYPE
*) ira_allocate (sizeof (IRA_INT_TYPE
)
118 * conflict_bit_vec_words_num
);
119 memset (conflicts
[id
], 0,
120 sizeof (IRA_INT_TYPE
) * conflict_bit_vec_words_num
);
123 object_set_words
= (ira_objects_num
+ IRA_INT_BITS
- 1) / IRA_INT_BITS
;
124 if (internal_flag_ira_verbose
> 0 && ira_dump_file
!= NULL
)
127 "+++Allocating %ld bytes for conflict table (uncompressed size %ld)\n",
128 (long) allocated_words_num
* sizeof (IRA_INT_TYPE
),
129 (long) object_set_words
* ira_objects_num
* sizeof (IRA_INT_TYPE
));
131 objects_live
= sparseset_alloc (ira_objects_num
);
132 for (i
= 0; i
< ira_max_point
; i
++)
134 for (r
= ira_start_point_ranges
[i
]; r
!= NULL
; r
= r
->start_next
)
136 ira_allocno_t allocno
= r
->allocno
;
137 ira_object_t obj
= ALLOCNO_OBJECT (allocno
);
138 int id
= OBJECT_CONFLICT_ID (obj
);
140 cover_class
= ALLOCNO_COVER_CLASS (allocno
);
141 sparseset_set_bit (objects_live
, id
);
142 EXECUTE_IF_SET_IN_SPARSESET (objects_live
, j
)
144 ira_object_t live_cr
= ira_object_id_map
[j
];
145 ira_allocno_t live_a
= OBJECT_ALLOCNO (live_cr
);
146 enum reg_class live_cover_class
= ALLOCNO_COVER_CLASS (live_a
);
148 if (ira_reg_classes_intersect_p
[cover_class
][live_cover_class
]
149 /* Don't set up conflict for the allocno with itself. */
152 SET_MINMAX_SET_BIT (conflicts
[id
], j
,
155 SET_MINMAX_SET_BIT (conflicts
[j
], id
,
156 OBJECT_MIN (live_cr
),
157 OBJECT_MAX (live_cr
));
162 for (r
= ira_finish_point_ranges
[i
]; r
!= NULL
; r
= r
->finish_next
)
164 ira_allocno_t allocno
= r
->allocno
;
165 ira_object_t obj
= ALLOCNO_OBJECT (allocno
);
166 sparseset_clear_bit (objects_live
, OBJECT_CONFLICT_ID (obj
));
169 sparseset_free (objects_live
);
173 /* Return true iff allocnos A1 and A2 cannot be allocated to the same
174 register due to conflicts. */
177 allocnos_conflict_p (ira_allocno_t a1
, ira_allocno_t a2
)
179 ira_object_t obj1
= ALLOCNO_OBJECT (a1
);
180 ira_object_t obj2
= ALLOCNO_OBJECT (a2
);
181 return OBJECTS_CONFLICT_P (obj1
, obj2
);
184 /* Return TRUE if the operand constraint STR is commutative. */
186 commutative_constraint_p (const char *str
)
191 for (ignore_p
= false;;)
196 str
+= CONSTRAINT_LEN (c
, str
);
203 /* Usually `%' is the first constraint character but the
204 documentation does not require this. */
212 /* Return the number of the operand which should be the same in any
213 case as operand with number OP_NUM (or negative value if there is
214 no such operand). If USE_COMMUT_OP_P is TRUE, the function makes
215 temporarily commutative operand exchange before this. The function
216 takes only really possible alternatives into consideration. */
218 get_dup_num (int op_num
, bool use_commut_op_p
)
220 int curr_alt
, c
, original
, dup
;
221 bool ignore_p
, commut_op_used_p
;
225 if (op_num
< 0 || recog_data
.n_alternatives
== 0)
227 op
= recog_data
.operand
[op_num
];
228 commut_op_used_p
= true;
231 if (commutative_constraint_p (recog_data
.constraints
[op_num
]))
233 else if (op_num
> 0 && commutative_constraint_p (recog_data
.constraints
237 commut_op_used_p
= false;
239 str
= recog_data
.constraints
[op_num
];
240 for (ignore_p
= false, original
= -1, curr_alt
= 0;;)
260 /* Accept a register which might be placed in memory. */
270 if (address_operand (op
, VOIDmode
))
278 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
279 case 'h': case 'j': case 'k': case 'l':
280 case 'q': case 't': case 'u':
281 case 'v': case 'w': case 'x': case 'y': case 'z':
282 case 'A': case 'B': case 'C': case 'D':
283 case 'Q': case 'R': case 'S': case 'T': case 'U':
284 case 'W': case 'Y': case 'Z':
289 ? GENERAL_REGS
: REG_CLASS_FROM_CONSTRAINT (c
, str
));
292 #ifdef EXTRA_CONSTRAINT_STR
293 else if (EXTRA_CONSTRAINT_STR (op
, c
, str
))
299 case '0': case '1': case '2': case '3': case '4':
300 case '5': case '6': case '7': case '8': case '9':
301 if (original
!= -1 && original
!= c
)
306 str
+= CONSTRAINT_LEN (c
, str
);
310 dup
= original
- '0';
313 if (commutative_constraint_p (recog_data
.constraints
[dup
]))
316 && commutative_constraint_p (recog_data
.constraints
[dup
-1]))
318 else if (! commut_op_used_p
)
324 /* Check that X is REG or SUBREG of REG. */
325 #define REG_SUBREG_P(x) \
326 (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))))
328 /* Return X if X is a REG, otherwise it should be SUBREG of REG and
329 the function returns the reg in this case. *OFFSET will be set to
330 0 in the first case or the regno offset in the first case. */
332 go_through_subreg (rtx x
, int *offset
)
339 ira_assert (GET_CODE (x
) == SUBREG
);
340 reg
= SUBREG_REG (x
);
341 ira_assert (REG_P (reg
));
342 if (REGNO (reg
) < FIRST_PSEUDO_REGISTER
)
343 *offset
= subreg_regno_offset (REGNO (reg
), GET_MODE (reg
),
344 SUBREG_BYTE (x
), GET_MODE (x
));
346 *offset
= (SUBREG_BYTE (x
) / REGMODE_NATURAL_SIZE (GET_MODE (x
)));
350 /* Process registers REG1 and REG2 in move INSN with execution
351 frequency FREQ. The function also processes the registers in a
352 potential move insn (INSN == NULL in this case) with frequency
353 FREQ. The function can modify hard register costs of the
354 corresponding allocnos or create a copy involving the corresponding
355 allocnos. The function does nothing if the both registers are hard
356 registers. When nothing is changed, the function returns
359 process_regs_for_copy (rtx reg1
, rtx reg2
, bool constraint_p
,
362 int allocno_preferenced_hard_regno
, cost
, index
, offset1
, offset2
;
365 enum reg_class rclass
, cover_class
;
366 enum machine_mode mode
;
369 gcc_assert (REG_SUBREG_P (reg1
) && REG_SUBREG_P (reg2
));
370 only_regs_p
= REG_P (reg1
) && REG_P (reg2
);
371 reg1
= go_through_subreg (reg1
, &offset1
);
372 reg2
= go_through_subreg (reg2
, &offset2
);
373 /* Set up hard regno preferenced by allocno. If allocno gets the
374 hard regno the copy (or potential move) insn will be removed. */
375 if (HARD_REGISTER_P (reg1
))
377 if (HARD_REGISTER_P (reg2
))
379 allocno_preferenced_hard_regno
= REGNO (reg1
) + offset1
- offset2
;
380 a
= ira_curr_regno_allocno_map
[REGNO (reg2
)];
382 else if (HARD_REGISTER_P (reg2
))
384 allocno_preferenced_hard_regno
= REGNO (reg2
) + offset2
- offset1
;
385 a
= ira_curr_regno_allocno_map
[REGNO (reg1
)];
389 ira_allocno_t a1
= ira_curr_regno_allocno_map
[REGNO (reg1
)];
390 ira_allocno_t a2
= ira_curr_regno_allocno_map
[REGNO (reg2
)];
391 if (!allocnos_conflict_p (a1
, a2
) && offset1
== offset2
)
393 cp
= ira_add_allocno_copy (a1
, a2
, freq
, constraint_p
, insn
,
394 ira_curr_loop_tree_node
);
395 bitmap_set_bit (ira_curr_loop_tree_node
->local_copies
, cp
->num
);
402 if (! IN_RANGE (allocno_preferenced_hard_regno
, 0, FIRST_PSEUDO_REGISTER
- 1))
403 /* Can not be tied. */
405 rclass
= REGNO_REG_CLASS (allocno_preferenced_hard_regno
);
406 mode
= ALLOCNO_MODE (a
);
407 cover_class
= ALLOCNO_COVER_CLASS (a
);
408 if (only_regs_p
&& insn
!= NULL_RTX
409 && reg_class_size
[rclass
] <= (unsigned) CLASS_MAX_NREGS (rclass
, mode
))
410 /* It is already taken into account in ira-costs.c. */
412 index
= ira_class_hard_reg_index
[cover_class
][allocno_preferenced_hard_regno
];
414 /* Can not be tied. It is not in the cover class. */
416 if (HARD_REGISTER_P (reg1
))
417 cost
= ira_get_register_move_cost (mode
, cover_class
, rclass
) * freq
;
419 cost
= ira_get_register_move_cost (mode
, rclass
, cover_class
) * freq
;
422 ira_allocate_and_set_costs
423 (&ALLOCNO_HARD_REG_COSTS (a
), cover_class
,
424 ALLOCNO_COVER_CLASS_COST (a
));
425 ira_allocate_and_set_costs
426 (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a
), cover_class
, 0);
427 ALLOCNO_HARD_REG_COSTS (a
)[index
] -= cost
;
428 ALLOCNO_CONFLICT_HARD_REG_COSTS (a
)[index
] -= cost
;
429 if (ALLOCNO_HARD_REG_COSTS (a
)[index
] < ALLOCNO_COVER_CLASS_COST (a
))
430 ALLOCNO_COVER_CLASS_COST (a
) = ALLOCNO_HARD_REG_COSTS (a
)[index
];
431 a
= ira_parent_or_cap_allocno (a
);
437 /* Process all of the output registers of the current insn which are
438 not bound (BOUND_P) and the input register REG (its operand number
439 OP_NUM) which dies in the insn as if there were a move insn between
440 them with frequency FREQ. */
442 process_reg_shuffles (rtx reg
, int op_num
, int freq
, bool *bound_p
)
447 gcc_assert (REG_SUBREG_P (reg
));
448 for (i
= 0; i
< recog_data
.n_operands
; i
++)
450 another_reg
= recog_data
.operand
[i
];
452 if (!REG_SUBREG_P (another_reg
) || op_num
== i
453 || recog_data
.operand_type
[i
] != OP_OUT
457 process_regs_for_copy (reg
, another_reg
, false, NULL_RTX
, freq
);
461 /* Process INSN and create allocno copies if necessary. For example,
462 it might be because INSN is a pseudo-register move or INSN is two
465 add_insn_allocno_copies (rtx insn
)
467 rtx set
, operand
, dup
;
469 bool commut_p
, bound_p
[MAX_RECOG_OPERANDS
];
472 freq
= REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn
));
475 if ((set
= single_set (insn
)) != NULL_RTX
476 && REG_SUBREG_P (SET_DEST (set
)) && REG_SUBREG_P (SET_SRC (set
))
477 && ! side_effects_p (set
)
478 && find_reg_note (insn
, REG_DEAD
,
479 REG_P (SET_SRC (set
))
481 : SUBREG_REG (SET_SRC (set
))) != NULL_RTX
)
483 process_regs_for_copy (SET_DEST (set
), SET_SRC (set
), false, insn
, freq
);
486 /* Fast check of possibility of constraint or shuffle copies. If
487 there are no dead registers, there will be no such copies. */
488 if (! find_reg_note (insn
, REG_DEAD
, NULL_RTX
))
491 for (i
= 0; i
< recog_data
.n_operands
; i
++)
493 for (i
= 0; i
< recog_data
.n_operands
; i
++)
495 operand
= recog_data
.operand
[i
];
496 if (! REG_SUBREG_P (operand
))
498 str
= recog_data
.constraints
[i
];
499 while (*str
== ' ' || *str
== '\t')
501 for (j
= 0, commut_p
= false; j
< 2; j
++, commut_p
= true)
502 if ((n
= get_dup_num (i
, commut_p
)) >= 0)
505 dup
= recog_data
.operand
[n
];
506 if (REG_SUBREG_P (dup
)
507 && find_reg_note (insn
, REG_DEAD
,
510 : SUBREG_REG (operand
)) != NULL_RTX
)
511 process_regs_for_copy (operand
, dup
, true, NULL_RTX
, freq
);
514 for (i
= 0; i
< recog_data
.n_operands
; i
++)
516 operand
= recog_data
.operand
[i
];
517 if (REG_SUBREG_P (operand
)
518 && find_reg_note (insn
, REG_DEAD
,
520 ? operand
: SUBREG_REG (operand
)) != NULL_RTX
)
521 /* If an operand dies, prefer its hard register for the output
522 operands by decreasing the hard register cost or creating
523 the corresponding allocno copies. The cost will not
524 correspond to a real move insn cost, so make the frequency
526 process_reg_shuffles (operand
, i
, freq
< 8 ? 1 : freq
/ 8, bound_p
);
530 /* Add copies originated from BB given by LOOP_TREE_NODE. */
532 add_copies (ira_loop_tree_node_t loop_tree_node
)
537 bb
= loop_tree_node
->bb
;
540 FOR_BB_INSNS (bb
, insn
)
541 if (NONDEBUG_INSN_P (insn
))
542 add_insn_allocno_copies (insn
);
545 /* Propagate copies the corresponding allocnos on upper loop tree
548 propagate_copies (void)
551 ira_copy_iterator ci
;
552 ira_allocno_t a1
, a2
, parent_a1
, parent_a2
;
554 FOR_EACH_COPY (cp
, ci
)
558 if (ALLOCNO_LOOP_TREE_NODE (a1
) == ira_loop_tree_root
)
560 ira_assert ((ALLOCNO_LOOP_TREE_NODE (a2
) != ira_loop_tree_root
));
561 parent_a1
= ira_parent_or_cap_allocno (a1
);
562 parent_a2
= ira_parent_or_cap_allocno (a2
);
563 ira_assert (parent_a1
!= NULL
&& parent_a2
!= NULL
);
564 if (! allocnos_conflict_p (parent_a1
, parent_a2
))
565 ira_add_allocno_copy (parent_a1
, parent_a2
, cp
->freq
,
566 cp
->constraint_p
, cp
->insn
, cp
->loop_tree_node
);
570 /* Array used to collect all conflict allocnos for given allocno. */
571 static ira_object_t
*collected_conflict_objects
;
573 /* Build conflict vectors or bit conflict vectors (whatever is more
574 profitable) for allocno A from the conflict table and propagate the
575 conflicts to upper level allocno. */
577 build_allocno_conflicts (ira_allocno_t a
)
579 int i
, px
, parent_num
;
580 int conflict_bit_vec_words_num
;
581 ira_allocno_t parent_a
, another_parent_a
;
583 IRA_INT_TYPE
*allocno_conflicts
;
584 ira_object_t obj
, parent_obj
;
585 minmax_set_iterator asi
;
587 obj
= ALLOCNO_OBJECT (a
);
588 allocno_conflicts
= conflicts
[OBJECT_CONFLICT_ID (obj
)];
590 FOR_EACH_BIT_IN_MINMAX_SET (allocno_conflicts
,
591 OBJECT_MIN (obj
), OBJECT_MAX (obj
), i
, asi
)
593 ira_object_t another_obj
= ira_object_id_map
[i
];
594 ira_allocno_t another_a
= OBJECT_ALLOCNO (obj
);
595 ira_assert (ira_reg_classes_intersect_p
596 [ALLOCNO_COVER_CLASS (a
)][ALLOCNO_COVER_CLASS (another_a
)]);
597 collected_conflict_objects
[px
++] = another_obj
;
599 if (ira_conflict_vector_profitable_p (obj
, px
))
601 ira_allocate_conflict_vec (obj
, px
);
602 vec
= OBJECT_CONFLICT_VEC (obj
);
603 memcpy (vec
, collected_conflict_objects
, sizeof (ira_object_t
) * px
);
605 OBJECT_NUM_CONFLICTS (obj
) = px
;
609 OBJECT_CONFLICT_ARRAY (obj
) = allocno_conflicts
;
610 if (OBJECT_MAX (obj
) < OBJECT_MIN (obj
))
611 conflict_bit_vec_words_num
= 0;
613 conflict_bit_vec_words_num
614 = ((OBJECT_MAX (obj
) - OBJECT_MIN (obj
) + IRA_INT_BITS
)
616 OBJECT_CONFLICT_ARRAY_SIZE (obj
)
617 = conflict_bit_vec_words_num
* sizeof (IRA_INT_TYPE
);
619 parent_a
= ira_parent_or_cap_allocno (a
);
620 if (parent_a
== NULL
)
622 ira_assert (ALLOCNO_COVER_CLASS (a
) == ALLOCNO_COVER_CLASS (parent_a
));
623 parent_obj
= ALLOCNO_OBJECT (parent_a
);
624 parent_num
= OBJECT_CONFLICT_ID (parent_obj
);
625 FOR_EACH_BIT_IN_MINMAX_SET (allocno_conflicts
,
626 OBJECT_MIN (obj
), OBJECT_MAX (obj
), i
, asi
)
628 ira_object_t another_obj
= ira_object_id_map
[i
];
629 ira_allocno_t another_a
= OBJECT_ALLOCNO (another_obj
);
631 ira_assert (ira_reg_classes_intersect_p
632 [ALLOCNO_COVER_CLASS (a
)][ALLOCNO_COVER_CLASS (another_a
)]);
633 another_parent_a
= ira_parent_or_cap_allocno (another_a
);
634 if (another_parent_a
== NULL
)
636 ira_assert (ALLOCNO_NUM (another_parent_a
) >= 0);
637 ira_assert (ALLOCNO_COVER_CLASS (another_a
)
638 == ALLOCNO_COVER_CLASS (another_parent_a
));
639 SET_MINMAX_SET_BIT (conflicts
[parent_num
],
640 OBJECT_CONFLICT_ID (ALLOCNO_OBJECT (another_parent_a
)),
641 OBJECT_MIN (parent_obj
),
642 OBJECT_MAX (parent_obj
));
646 /* Build conflict vectors or bit conflict vectors (whatever is more
647 profitable) of all allocnos from the conflict table. */
649 build_conflicts (void)
652 ira_allocno_t a
, cap
;
654 collected_conflict_objects
655 = (ira_object_t
*) ira_allocate (sizeof (ira_object_t
)
657 for (i
= max_reg_num () - 1; i
>= FIRST_PSEUDO_REGISTER
; i
--)
658 for (a
= ira_regno_allocno_map
[i
];
660 a
= ALLOCNO_NEXT_REGNO_ALLOCNO (a
))
662 build_allocno_conflicts (a
);
663 for (cap
= ALLOCNO_CAP (a
); cap
!= NULL
; cap
= ALLOCNO_CAP (cap
))
664 build_allocno_conflicts (cap
);
666 ira_free (collected_conflict_objects
);
671 /* Print hard reg set SET with TITLE to FILE. */
673 print_hard_reg_set (FILE *file
, const char *title
, HARD_REG_SET set
)
678 for (start
= -1, i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
680 if (TEST_HARD_REG_BIT (set
, i
))
682 if (i
== 0 || ! TEST_HARD_REG_BIT (set
, i
- 1))
686 && (i
== FIRST_PSEUDO_REGISTER
- 1 || ! TEST_HARD_REG_BIT (set
, i
)))
689 fprintf (file
, " %d", start
);
690 else if (start
== i
- 2)
691 fprintf (file
, " %d %d", start
, start
+ 1);
693 fprintf (file
, " %d-%d", start
, i
- 1);
701 print_allocno_conflicts (FILE * file
, bool reg_p
, ira_allocno_t a
)
703 HARD_REG_SET conflicting_hard_regs
;
705 ira_allocno_t conflict_a
;
706 ira_allocno_conflict_iterator aci
;
710 fprintf (file
, ";; r%d", ALLOCNO_REGNO (a
));
713 fprintf (file
, ";; a%d(r%d,", ALLOCNO_NUM (a
), ALLOCNO_REGNO (a
));
714 if ((bb
= ALLOCNO_LOOP_TREE_NODE (a
)->bb
) != NULL
)
715 fprintf (file
, "b%d", bb
->index
);
717 fprintf (file
, "l%d", ALLOCNO_LOOP_TREE_NODE (a
)->loop
->num
);
721 fputs (" conflicts:", file
);
722 obj
= ALLOCNO_OBJECT (a
);
723 if (OBJECT_CONFLICT_ARRAY (obj
) != NULL
)
724 FOR_EACH_ALLOCNO_CONFLICT (a
, conflict_a
, aci
)
727 fprintf (file
, " r%d,", ALLOCNO_REGNO (conflict_a
));
730 fprintf (file
, " a%d(r%d,", ALLOCNO_NUM (conflict_a
),
731 ALLOCNO_REGNO (conflict_a
));
732 if ((bb
= ALLOCNO_LOOP_TREE_NODE (conflict_a
)->bb
) != NULL
)
733 fprintf (file
, "b%d)", bb
->index
);
735 fprintf (file
, "l%d)",
736 ALLOCNO_LOOP_TREE_NODE (conflict_a
)->loop
->num
);
740 COPY_HARD_REG_SET (conflicting_hard_regs
, OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
));
741 AND_COMPL_HARD_REG_SET (conflicting_hard_regs
, ira_no_alloc_regs
);
742 AND_HARD_REG_SET (conflicting_hard_regs
,
743 reg_class_contents
[ALLOCNO_COVER_CLASS (a
)]);
744 print_hard_reg_set (file
, "\n;; total conflict hard regs:",
745 conflicting_hard_regs
);
747 COPY_HARD_REG_SET (conflicting_hard_regs
, OBJECT_CONFLICT_HARD_REGS (obj
));
748 AND_COMPL_HARD_REG_SET (conflicting_hard_regs
, ira_no_alloc_regs
);
749 AND_HARD_REG_SET (conflicting_hard_regs
,
750 reg_class_contents
[ALLOCNO_COVER_CLASS (a
)]);
751 print_hard_reg_set (file
, ";; conflict hard regs:",
752 conflicting_hard_regs
);
756 /* Print information about allocno or only regno (if REG_P) conflicts
759 print_conflicts (FILE *file
, bool reg_p
)
762 ira_allocno_iterator ai
;
764 FOR_EACH_ALLOCNO (a
, ai
)
765 print_allocno_conflicts (file
, reg_p
, a
);
768 /* Print information about allocno or only regno (if REG_P) conflicts
771 ira_debug_conflicts (bool reg_p
)
773 print_conflicts (stderr
, reg_p
);
778 /* Entry function which builds allocno conflicts and allocno copies
779 and accumulate some allocno info on upper level regions. */
781 ira_build_conflicts (void)
784 ira_allocno_iterator ai
;
785 HARD_REG_SET temp_hard_reg_set
;
789 ira_conflicts_p
= build_conflict_bit_table ();
793 ira_object_iterator oi
;
796 ira_traverse_loop_tree (true, ira_loop_tree_root
, NULL
, add_copies
);
797 /* We need finished conflict table for the subsequent call. */
798 if (flag_ira_region
== IRA_REGION_ALL
799 || flag_ira_region
== IRA_REGION_MIXED
)
802 /* Now we can free memory for the conflict table (see function
803 build_allocno_conflicts for details). */
804 FOR_EACH_OBJECT (obj
, oi
)
806 if (OBJECT_CONFLICT_ARRAY (obj
) != conflicts
[OBJECT_CONFLICT_ID (obj
)])
807 ira_free (conflicts
[OBJECT_CONFLICT_ID (obj
)]);
809 ira_free (conflicts
);
812 if (! CLASS_LIKELY_SPILLED_P (base_reg_class (VOIDmode
, ADDRESS
, SCRATCH
)))
813 CLEAR_HARD_REG_SET (temp_hard_reg_set
);
816 COPY_HARD_REG_SET (temp_hard_reg_set
,
817 reg_class_contents
[base_reg_class (VOIDmode
, ADDRESS
, SCRATCH
)]);
818 AND_COMPL_HARD_REG_SET (temp_hard_reg_set
, ira_no_alloc_regs
);
819 AND_HARD_REG_SET (temp_hard_reg_set
, call_used_reg_set
);
821 FOR_EACH_ALLOCNO (a
, ai
)
823 ira_object_t obj
= ALLOCNO_OBJECT (a
);
827 if ((! flag_caller_saves
&& ALLOCNO_CALLS_CROSSED_NUM (a
) != 0)
828 /* For debugging purposes don't put user defined variables in
829 callee-clobbered registers. */
831 && (attrs
= REG_ATTRS (regno_reg_rtx
[ALLOCNO_REGNO (a
)])) != NULL
832 && (decl
= attrs
->decl
) != NULL
833 && VAR_OR_FUNCTION_DECL_P (decl
)
834 && ! DECL_ARTIFICIAL (decl
)))
836 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
), call_used_reg_set
);
837 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
), call_used_reg_set
);
839 else if (ALLOCNO_CALLS_CROSSED_NUM (a
) != 0)
841 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
),
842 no_caller_save_reg_set
);
843 IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj
), temp_hard_reg_set
);
844 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
), no_caller_save_reg_set
);
845 IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj
), temp_hard_reg_set
);
848 if (optimize
&& ira_conflicts_p
849 && internal_flag_ira_verbose
> 2 && ira_dump_file
!= NULL
)
850 print_conflicts (ira_dump_file
, false);