1 /* IRA conflict builder.
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
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"
38 #include "sparseset.h"
41 /* This file contains code responsible for allocno conflict creation,
42 allocno copy creation and allocno info accumulation on upper level
45 /* ira_allocnos_num array of arrays of bits, recording whether two
46 allocno's conflict (can't go in the same hardware register).
48 Some arrays will be used as conflict bit vector of the
49 corresponding allocnos see function build_allocno_conflicts. */
50 static IRA_INT_TYPE **conflicts;
52 /* Macro to test a conflict of A1 and A2 in `conflicts'. */
53 #define CONFLICT_ALLOCNO_P(A1, A2) \
54 (ALLOCNO_MIN (A1) <= ALLOCNO_CONFLICT_ID (A2) \
55 && ALLOCNO_CONFLICT_ID (A2) <= ALLOCNO_MAX (A1) \
56 && TEST_ALLOCNO_SET_BIT (conflicts[ALLOCNO_NUM (A1)], \
57 ALLOCNO_CONFLICT_ID (A2), \
63 /* Build allocno conflict table by processing allocno live ranges. */
65 build_conflict_bit_table (void)
67 int i, num, id, allocated_words_num, conflict_bit_vec_words_num;
69 enum reg_class cover_class;
70 ira_allocno_t allocno, live_a;
71 allocno_live_range_t r;
72 ira_allocno_iterator ai;
73 sparseset allocnos_live;
74 int allocno_set_words;
76 allocno_set_words = (ira_allocnos_num + IRA_INT_BITS - 1) / IRA_INT_BITS;
77 allocnos_live = sparseset_alloc (ira_allocnos_num);
78 conflicts = (IRA_INT_TYPE **) ira_allocate (sizeof (IRA_INT_TYPE *)
80 allocated_words_num = 0;
81 FOR_EACH_ALLOCNO (allocno, ai)
83 num = ALLOCNO_NUM (allocno);
84 if (ALLOCNO_MAX (allocno) < ALLOCNO_MIN (allocno))
86 conflicts[num] = NULL;
89 conflict_bit_vec_words_num
90 = ((ALLOCNO_MAX (allocno) - ALLOCNO_MIN (allocno) + IRA_INT_BITS)
92 allocated_words_num += conflict_bit_vec_words_num;
94 = (IRA_INT_TYPE *) ira_allocate (sizeof (IRA_INT_TYPE)
95 * conflict_bit_vec_words_num);
96 memset (conflicts[num], 0,
97 sizeof (IRA_INT_TYPE) * conflict_bit_vec_words_num);
99 if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
102 "+++Allocating %ld bytes for conflict table (uncompressed size %ld)\n",
103 (long) allocated_words_num * sizeof (IRA_INT_TYPE),
104 (long) allocno_set_words * ira_allocnos_num * sizeof (IRA_INT_TYPE));
105 for (i = 0; i < ira_max_point; i++)
107 for (r = ira_start_point_ranges[i]; r != NULL; r = r->start_next)
109 allocno = r->allocno;
110 num = ALLOCNO_NUM (allocno);
111 id = ALLOCNO_CONFLICT_ID (allocno);
112 cover_class = ALLOCNO_COVER_CLASS (allocno);
113 sparseset_set_bit (allocnos_live, num);
114 EXECUTE_IF_SET_IN_SPARSESET (allocnos_live, j)
116 live_a = ira_allocnos[j];
117 if (cover_class == ALLOCNO_COVER_CLASS (live_a)
118 /* Don't set up conflict for the allocno with itself. */
121 SET_ALLOCNO_SET_BIT (conflicts[num],
122 ALLOCNO_CONFLICT_ID (live_a),
123 ALLOCNO_MIN (allocno),
124 ALLOCNO_MAX (allocno));
125 SET_ALLOCNO_SET_BIT (conflicts[j], id,
126 ALLOCNO_MIN (live_a),
127 ALLOCNO_MAX (live_a));
132 for (r = ira_finish_point_ranges[i]; r != NULL; r = r->finish_next)
133 sparseset_clear_bit (allocnos_live, ALLOCNO_NUM (r->allocno));
135 sparseset_free (allocnos_live);
140 /* Return TRUE if the operand constraint STR is commutative. */
142 commutative_constraint_p (const char *str)
147 for (ignore_p = false;;)
152 str += CONSTRAINT_LEN (c, str);
159 /* Usually `%' is the first constraint character but the
160 documentation does not require this. */
168 /* Return the number of the operand which should be the same in any
169 case as operand with number OP_NUM (or negative value if there is
170 no such operand). If USE_COMMUT_OP_P is TRUE, the function makes
171 temporarily commutative operand exchange before this. The function
172 takes only really possible alternatives into consideration. */
174 get_dup_num (int op_num, bool use_commut_op_p)
176 int curr_alt, c, original, dup;
177 bool ignore_p, commut_op_used_p;
181 if (op_num < 0 || recog_data.n_alternatives == 0)
183 op = recog_data.operand[op_num];
184 commut_op_used_p = true;
187 if (commutative_constraint_p (recog_data.constraints[op_num]))
189 else if (op_num > 0 && commutative_constraint_p (recog_data.constraints
193 commut_op_used_p = false;
195 str = recog_data.constraints[op_num];
196 for (ignore_p = false, original = -1, curr_alt = 0;;)
216 /* Accept a register which might be placed in memory. */
226 GO_IF_LEGITIMATE_ADDRESS (VOIDmode, op, win_p);
236 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
237 case 'h': case 'j': case 'k': case 'l':
238 case 'q': case 't': case 'u':
239 case 'v': case 'w': case 'x': case 'y': case 'z':
240 case 'A': case 'B': case 'C': case 'D':
241 case 'Q': case 'R': case 'S': case 'T': case 'U':
242 case 'W': case 'Y': case 'Z':
247 ? GENERAL_REGS : REG_CLASS_FROM_CONSTRAINT (c, str));
250 #ifdef EXTRA_CONSTRAINT_STR
251 else if (EXTRA_CONSTRAINT_STR (op, c, str))
257 case '0': case '1': case '2': case '3': case '4':
258 case '5': case '6': case '7': case '8': case '9':
259 if (original != -1 && original != c)
264 str += CONSTRAINT_LEN (c, str);
268 dup = original - '0';
271 if (commutative_constraint_p (recog_data.constraints[dup]))
274 && commutative_constraint_p (recog_data.constraints[dup -1]))
276 else if (! commut_op_used_p)
282 /* Return the operand which should be, in any case, the same as
283 operand with number OP_NUM. If USE_COMMUT_OP_P is TRUE, the
284 function makes temporarily commutative operand exchange before
287 get_dup (int op_num, bool use_commut_op_p)
289 int n = get_dup_num (op_num, use_commut_op_p);
294 return recog_data.operand[n];
297 /* Check that X is REG or SUBREG of REG. */
298 #define REG_SUBREG_P(x) \
299 (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))))
301 /* Return X if X is a REG, otherwise it should be SUBREG of REG and
302 the function returns the reg in this case. *OFFSET will be set to
303 0 in the first case or the regno offset in the first case. */
305 go_through_subreg (rtx x, int *offset)
312 ira_assert (GET_CODE (x) == SUBREG);
313 reg = SUBREG_REG (x);
314 ira_assert (REG_P (reg));
315 if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
316 *offset = subreg_regno_offset (REGNO (reg), GET_MODE (reg),
317 SUBREG_BYTE (x), GET_MODE (x));
319 *offset = (SUBREG_BYTE (x) / REGMODE_NATURAL_SIZE (GET_MODE (x)));
323 /* Process registers REG1 and REG2 in move INSN with execution
324 frequency FREQ. The function also processes the registers in a
325 potential move insn (INSN == NULL in this case) with frequency
326 FREQ. The function can modify hard register costs of the
327 corresponding allocnos or create a copy involving the corresponding
328 allocnos. The function does nothing if the both registers are hard
329 registers. When nothing is changed, the function returns
332 process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
335 int allocno_preferenced_hard_regno, cost, index, offset1, offset2;
338 enum reg_class rclass, cover_class;
339 enum machine_mode mode;
341 ira_loop_tree_node_t parent;
343 gcc_assert (REG_SUBREG_P (reg1) && REG_SUBREG_P (reg2));
344 only_regs_p = REG_P (reg1) && REG_P (reg2);
345 reg1 = go_through_subreg (reg1, &offset1);
346 reg2 = go_through_subreg (reg2, &offset2);
347 /* Set up hard regno preferenced by allocno. If allocno gets the
348 hard regno the copy (or potential move) insn will be removed. */
349 if (HARD_REGISTER_P (reg1))
351 if (HARD_REGISTER_P (reg2))
353 allocno_preferenced_hard_regno = REGNO (reg1) + offset1 - offset2;
354 a = ira_curr_regno_allocno_map[REGNO (reg2)];
356 else if (HARD_REGISTER_P (reg2))
358 allocno_preferenced_hard_regno = REGNO (reg2) + offset2 - offset1;
359 a = ira_curr_regno_allocno_map[REGNO (reg1)];
361 else if (!CONFLICT_ALLOCNO_P (ira_curr_regno_allocno_map[REGNO (reg1)],
362 ira_curr_regno_allocno_map[REGNO (reg2)])
363 && offset1 == offset2)
365 cp = ira_add_allocno_copy (ira_curr_regno_allocno_map[REGNO (reg1)],
366 ira_curr_regno_allocno_map[REGNO (reg2)],
367 freq, constraint_p, insn,
368 ira_curr_loop_tree_node);
369 bitmap_set_bit (ira_curr_loop_tree_node->local_copies, cp->num);
374 if (! IN_RANGE (allocno_preferenced_hard_regno, 0, FIRST_PSEUDO_REGISTER - 1))
375 /* Can not be tied. */
377 rclass = REGNO_REG_CLASS (allocno_preferenced_hard_regno);
378 mode = ALLOCNO_MODE (a);
379 cover_class = ALLOCNO_COVER_CLASS (a);
380 if (only_regs_p && insn != NULL_RTX
381 && reg_class_size[rclass] <= (unsigned) CLASS_MAX_NREGS (rclass, mode))
382 /* It is already taken into account in ira-costs.c. */
384 index = ira_class_hard_reg_index[cover_class][allocno_preferenced_hard_regno];
386 /* Can not be tied. It is not in the cover class. */
388 if (HARD_REGISTER_P (reg1))
389 cost = ira_register_move_cost[mode][cover_class][rclass] * freq;
391 cost = ira_register_move_cost[mode][rclass][cover_class] * freq;
394 ira_allocate_and_set_costs
395 (&ALLOCNO_HARD_REG_COSTS (a), cover_class,
396 ALLOCNO_COVER_CLASS_COST (a));
397 ira_allocate_and_set_costs
398 (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a), cover_class, 0);
399 ALLOCNO_HARD_REG_COSTS (a)[index] -= cost;
400 ALLOCNO_CONFLICT_HARD_REG_COSTS (a)[index] -= cost;
401 if (ALLOCNO_HARD_REG_COSTS (a)[index] < ALLOCNO_COVER_CLASS_COST (a))
402 ALLOCNO_COVER_CLASS_COST (a) = ALLOCNO_HARD_REG_COSTS (a)[index];
403 if (ALLOCNO_CAP (a) != NULL)
405 else if ((parent = ALLOCNO_LOOP_TREE_NODE (a)->parent) == NULL
406 || (a = parent->regno_allocno_map[ALLOCNO_REGNO (a)]) == NULL)
412 /* Process all of the output registers of the current insn and
413 the input register REG (its operand number OP_NUM) which dies in the
414 insn as if there were a move insn between them with frequency
417 process_reg_shuffles (rtx reg, int op_num, int freq)
422 gcc_assert (REG_SUBREG_P (reg));
423 for (i = 0; i < recog_data.n_operands; i++)
425 another_reg = recog_data.operand[i];
427 if (!REG_SUBREG_P (another_reg) || op_num == i
428 || recog_data.operand_type[i] != OP_OUT)
431 process_regs_for_copy (reg, another_reg, false, NULL_RTX, freq);
435 /* Process INSN and create allocno copies if necessary. For example,
436 it might be because INSN is a pseudo-register move or INSN is two
439 add_insn_allocno_copies (rtx insn)
441 rtx set, operand, dup;
443 bool commut_p, bound_p;
446 freq = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn));
449 if ((set = single_set (insn)) != NULL_RTX
450 && REG_SUBREG_P (SET_DEST (set)) && REG_SUBREG_P (SET_SRC (set))
451 && ! side_effects_p (set)
452 && find_reg_note (insn, REG_DEAD,
453 REG_P (SET_SRC (set))
455 : SUBREG_REG (SET_SRC (set))) != NULL_RTX)
456 process_regs_for_copy (SET_DEST (set), SET_SRC (set), false, insn, freq);
460 for (i = 0; i < recog_data.n_operands; i++)
462 operand = recog_data.operand[i];
463 if (REG_SUBREG_P (operand)
464 && find_reg_note (insn, REG_DEAD,
466 ? operand : SUBREG_REG (operand)) != NULL_RTX)
468 str = recog_data.constraints[i];
469 while (*str == ' ' && *str == '\t')
472 for (j = 0, commut_p = false; j < 2; j++, commut_p = true)
473 if ((dup = get_dup (i, commut_p)) != NULL_RTX
474 && REG_SUBREG_P (dup)
475 && process_regs_for_copy (operand, dup, true,
480 /* If an operand dies, prefer its hard register for the
481 output operands by decreasing the hard register cost
482 or creating the corresponding allocno copies. The
483 cost will not correspond to a real move insn cost, so
484 make the frequency smaller. */
485 process_reg_shuffles (operand, i, freq < 8 ? 1 : freq / 8);
491 /* Add copies originated from BB given by LOOP_TREE_NODE. */
493 add_copies (ira_loop_tree_node_t loop_tree_node)
498 bb = loop_tree_node->bb;
501 FOR_BB_INSNS (bb, insn)
503 add_insn_allocno_copies (insn);
506 /* Propagate copies the corresponding allocnos on upper loop tree
509 propagate_copies (void)
512 ira_copy_iterator ci;
513 ira_allocno_t a1, a2, parent_a1, parent_a2;
514 ira_loop_tree_node_t parent;
516 FOR_EACH_COPY (cp, ci)
520 if (ALLOCNO_LOOP_TREE_NODE (a1) == ira_loop_tree_root)
522 ira_assert ((ALLOCNO_LOOP_TREE_NODE (a2) != ira_loop_tree_root));
523 parent = ALLOCNO_LOOP_TREE_NODE (a1)->parent;
524 if ((parent_a1 = ALLOCNO_CAP (a1)) == NULL)
525 parent_a1 = parent->regno_allocno_map[ALLOCNO_REGNO (a1)];
526 if ((parent_a2 = ALLOCNO_CAP (a2)) == NULL)
527 parent_a2 = parent->regno_allocno_map[ALLOCNO_REGNO (a2)];
528 ira_assert (parent_a1 != NULL && parent_a2 != NULL);
529 if (! CONFLICT_ALLOCNO_P (parent_a1, parent_a2))
530 ira_add_allocno_copy (parent_a1, parent_a2, cp->freq,
531 cp->constraint_p, cp->insn, cp->loop_tree_node);
535 /* Array used to collect all conflict allocnos for given allocno. */
536 static ira_allocno_t *collected_conflict_allocnos;
538 /* Build conflict vectors or bit conflict vectors (whatever is more
539 profitable) for allocno A from the conflict table and propagate the
540 conflicts to upper level allocno. */
542 build_allocno_conflicts (ira_allocno_t a)
544 int i, px, parent_num;
545 int conflict_bit_vec_words_num;
546 ira_loop_tree_node_t parent;
547 ira_allocno_t parent_a, another_a, another_parent_a;
549 IRA_INT_TYPE *allocno_conflicts;
550 ira_allocno_set_iterator asi;
552 allocno_conflicts = conflicts[ALLOCNO_NUM (a)];
554 FOR_EACH_ALLOCNO_IN_SET (allocno_conflicts,
555 ALLOCNO_MIN (a), ALLOCNO_MAX (a), i, asi)
557 another_a = ira_conflict_id_allocno_map[i];
558 ira_assert (ALLOCNO_COVER_CLASS (a)
559 == ALLOCNO_COVER_CLASS (another_a));
560 collected_conflict_allocnos[px++] = another_a;
562 if (ira_conflict_vector_profitable_p (a, px))
564 ira_allocate_allocno_conflict_vec (a, px);
565 vec = (ira_allocno_t*) ALLOCNO_CONFLICT_ALLOCNO_ARRAY (a);
566 memcpy (vec, collected_conflict_allocnos, sizeof (ira_allocno_t) * px);
568 ALLOCNO_CONFLICT_ALLOCNOS_NUM (a) = px;
572 ALLOCNO_CONFLICT_ALLOCNO_ARRAY (a) = conflicts[ALLOCNO_NUM (a)];
573 if (ALLOCNO_MAX (a) < ALLOCNO_MIN (a))
574 conflict_bit_vec_words_num = 0;
576 conflict_bit_vec_words_num
577 = ((ALLOCNO_MAX (a) - ALLOCNO_MIN (a) + IRA_INT_BITS)
579 ALLOCNO_CONFLICT_ALLOCNO_ARRAY_SIZE (a)
580 = conflict_bit_vec_words_num * sizeof (IRA_INT_TYPE);
582 parent = ALLOCNO_LOOP_TREE_NODE (a)->parent;
583 if ((parent_a = ALLOCNO_CAP (a)) == NULL
585 || (parent_a = parent->regno_allocno_map[ALLOCNO_REGNO (a)])
588 ira_assert (parent != NULL);
589 ira_assert (ALLOCNO_COVER_CLASS (a) == ALLOCNO_COVER_CLASS (parent_a));
590 parent_num = ALLOCNO_NUM (parent_a);
591 FOR_EACH_ALLOCNO_IN_SET (allocno_conflicts,
592 ALLOCNO_MIN (a), ALLOCNO_MAX (a), i, asi)
594 another_a = ira_conflict_id_allocno_map[i];
595 ira_assert (ALLOCNO_COVER_CLASS (a)
596 == ALLOCNO_COVER_CLASS (another_a));
597 if ((another_parent_a = ALLOCNO_CAP (another_a)) == NULL
598 && (another_parent_a = (parent->regno_allocno_map
599 [ALLOCNO_REGNO (another_a)])) == NULL)
601 ira_assert (ALLOCNO_NUM (another_parent_a) >= 0);
602 ira_assert (ALLOCNO_COVER_CLASS (another_a)
603 == ALLOCNO_COVER_CLASS (another_parent_a));
604 SET_ALLOCNO_SET_BIT (conflicts[parent_num],
605 ALLOCNO_CONFLICT_ID (another_parent_a),
606 ALLOCNO_MIN (parent_a),
607 ALLOCNO_MAX (parent_a));
611 /* Build conflict vectors or bit conflict vectors (whatever is more
612 profitable) of all allocnos from the conflict table. */
614 build_conflicts (void)
617 ira_allocno_t a, cap;
619 collected_conflict_allocnos
620 = (ira_allocno_t *) ira_allocate (sizeof (ira_allocno_t)
622 for (i = max_reg_num () - 1; i >= FIRST_PSEUDO_REGISTER; i--)
623 for (a = ira_regno_allocno_map[i];
625 a = ALLOCNO_NEXT_REGNO_ALLOCNO (a))
627 build_allocno_conflicts (a);
628 for (cap = ALLOCNO_CAP (a); cap != NULL; cap = ALLOCNO_CAP (cap))
629 build_allocno_conflicts (cap);
631 ira_free (collected_conflict_allocnos);
636 /* Print hard reg set SET with TITLE to FILE. */
638 print_hard_reg_set (FILE *file, const char *title, HARD_REG_SET set)
642 fprintf (file, title);
643 for (start = -1, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
645 if (TEST_HARD_REG_BIT (set, i))
647 if (i == 0 || ! TEST_HARD_REG_BIT (set, i - 1))
651 && (i == FIRST_PSEUDO_REGISTER - 1 || ! TEST_HARD_REG_BIT (set, i)))
654 fprintf (file, " %d", start);
655 else if (start == i - 2)
656 fprintf (file, " %d %d", start, start + 1);
658 fprintf (file, " %d-%d", start, i - 1);
662 fprintf (file, "\n");
665 /* Print information about allocno or only regno (if REG_P) conflicts
668 print_conflicts (FILE *file, bool reg_p)
671 ira_allocno_iterator ai;
672 HARD_REG_SET conflicting_hard_regs;
674 FOR_EACH_ALLOCNO (a, ai)
676 ira_allocno_t conflict_a;
677 ira_allocno_conflict_iterator aci;
681 fprintf (file, ";; r%d", ALLOCNO_REGNO (a));
684 fprintf (file, ";; a%d(r%d,", ALLOCNO_NUM (a), ALLOCNO_REGNO (a));
685 if ((bb = ALLOCNO_LOOP_TREE_NODE (a)->bb) != NULL)
686 fprintf (file, "b%d", bb->index);
688 fprintf (file, "l%d", ALLOCNO_LOOP_TREE_NODE (a)->loop->num);
691 fprintf (file, " conflicts:");
692 if (ALLOCNO_CONFLICT_ALLOCNO_ARRAY (a) != NULL)
693 FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci)
696 fprintf (file, " r%d,", ALLOCNO_REGNO (conflict_a));
699 fprintf (file, " a%d(r%d,", ALLOCNO_NUM (conflict_a),
700 ALLOCNO_REGNO (conflict_a));
701 if ((bb = ALLOCNO_LOOP_TREE_NODE (conflict_a)->bb) != NULL)
702 fprintf (file, "b%d)", bb->index);
704 fprintf (file, "l%d)",
705 ALLOCNO_LOOP_TREE_NODE (conflict_a)->loop->num);
708 COPY_HARD_REG_SET (conflicting_hard_regs,
709 ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a));
710 AND_COMPL_HARD_REG_SET (conflicting_hard_regs, ira_no_alloc_regs);
711 AND_HARD_REG_SET (conflicting_hard_regs,
712 reg_class_contents[ALLOCNO_COVER_CLASS (a)]);
713 print_hard_reg_set (file, "\n;; total conflict hard regs:",
714 conflicting_hard_regs);
715 COPY_HARD_REG_SET (conflicting_hard_regs,
716 ALLOCNO_CONFLICT_HARD_REGS (a));
717 AND_COMPL_HARD_REG_SET (conflicting_hard_regs, ira_no_alloc_regs);
718 AND_HARD_REG_SET (conflicting_hard_regs,
719 reg_class_contents[ALLOCNO_COVER_CLASS (a)]);
720 print_hard_reg_set (file, ";; conflict hard regs:",
721 conflicting_hard_regs);
723 fprintf (file, "\n");
726 /* Print information about allocno or only regno (if REG_P) conflicts
729 ira_debug_conflicts (bool reg_p)
731 print_conflicts (stderr, reg_p);
736 /* Entry function which builds allocno conflicts and allocno copies
737 and accumulate some allocno info on upper level regions. */
739 ira_build_conflicts (void)
742 ira_allocno_iterator ai;
746 build_conflict_bit_table ();
748 ira_traverse_loop_tree (true, ira_loop_tree_root, NULL, add_copies);
749 /* We need finished conflict table for the subsequent call. */
750 if (flag_ira_algorithm == IRA_ALGORITHM_REGIONAL
751 || flag_ira_algorithm == IRA_ALGORITHM_MIXED)
753 /* Now we can free memory for the conflict table (see function
754 build_allocno_conflicts for details). */
755 FOR_EACH_ALLOCNO (a, ai)
757 if (ALLOCNO_CONFLICT_ALLOCNO_ARRAY (a) != conflicts[ALLOCNO_NUM (a)])
758 ira_free (conflicts[ALLOCNO_NUM (a)]);
760 ira_free (conflicts);
762 FOR_EACH_ALLOCNO (a, ai)
764 if (ALLOCNO_CALLS_CROSSED_NUM (a) == 0)
766 if (! flag_caller_saves)
768 IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a),
770 if (ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
771 IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a),
776 IOR_HARD_REG_SET (ALLOCNO_TOTAL_CONFLICT_HARD_REGS (a),
777 no_caller_save_reg_set);
778 if (ALLOCNO_CALLS_CROSSED_NUM (a) != 0)
779 IOR_HARD_REG_SET (ALLOCNO_CONFLICT_HARD_REGS (a),
780 no_caller_save_reg_set);
783 if (optimize && internal_flag_ira_verbose > 2 && ira_dump_file != NULL)
784 print_conflicts (ira_dump_file, false);