From patchwork Fri Jun 18 14:12:04 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bernd Schmidt X-Patchwork-Id: 56191 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id A7BF21007D5 for ; Sat, 19 Jun 2010 00:12:35 +1000 (EST) Received: (qmail 17536 invoked by alias); 18 Jun 2010 14:12:32 -0000 Received: (qmail 17446 invoked by uid 22791); 18 Jun 2010 14:12:23 -0000 X-SWARE-Spam-Status: No, hits=-1.9 required=5.0 tests=AWL, BAYES_00, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 18 Jun 2010 14:12:12 +0000 Received: (qmail 3079 invoked from network); 18 Jun 2010 14:12:10 -0000 Received: from unknown (HELO ?84.152.216.85?) (bernds@127.0.0.2) by mail.codesourcery.com with ESMTPA; 18 Jun 2010 14:12:10 -0000 Message-ID: <4C1B7EB4.3080300@codesourcery.com> Date: Fri, 18 Jun 2010 14:12:04 +0000 From: Bernd Schmidt User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.9) Gecko/20100604 Thunderbird/3.0.4 MIME-Version: 1.0 To: GCC Patches Subject: Patch 9/9: change FOR_EACH_ALLOCNO_CONFLICT to use objects References: <4C1B7BC0.7010803@codesourcery.com> In-Reply-To: <4C1B7BC0.7010803@codesourcery.com> Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Now that conflicts are tracked in objects rather than allocnos, this changes FOR_EACH_ALLOCNO_CONFLICT to FOR_EACH_OBJECT_CONFLICT. * ira-int.h (ira_object_conflict_iterator): Rename from ira_allocno_conflict_iterator. (ira_object_conflict_iter_init): Rename from ira_allocno_conflict_iter_init, second arg changed to * ira.c (check_allocation): Use FOR_EACH_OBJECT_CONFLICT rather than FOR_EACH_ALLOCNO_CONFLICT. * ira-color.c (assign_hard_reg, push_allocno_to_stack) setup_allocno_left_conflicts_size, coalesced_allocno_conflict_p, ira_reassign_conflict_allocnos, ira_reassign_pseudos): Likewise. * ira-conflicts.c (print_allocno_conflicts): Likewise. (Index: gcc/ira.c =================================================================== --- gcc.orig/ira.c +++ gcc/ira.c @@ -1748,33 +1748,40 @@ calculate_allocation_cost (void) static void check_allocation (void) { - ira_allocno_t a, conflict_a; - int hard_regno, conflict_hard_regno, nregs, conflict_nregs; - ira_allocno_conflict_iterator aci; + ira_allocno_t a; + int hard_regno, nregs; ira_allocno_iterator ai; FOR_EACH_ALLOCNO (a, ai) { + ira_object_t obj, conflict_obj; + ira_object_conflict_iterator oci; + if (ALLOCNO_CAP_MEMBER (a) != NULL || (hard_regno = ALLOCNO_HARD_REGNO (a)) < 0) continue; nregs = hard_regno_nregs[hard_regno][ALLOCNO_MODE (a)]; - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci) - if ((conflict_hard_regno = ALLOCNO_HARD_REGNO (conflict_a)) >= 0) - { - conflict_nregs - = (hard_regno_nregs - [conflict_hard_regno][ALLOCNO_MODE (conflict_a)]); - if ((conflict_hard_regno <= hard_regno - && hard_regno < conflict_hard_regno + conflict_nregs) - || (hard_regno <= conflict_hard_regno - && conflict_hard_regno < hard_regno + nregs)) - { - fprintf (stderr, "bad allocation for %d and %d\n", - ALLOCNO_REGNO (a), ALLOCNO_REGNO (conflict_a)); - gcc_unreachable (); - } - } + obj = ALLOCNO_OBJECT (a); + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) + { + ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj); + int conflict_hard_regno = ALLOCNO_HARD_REGNO (conflict_a); + if (conflict_hard_regno >= 0) + { + int conflict_nregs + = (hard_regno_nregs + [conflict_hard_regno][ALLOCNO_MODE (conflict_a)]); + if ((conflict_hard_regno <= hard_regno + && hard_regno < conflict_hard_regno + conflict_nregs) + || (hard_regno <= conflict_hard_regno + && conflict_hard_regno < hard_regno + nregs)) + { + fprintf (stderr, "bad allocation for %d and %d\n", + ALLOCNO_REGNO (a), ALLOCNO_REGNO (conflict_a)); + gcc_unreachable (); + } + } + } } } #endif Index: gcc/ira-color.c =================================================================== --- gcc.orig/ira-color.c +++ gcc/ira-color.c @@ -446,8 +446,7 @@ assign_hard_reg (ira_allocno_t allocno, int *conflict_costs; enum reg_class cover_class, conflict_cover_class; enum machine_mode mode; - ira_allocno_t a, conflict_allocno; - ira_allocno_conflict_iterator aci; + ira_allocno_t a; static int costs[FIRST_PSEUDO_REGISTER], full_costs[FIRST_PSEUDO_REGISTER]; #ifndef HONOR_REG_ALLOC_ORDER enum reg_class rclass; @@ -477,6 +476,8 @@ assign_hard_reg (ira_allocno_t allocno, a = ALLOCNO_NEXT_COALESCED_ALLOCNO (a)) { ira_object_t obj = ALLOCNO_OBJECT (a); + ira_object_t conflict_obj; + ira_object_conflict_iterator oci; mem_cost += ALLOCNO_UPDATED_MEMORY_COST (a); IOR_HARD_REG_SET (conflicting_regs, @@ -500,60 +501,64 @@ assign_hard_reg (ira_allocno_t allocno, full_costs[i] += cost; } /* Take preferences of conflicting allocnos into account. */ - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_allocno, aci) - /* Reload can give another class so we need to check all - allocnos. */ - if (retry_p || bitmap_bit_p (consideration_allocno_bitmap, - ALLOCNO_NUM (conflict_allocno))) - { - conflict_cover_class = ALLOCNO_COVER_CLASS (conflict_allocno); - ira_assert (ira_reg_classes_intersect_p - [cover_class][conflict_cover_class]); - if (allocno_coalesced_p) - { - if (bitmap_bit_p (processed_coalesced_allocno_bitmap, - ALLOCNO_NUM (conflict_allocno))) - continue; - bitmap_set_bit (processed_coalesced_allocno_bitmap, - ALLOCNO_NUM (conflict_allocno)); - } - if (ALLOCNO_ASSIGNED_P (conflict_allocno)) - { - if ((hard_regno = ALLOCNO_HARD_REGNO (conflict_allocno)) >= 0 - && ira_class_hard_reg_index[cover_class][hard_regno] >= 0) - { - IOR_HARD_REG_SET - (conflicting_regs, - ira_reg_mode_hard_regset - [hard_regno][ALLOCNO_MODE (conflict_allocno)]); - if (hard_reg_set_subset_p (reg_class_contents[cover_class], - conflicting_regs)) - goto fail; - } - } - else if (! ALLOCNO_MAY_BE_SPILLED_P (ALLOCNO_FIRST_COALESCED_ALLOCNO - (conflict_allocno))) - { - ira_allocate_and_copy_costs - (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_allocno), - conflict_cover_class, - ALLOCNO_CONFLICT_HARD_REG_COSTS (conflict_allocno)); - conflict_costs - = ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_allocno); - if (conflict_costs != NULL) - for (j = class_size - 1; j >= 0; j--) - { - hard_regno = ira_class_hard_regs[cover_class][j]; - ira_assert (hard_regno >= 0); - k = (ira_class_hard_reg_index - [conflict_cover_class][hard_regno]); - if (k < 0) - continue; - full_costs[j] -= conflict_costs[k]; - } - queue_update_cost (conflict_allocno, COST_HOP_DIVISOR); - } - } + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) + { + ira_allocno_t conflict_allocno = OBJECT_ALLOCNO (conflict_obj); + + /* Reload can give another class so we need to check all + allocnos. */ + if (retry_p || bitmap_bit_p (consideration_allocno_bitmap, + ALLOCNO_NUM (conflict_allocno))) + { + conflict_cover_class = ALLOCNO_COVER_CLASS (conflict_allocno); + ira_assert (ira_reg_classes_intersect_p + [cover_class][conflict_cover_class]); + if (allocno_coalesced_p) + { + if (bitmap_bit_p (processed_coalesced_allocno_bitmap, + ALLOCNO_NUM (conflict_allocno))) + continue; + bitmap_set_bit (processed_coalesced_allocno_bitmap, + ALLOCNO_NUM (conflict_allocno)); + } + if (ALLOCNO_ASSIGNED_P (conflict_allocno)) + { + if ((hard_regno = ALLOCNO_HARD_REGNO (conflict_allocno)) >= 0 + && ira_class_hard_reg_index[cover_class][hard_regno] >= 0) + { + IOR_HARD_REG_SET + (conflicting_regs, + ira_reg_mode_hard_regset + [hard_regno][ALLOCNO_MODE (conflict_allocno)]); + if (hard_reg_set_subset_p (reg_class_contents[cover_class], + conflicting_regs)) + goto fail; + } + } + else if (! ALLOCNO_MAY_BE_SPILLED_P (ALLOCNO_FIRST_COALESCED_ALLOCNO + (conflict_allocno))) + { + ira_allocate_and_copy_costs + (&ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_allocno), + conflict_cover_class, + ALLOCNO_CONFLICT_HARD_REG_COSTS (conflict_allocno)); + conflict_costs + = ALLOCNO_UPDATED_CONFLICT_HARD_REG_COSTS (conflict_allocno); + if (conflict_costs != NULL) + for (j = class_size - 1; j >= 0; j--) + { + hard_regno = ira_class_hard_regs[cover_class][j]; + ira_assert (hard_regno >= 0); + k = (ira_class_hard_reg_index + [conflict_cover_class][hard_regno]); + if (k < 0) + continue; + full_costs[j] -= conflict_costs[k]; + } + queue_update_cost (conflict_allocno, COST_HOP_DIVISOR); + } + } + } if (a == allocno) break; } @@ -869,9 +874,8 @@ static void push_allocno_to_stack (ira_allocno_t allocno) { int left_conflicts_size, conflict_size, size; - ira_allocno_t a, conflict_allocno; + ira_allocno_t a; enum reg_class cover_class; - ira_allocno_conflict_iterator aci; ALLOCNO_IN_GRAPH_P (allocno) = false; VEC_safe_push (ira_allocno_t, heap, allocno_stack_vec, allocno); @@ -884,8 +888,14 @@ push_allocno_to_stack (ira_allocno_t all for (a = ALLOCNO_NEXT_COALESCED_ALLOCNO (allocno);; a = ALLOCNO_NEXT_COALESCED_ALLOCNO (a)) { - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_allocno, aci) + ira_object_t obj = ALLOCNO_OBJECT (a); + ira_object_t conflict_obj; + ira_object_conflict_iterator oci; + + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) { + ira_allocno_t conflict_allocno = OBJECT_ALLOCNO (conflict_obj); + conflict_allocno = ALLOCNO_FIRST_COALESCED_ALLOCNO (conflict_allocno); if (bitmap_bit_p (coloring_allocno_bitmap, ALLOCNO_NUM (conflict_allocno))) @@ -1402,10 +1412,9 @@ static void setup_allocno_left_conflicts_size (ira_allocno_t allocno) { int i, hard_regs_num, hard_regno, conflict_allocnos_size; - ira_allocno_t a, conflict_allocno; + ira_allocno_t a; enum reg_class cover_class; HARD_REG_SET temp_set; - ira_allocno_conflict_iterator aci; cover_class = ALLOCNO_COVER_CLASS (allocno); hard_regs_num = ira_class_hard_regs_num[cover_class]; @@ -1441,8 +1450,14 @@ setup_allocno_left_conflicts_size (ira_a for (a = ALLOCNO_NEXT_COALESCED_ALLOCNO (allocno);; a = ALLOCNO_NEXT_COALESCED_ALLOCNO (a)) { - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_allocno, aci) + ira_object_t obj = ALLOCNO_OBJECT (a); + ira_object_t conflict_obj; + ira_object_conflict_iterator oci; + + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) { + ira_allocno_t conflict_allocno = OBJECT_ALLOCNO (conflict_obj); + conflict_allocno = ALLOCNO_FIRST_COALESCED_ALLOCNO (conflict_allocno); if (bitmap_bit_p (consideration_allocno_bitmap, @@ -1560,8 +1575,7 @@ static bool coalesced_allocno_conflict_p (ira_allocno_t a1, ira_allocno_t a2, bool reload_p) { - ira_allocno_t a, conflict_allocno; - ira_allocno_conflict_iterator aci; + ira_allocno_t a; if (allocno_coalesced_p) { @@ -1579,6 +1593,7 @@ coalesced_allocno_conflict_p (ira_allocn { if (reload_p) { + ira_allocno_t conflict_allocno; for (conflict_allocno = ALLOCNO_NEXT_COALESCED_ALLOCNO (a1);; conflict_allocno = ALLOCNO_NEXT_COALESCED_ALLOCNO (conflict_allocno)) @@ -1592,12 +1607,19 @@ coalesced_allocno_conflict_p (ira_allocn } else { - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_allocno, aci) - if (conflict_allocno == a1 - || (allocno_coalesced_p - && bitmap_bit_p (processed_coalesced_allocno_bitmap, - ALLOCNO_NUM (conflict_allocno)))) - return true; + ira_object_t obj = ALLOCNO_OBJECT (a); + ira_object_t conflict_obj; + ira_object_conflict_iterator oci; + + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) + { + ira_allocno_t conflict_allocno = OBJECT_ALLOCNO (conflict_obj); + if (conflict_allocno == a1 + || (allocno_coalesced_p + && bitmap_bit_p (processed_coalesced_allocno_bitmap, + ALLOCNO_NUM (conflict_allocno)))) + return true; + } } if (a == a2) break; @@ -2288,8 +2310,7 @@ void ira_reassign_conflict_allocnos (int start_regno) { int i, allocnos_to_color_num; - ira_allocno_t a, conflict_a; - ira_allocno_conflict_iterator aci; + ira_allocno_t a; enum reg_class cover_class; bitmap allocnos_to_color; ira_allocno_iterator ai; @@ -2298,6 +2319,10 @@ ira_reassign_conflict_allocnos (int star allocnos_to_color_num = 0; FOR_EACH_ALLOCNO (a, ai) { + ira_object_t obj = ALLOCNO_OBJECT (a); + ira_object_t conflict_obj; + ira_object_conflict_iterator oci; + if (! ALLOCNO_ASSIGNED_P (a) && ! bitmap_bit_p (allocnos_to_color, ALLOCNO_NUM (a))) { @@ -2315,8 +2340,9 @@ ira_reassign_conflict_allocnos (int star if (ALLOCNO_REGNO (a) < start_regno || (cover_class = ALLOCNO_COVER_CLASS (a)) == NO_REGS) continue; - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci) + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) { + ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj); ira_assert (ira_reg_classes_intersect_p [cover_class][ALLOCNO_COVER_CLASS (conflict_a)]); if (bitmap_bit_p (allocnos_to_color, ALLOCNO_NUM (conflict_a))) @@ -2873,9 +2899,8 @@ ira_reassign_pseudos (int *spilled_pseud { int i, n, regno; bool changed_p; - ira_allocno_t a, conflict_a; + ira_allocno_t a; HARD_REG_SET forbidden_regs; - ira_allocno_conflict_iterator aci; bitmap temp = BITMAP_ALLOC (NULL); /* Add pseudos which conflict with pseudos already in @@ -2887,21 +2912,27 @@ ira_reassign_pseudos (int *spilled_pseud for (i = 0, n = num; i < n; i++) { + ira_object_t obj, conflict_obj; + ira_object_conflict_iterator oci; int regno = spilled_pseudo_regs[i]; bitmap_set_bit (temp, regno); a = ira_regno_allocno_map[regno]; - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci) - if (ALLOCNO_HARD_REGNO (conflict_a) < 0 - && ! ALLOCNO_DONT_REASSIGN_P (conflict_a) - && ! bitmap_bit_p (temp, ALLOCNO_REGNO (conflict_a))) - { - spilled_pseudo_regs[num++] = ALLOCNO_REGNO (conflict_a); - bitmap_set_bit (temp, ALLOCNO_REGNO (conflict_a)); - /* ?!? This seems wrong. */ - bitmap_set_bit (consideration_allocno_bitmap, - ALLOCNO_NUM (conflict_a)); - } + obj = ALLOCNO_OBJECT (a); + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) + { + ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj); + if (ALLOCNO_HARD_REGNO (conflict_a) < 0 + && ! ALLOCNO_DONT_REASSIGN_P (conflict_a) + && ! bitmap_bit_p (temp, ALLOCNO_REGNO (conflict_a))) + { + spilled_pseudo_regs[num++] = ALLOCNO_REGNO (conflict_a); + bitmap_set_bit (temp, ALLOCNO_REGNO (conflict_a)); + /* ?!? This seems wrong. */ + bitmap_set_bit (consideration_allocno_bitmap, + ALLOCNO_NUM (conflict_a)); + } + } } if (num > 1) Index: gcc/ira-conflicts.c =================================================================== --- gcc.orig/ira-conflicts.c +++ gcc/ira-conflicts.c @@ -717,9 +717,8 @@ static void print_allocno_conflicts (FILE * file, bool reg_p, ira_allocno_t a) { HARD_REG_SET conflicting_hard_regs; - ira_object_t obj; - ira_allocno_t conflict_a; - ira_allocno_conflict_iterator aci; + ira_object_t obj, conflict_obj; + ira_object_conflict_iterator oci; basic_block bb; if (reg_p) @@ -737,8 +736,9 @@ print_allocno_conflicts (FILE * file, bo fputs (" conflicts:", file); obj = ALLOCNO_OBJECT (a); if (OBJECT_CONFLICT_ARRAY (obj) != NULL) - FOR_EACH_ALLOCNO_CONFLICT (a, conflict_a, aci) + FOR_EACH_OBJECT_CONFLICT (obj, conflict_obj, oci) { + ira_allocno_t conflict_a = OBJECT_ALLOCNO (conflict_obj); if (reg_p) fprintf (file, " r%d,", ALLOCNO_REGNO (conflict_a)); else Index: gcc/ira-int.h =================================================================== --- gcc.orig/ira-int.h +++ gcc/ira-int.h @@ -1088,14 +1088,13 @@ typedef struct { /* The word of bit vector currently visited. It is defined only if OBJECT_CONFLICT_VEC_P is FALSE. */ unsigned IRA_INT_TYPE word; -} ira_allocno_conflict_iterator; +} ira_object_conflict_iterator; /* Initialize the iterator I with ALLOCNO conflicts. */ static inline void -ira_allocno_conflict_iter_init (ira_allocno_conflict_iterator *i, - ira_allocno_t allocno) +ira_object_conflict_iter_init (ira_object_conflict_iterator *i, + ira_object_t obj) { - ira_object_t obj = ALLOCNO_OBJECT (allocno); i->conflict_vec_p = OBJECT_CONFLICT_VEC_P (obj); i->vec = OBJECT_CONFLICT_ARRAY (obj); i->word_num = 0; @@ -1119,8 +1118,8 @@ ira_allocno_conflict_iter_init (ira_allo case *A is set to the allocno to be visited. Otherwise, return FALSE. */ static inline bool -ira_allocno_conflict_iter_cond (ira_allocno_conflict_iterator *i, - ira_allocno_t *a) +ira_object_conflict_iter_cond (ira_object_conflict_iterator *i, + ira_object_t *pobj) { ira_object_t obj; @@ -1151,13 +1150,13 @@ ira_allocno_conflict_iter_cond (ira_allo obj = ira_object_id_map[i->bit_num + i->base_conflict_id]; } - *a = OBJECT_ALLOCNO (obj); + *pobj = obj; return true; } /* Advance to the next conflicting allocno. */ static inline void -ira_allocno_conflict_iter_next (ira_allocno_conflict_iterator *i) +ira_object_conflict_iter_next (ira_object_conflict_iterator *i) { if (i->conflict_vec_p) i->word_num++; @@ -1168,14 +1167,13 @@ ira_allocno_conflict_iter_next (ira_allo } } -/* Loop over all allocnos conflicting with ALLOCNO. In each - iteration, A is set to the next conflicting allocno. ITER is an - instance of ira_allocno_conflict_iterator used to iterate the - conflicts. */ -#define FOR_EACH_ALLOCNO_CONFLICT(ALLOCNO, A, ITER) \ - for (ira_allocno_conflict_iter_init (&(ITER), (ALLOCNO)); \ - ira_allocno_conflict_iter_cond (&(ITER), &(A)); \ - ira_allocno_conflict_iter_next (&(ITER))) +/* Loop over all objects conflicting with OBJ. In each iteration, + CONF is set to the next conflicting object. ITER is an instance + of ira_object_conflict_iterator used to iterate the conflicts. */ +#define FOR_EACH_OBJECT_CONFLICT(OBJ, CONF, ITER) \ + for (ira_object_conflict_iter_init (&(ITER), (OBJ)); \ + ira_object_conflict_iter_cond (&(ITER), &(CONF)); \ + ira_object_conflict_iter_next (&(ITER)))