From 71b77236f1e90b13176b03da3585752fbf6e497c Mon Sep 17 00:00:00 2001 From: hubicka Date: Sun, 21 Nov 1999 12:53:31 +0000 Subject: [PATCH] * global.c (allocno): New structure and static variable. (allocno_reg): Remove, all references replaced by allocno. (allocno_size): Likewise. (hard_reg_conflicts): Likewise. (hard_reg_preferences): Likewise. (hard_reg_copy_preferences): Likewise. (hard_reg_full_preferences): Likewise. (regs_someone_prefers): Likewise. (allocno_calls_crossed): Likewise. (allocno_n_refs): Likewise. (allocno_live_length): Likewise. (find_reg): Rename ALLOCNO to NUM. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@30602 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/global.c | 336 +++++++++++++++++++++++++++-------------------------------- 1 file changed, 155 insertions(+), 181 deletions(-) diff --git a/gcc/global.c b/gcc/global.c index 7e0074c..2c95f57 100644 --- a/gcc/global.c +++ b/gcc/global.c @@ -83,20 +83,58 @@ static int max_allocno; static int *reg_allocno; -/* Indexed by allocno, gives the reg number. */ +struct allocno +{ + int reg; + /* Gives the number of consecutive hard registers needed by that + pseudo reg. */ + int size; + + /* Number of calls crossed by each allocno. */ + int calls_crossed; + + /* Number of refs (weighted) to each allocno. */ + int n_refs; + + /* Guess at live length of each allocno. + This is actually the max of the live lengths of the regs. */ + int live_length; + + /* Set of hard regs conflicting with allocno N. */ + + HARD_REG_SET hard_reg_conflicts; + + /* Set of hard regs preferred by allocno N. + This is used to make allocnos go into regs that are copied to or from them, + when possible, to reduce register shuffling. */ + + HARD_REG_SET hard_reg_preferences; + + /* Similar, but just counts register preferences made in simple copy + operations, rather than arithmetic. These are given priority because + we can always eliminate an insn by using these, but using a register + in the above list won't always eliminate an insn. */ -static int *allocno_reg; + HARD_REG_SET hard_reg_copy_preferences; + + /* Similar to hard_reg_preferences, but includes bits for subsequent + registers when an allocno is multi-word. The above variable is used for + allocation while this is used to build reg_someone_prefers, below. */ + + HARD_REG_SET hard_reg_full_preferences; + + /* Set of hard registers that some later allocno has a preference for. */ + + HARD_REG_SET regs_someone_prefers; +}; + +static struct allocno *allocno; /* A vector of the integers from 0 to max_allocno-1, sorted in the order of first-to-be-allocated first. */ static int *allocno_order; -/* Indexed by an allocno, gives the number of consecutive - hard registers needed by that pseudo reg. */ - -static int *allocno_size; - /* Indexed by (pseudo) reg number, gives the number of another lower-numbered pseudo reg which can share a hard reg with this pseudo *even if the two pseudos would otherwise appear to conflict*. */ @@ -139,7 +177,7 @@ static int allocno_row_words; do { \ int i_; \ int allocno_; \ - INT_TYPE *p_ = (ALLOCNO_SET); \ + INT_TYPE *p_ = (ALLOCNO_SET); \ \ for (i_ = allocno_row_words - 1, allocno_ = 0; i_ >= 0; \ i_--, allocno_ += INT_BITS) \ @@ -168,34 +206,6 @@ do { \ static HARD_REG_SET hard_regs_live; -/* Indexed by N, set of hard regs conflicting with allocno N. */ - -static HARD_REG_SET *hard_reg_conflicts; - -/* Indexed by N, set of hard regs preferred by allocno N. - This is used to make allocnos go into regs that are copied to or from them, - when possible, to reduce register shuffling. */ - -static HARD_REG_SET *hard_reg_preferences; - -/* Similar, but just counts register preferences made in simple copy - operations, rather than arithmetic. These are given priority because - we can always eliminate an insn by using these, but using a register - in the above list won't always eliminate an insn. */ - -static HARD_REG_SET *hard_reg_copy_preferences; - -/* Similar to hard_reg_preferences, but includes bits for subsequent - registers when an allocno is multi-word. The above variable is used for - allocation while this is used to build reg_someone_prefers, below. */ - -static HARD_REG_SET *hard_reg_full_preferences; - -/* Indexed by N, set of hard registers that some later allocno has a - preference for. */ - -static HARD_REG_SET *regs_someone_prefers; - /* Set of registers that global-alloc isn't supposed to use. */ static HARD_REG_SET no_global_alloc_regs; @@ -204,19 +214,6 @@ static HARD_REG_SET no_global_alloc_regs; static HARD_REG_SET regs_used_so_far; -/* Number of calls crossed by each allocno. */ - -static int *allocno_calls_crossed; - -/* Number of refs (weighted) to each allocno. */ - -static int *allocno_n_refs; - -/* Guess at live length of each allocno. - This is actually the max of the live lengths of the regs. */ - -static int *allocno_live_length; - /* Number of refs (weighted) to each hard reg, as used by local alloc. It is zero for a reg that contains global pseudos or is explicitly used. */ @@ -230,11 +227,11 @@ static int local_reg_live_length[FIRST_PSEUDO_REGISTER]; /* Test a bit in TABLE, a vector of HARD_REG_SETs, for vector element I, and hard register number J. */ -#define REGBITP(TABLE, I, J) TEST_HARD_REG_BIT (TABLE[I], J) +#define REGBITP(TABLE, I, J) TEST_HARD_REG_BIT (allocno[I].TABLE, J) /* Set to 1 a bit in a vector of HARD_REG_SETs. Works like REGBITP. */ -#define SET_REGBIT(TABLE, I, J) SET_HARD_REG_BIT (TABLE[I], J) +#define SET_REGBIT(TABLE, I, J) SET_HARD_REG_BIT (allocno[I].TABLE, J) /* Bit mask for allocnos live at current point in the scan. */ @@ -444,22 +441,18 @@ global_alloc (file) else reg_allocno[i] = -1; - allocno_reg = (int *) xmalloc (max_allocno * sizeof (int)); - allocno_size = (int *) xcalloc (max_allocno, sizeof (int)); - allocno_calls_crossed = (int *) xcalloc (max_allocno, sizeof (int)); - allocno_n_refs = (int *) xcalloc (max_allocno, sizeof (int)); - allocno_live_length = (int *) xcalloc (max_allocno, sizeof (int)); + allocno = (struct allocno *) xcalloc (max_allocno, sizeof (struct allocno)); for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++) if (reg_allocno[i] >= 0) { - int allocno = reg_allocno[i]; - allocno_reg[allocno] = i; - allocno_size[allocno] = PSEUDO_REGNO_SIZE (i); - allocno_calls_crossed[allocno] += REG_N_CALLS_CROSSED (i); - allocno_n_refs[allocno] += REG_N_REFS (i); - if (allocno_live_length[allocno] < REG_LIVE_LENGTH (i)) - allocno_live_length[allocno] = REG_LIVE_LENGTH (i); + int num = reg_allocno[i]; + allocno[num].reg = i; + allocno[num].size = PSEUDO_REGNO_SIZE (i); + allocno[num].calls_crossed += REG_N_CALLS_CROSSED (i); + allocno[num].n_refs += REG_N_REFS (i); + if (allocno[num].live_length < REG_LIVE_LENGTH (i)) + allocno[num].live_length = REG_LIVE_LENGTH (i); } /* Calculate amount of usage of each hard reg by pseudos @@ -486,20 +479,6 @@ global_alloc (file) if (regs_ever_live[i]) local_reg_n_refs[i] = 0; - /* Allocate the space for the conflict and preference tables and - initialize them. */ - - hard_reg_conflicts - = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET)); - hard_reg_preferences - = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET)); - hard_reg_copy_preferences - = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET)); - hard_reg_full_preferences - = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET)); - regs_someone_prefers - = (HARD_REG_SET *) xcalloc (max_allocno, sizeof (HARD_REG_SET)); - allocno_row_words = (max_allocno + INT_BITS - 1) / INT_BITS; /* We used to use alloca here, but the size of what it would try to @@ -531,10 +510,12 @@ global_alloc (file) for (i = 0; i < (size_t) max_allocno; i++) { - AND_COMPL_HARD_REG_SET (hard_reg_conflicts[i], eliminable_regset); - AND_COMPL_HARD_REG_SET (hard_reg_copy_preferences[i], + AND_COMPL_HARD_REG_SET (allocno[i].hard_reg_conflicts, + eliminable_regset); + AND_COMPL_HARD_REG_SET (allocno[i].hard_reg_copy_preferences, + eliminable_regset); + AND_COMPL_HARD_REG_SET (allocno[i].hard_reg_preferences, eliminable_regset); - AND_COMPL_HARD_REG_SET (hard_reg_preferences[i], eliminable_regset); } /* Try to expand the preferences by merging them between allocnos. */ @@ -556,10 +537,10 @@ global_alloc (file) for (i = 0; i < (size_t) max_allocno; i++) { - if (allocno_size[i] == 0) - allocno_size[i] = 1; - if (allocno_live_length[i] == 0) - allocno_live_length[i] = -1; + if (allocno[i].size == 0) + allocno[i].size = 1; + if (allocno[i].live_length == 0) + allocno[i].live_length = -1; } qsort (allocno_order, max_allocno, sizeof (int), allocno_compare); @@ -573,8 +554,8 @@ global_alloc (file) except for parameters marked with reg_live_length[regno] == -2. */ for (i = 0; i < (size_t) max_allocno; i++) - if (reg_renumber[allocno_reg[allocno_order[i]]] < 0 - && REG_LIVE_LENGTH (allocno_reg[allocno_order[i]]) >= 0) + if (reg_renumber[allocno[allocno_order[i]].reg] < 0 + && REG_LIVE_LENGTH (allocno[allocno_order[i]].reg) >= 0) { /* If we have more than one register class, first try allocating in the class that is cheapest @@ -582,10 +563,10 @@ global_alloc (file) if (N_REG_CLASSES > 1) { find_reg (allocno_order[i], 0, 0, 0, 0); - if (reg_renumber[allocno_reg[allocno_order[i]]] >= 0) + if (reg_renumber[allocno[allocno_order[i]].reg] >= 0) continue; } - if (reg_alternate_class (allocno_reg[allocno_order[i]]) != NO_REGS) + if (reg_alternate_class (allocno[allocno_order[i]].reg) != NO_REGS) find_reg (allocno_order[i], 0, 1, 0, 0); } @@ -607,16 +588,7 @@ global_alloc (file) /* Clean up. */ free (reg_allocno); free (reg_may_share); - free (allocno_reg); - free (allocno_size); - free (allocno_calls_crossed); - free (allocno_n_refs); - free (allocno_live_length); - free (hard_reg_conflicts); - free (hard_reg_preferences); - free (hard_reg_copy_preferences); - free (hard_reg_full_preferences); - free (regs_someone_prefers); + free (allocno); free (conflicts); free (allocnos_live); @@ -637,13 +609,13 @@ allocno_compare (v1p, v2p) times a register can occur in one insn (surely less than 100). Multiplying this by 10000 can't overflow. */ register int pri1 - = (((double) (floor_log2 (allocno_n_refs[v1]) * allocno_n_refs[v1]) - / allocno_live_length[v1]) - * 10000 * allocno_size[v1]); + = (((double) (floor_log2 (allocno[v1].n_refs) * allocno[v1].n_refs) + / allocno[v1].live_length) + * 10000 * allocno[v1].size); register int pri2 - = (((double) (floor_log2 (allocno_n_refs[v2]) * allocno_n_refs[v2]) - / allocno_live_length[v2]) - * 10000 * allocno_size[v2]); + = (((double) (floor_log2 (allocno[v2].n_refs) * allocno[v2].n_refs) + / allocno[v2].live_length) + * 10000 * allocno[v2].size); if (pri2 - pri1) return pri2 - pri1; @@ -883,20 +855,20 @@ expand_preferences () if (XEXP (link, 0) == SET_SRC (set)) { - IOR_HARD_REG_SET (hard_reg_copy_preferences[a1], - hard_reg_copy_preferences[a2]); - IOR_HARD_REG_SET (hard_reg_copy_preferences[a2], - hard_reg_copy_preferences[a1]); + IOR_HARD_REG_SET (allocno[a1].hard_reg_copy_preferences, + allocno[a2].hard_reg_copy_preferences); + IOR_HARD_REG_SET (allocno[a2].hard_reg_copy_preferences, + allocno[a1].hard_reg_copy_preferences); } - IOR_HARD_REG_SET (hard_reg_preferences[a1], - hard_reg_preferences[a2]); - IOR_HARD_REG_SET (hard_reg_preferences[a2], - hard_reg_preferences[a1]); - IOR_HARD_REG_SET (hard_reg_full_preferences[a1], - hard_reg_full_preferences[a2]); - IOR_HARD_REG_SET (hard_reg_full_preferences[a2], - hard_reg_full_preferences[a1]); + IOR_HARD_REG_SET (allocno[a1].hard_reg_preferences, + allocno[a2].hard_reg_preferences); + IOR_HARD_REG_SET (allocno[a2].hard_reg_preferences, + allocno[a1].hard_reg_preferences); + IOR_HARD_REG_SET (allocno[a1].hard_reg_full_preferences, + allocno[a2].hard_reg_full_preferences); + IOR_HARD_REG_SET (allocno[a2].hard_reg_full_preferences, + allocno[a1].hard_reg_full_preferences); } } @@ -911,7 +883,7 @@ static void prune_preferences () { int i; - int allocno; + int num; int *allocno_to_order = (int *) xmalloc (max_allocno * sizeof (int)); /* Scan least most important to most important. @@ -923,22 +895,22 @@ prune_preferences () { HARD_REG_SET temp; - allocno = allocno_order[i]; - allocno_to_order[allocno] = i; - COPY_HARD_REG_SET (temp, hard_reg_conflicts[allocno]); + num = allocno_order[i]; + allocno_to_order[num] = i; + COPY_HARD_REG_SET (temp, allocno[num].hard_reg_conflicts); - if (allocno_calls_crossed[allocno] == 0) + if (allocno[num].calls_crossed == 0) IOR_HARD_REG_SET (temp, fixed_reg_set); else IOR_HARD_REG_SET (temp, call_used_reg_set); IOR_COMPL_HARD_REG_SET (temp, - reg_class_contents[(int) reg_preferred_class (allocno_reg[allocno])]); + reg_class_contents[(int) reg_preferred_class (allocno[num].reg)]); - AND_COMPL_HARD_REG_SET (hard_reg_preferences[allocno], temp); - AND_COMPL_HARD_REG_SET (hard_reg_copy_preferences[allocno], temp); - AND_COMPL_HARD_REG_SET (hard_reg_full_preferences[allocno], temp); + AND_COMPL_HARD_REG_SET (allocno[num].hard_reg_preferences, temp); + AND_COMPL_HARD_REG_SET (allocno[num].hard_reg_copy_preferences, temp); + AND_COMPL_HARD_REG_SET (allocno[num].hard_reg_full_preferences, temp); } for (i = max_allocno - 1; i >= 0; i--) @@ -951,31 +923,33 @@ prune_preferences () HARD_REG_SET temp, temp2; int allocno2; - allocno = allocno_order[i]; + num = allocno_order[i]; CLEAR_HARD_REG_SET (temp); CLEAR_HARD_REG_SET (temp2); - EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + allocno * allocno_row_words, + EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + num * allocno_row_words, allocno2, { if (allocno_to_order[allocno2] > i) { - if (allocno_size[allocno2] <= allocno_size[allocno]) - IOR_HARD_REG_SET (temp, hard_reg_full_preferences[allocno2]); + if (allocno[allocno2].size <= allocno[num].size) + IOR_HARD_REG_SET (temp, + allocno[allocno2].hard_reg_full_preferences); else - IOR_HARD_REG_SET (temp2, hard_reg_full_preferences[allocno2]); + IOR_HARD_REG_SET (temp2, + allocno[allocno2].hard_reg_full_preferences); } }); - AND_COMPL_HARD_REG_SET (temp, hard_reg_full_preferences[allocno]); + AND_COMPL_HARD_REG_SET (temp, allocno[num].hard_reg_full_preferences); IOR_HARD_REG_SET (temp, temp2); - COPY_HARD_REG_SET (regs_someone_prefers[allocno], temp); + COPY_HARD_REG_SET (allocno[num].regs_someone_prefers, temp); } free (allocno_to_order); } -/* Assign a hard register to ALLOCNO; look for one that is the beginning +/* Assign a hard register to allocno NUM; look for one that is the beginning of a long enough stretch of hard regs none of which conflicts with ALLOCNO. The registers marked in PREFREGS are tried first. @@ -994,8 +968,8 @@ prune_preferences () If not, do nothing. */ static void -find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) - int allocno; +find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying) + int num; HARD_REG_SET losers; int alt_regs_p; int accept_call_clobbered; @@ -1008,13 +982,13 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) HARD_REG_SET used, used1, used2; enum reg_class class = (alt_regs_p - ? reg_alternate_class (allocno_reg[allocno]) - : reg_preferred_class (allocno_reg[allocno])); - enum machine_mode mode = PSEUDO_REGNO_MODE (allocno_reg[allocno]); + ? reg_alternate_class (allocno[num].reg) + : reg_preferred_class (allocno[num].reg)); + enum machine_mode mode = PSEUDO_REGNO_MODE (allocno[num].reg); if (accept_call_clobbered) COPY_HARD_REG_SET (used1, call_fixed_reg_set); - else if (allocno_calls_crossed[allocno] == 0) + else if (allocno[num].calls_crossed == 0) COPY_HARD_REG_SET (used1, fixed_reg_set); else COPY_HARD_REG_SET (used1, call_used_reg_set); @@ -1027,10 +1001,10 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) IOR_COMPL_HARD_REG_SET (used1, reg_class_contents[(int) class]); COPY_HARD_REG_SET (used2, used1); - IOR_HARD_REG_SET (used1, hard_reg_conflicts[allocno]); + IOR_HARD_REG_SET (used1, allocno[num].hard_reg_conflicts); #ifdef CLASS_CANNOT_CHANGE_SIZE - if (REG_CHANGES_SIZE (allocno_reg[allocno])) + if (REG_CHANGES_SIZE (allocno[num].reg)) IOR_HARD_REG_SET (used1, reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]); #endif @@ -1043,7 +1017,7 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) COPY_HARD_REG_SET (used, used1); IOR_COMPL_HARD_REG_SET (used, regs_used_so_far); - IOR_HARD_REG_SET (used, regs_someone_prefers[allocno]); + IOR_HARD_REG_SET (used, allocno[num].regs_someone_prefers); best_reg = -1; for (i = FIRST_PSEUDO_REGISTER, pass = 0; @@ -1061,7 +1035,7 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) #endif if (! TEST_HARD_REG_BIT (used, regno) && HARD_REGNO_MODE_OK (regno, mode) - && (allocno_calls_crossed[allocno] == 0 + && (allocno[num].calls_crossed == 0 || accept_call_clobbered || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode))) { @@ -1094,14 +1068,14 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) First do this for those register with copy preferences, then all preferred registers. */ - AND_COMPL_HARD_REG_SET (hard_reg_copy_preferences[allocno], used); - GO_IF_HARD_REG_SUBSET (hard_reg_copy_preferences[allocno], + AND_COMPL_HARD_REG_SET (allocno[num].hard_reg_copy_preferences, used); + GO_IF_HARD_REG_SUBSET (allocno[num].hard_reg_copy_preferences, reg_class_contents[(int) NO_REGS], no_copy_prefs); if (best_reg >= 0) { for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (hard_reg_copy_preferences[allocno], i) + if (TEST_HARD_REG_BIT (allocno[num].hard_reg_copy_preferences, i) && HARD_REGNO_MODE_OK (i, mode) && (REGNO_REG_CLASS (i) == REGNO_REG_CLASS (best_reg) || reg_class_subset_p (REGNO_REG_CLASS (i), @@ -1130,14 +1104,14 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) } no_copy_prefs: - AND_COMPL_HARD_REG_SET (hard_reg_preferences[allocno], used); - GO_IF_HARD_REG_SUBSET (hard_reg_preferences[allocno], + AND_COMPL_HARD_REG_SET (allocno[num].hard_reg_preferences, used); + GO_IF_HARD_REG_SUBSET (allocno[num].hard_reg_preferences, reg_class_contents[(int) NO_REGS], no_prefs); if (best_reg >= 0) { for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (hard_reg_preferences[allocno], i) + if (TEST_HARD_REG_BIT (allocno[num].hard_reg_preferences, i) && HARD_REGNO_MODE_OK (i, mode) && (REGNO_REG_CLASS (i) == REGNO_REG_CLASS (best_reg) || reg_class_subset_p (REGNO_REG_CLASS (i), @@ -1177,9 +1151,9 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) allocate a call-clobbered register and save and restore it around calls, do that. */ if (! accept_call_clobbered - && allocno_calls_crossed[allocno] != 0 - && CALLER_SAVE_PROFITABLE (allocno_n_refs[allocno], - allocno_calls_crossed[allocno])) + && allocno[num].calls_crossed != 0 + && CALLER_SAVE_PROFITABLE (allocno[num].n_refs, + allocno[num].calls_crossed)) { HARD_REG_SET new_losers; if (! losers) @@ -1188,8 +1162,8 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) COPY_HARD_REG_SET (new_losers, losers); IOR_HARD_REG_SET(new_losers, losing_caller_save_reg_set); - find_reg (allocno, new_losers, alt_regs_p, 1, retrying); - if (reg_renumber[allocno_reg[allocno]] >= 0) + find_reg (num, new_losers, alt_regs_p, 1, retrying); + if (reg_renumber[allocno[num].reg] >= 0) { caller_save_needed = 1; return; @@ -1204,7 +1178,7 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) so we can use it instead. */ if (best_reg < 0 && !retrying /* Let's not bother with multi-reg allocnos. */ - && allocno_size[allocno] == 1) + && allocno[num].size == 1) { /* Count from the end, to find the least-used ones first. */ for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--) @@ -1220,7 +1194,7 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) && ! TEST_HARD_REG_BIT (used2, regno) && HARD_REGNO_MODE_OK (regno, mode) #ifdef CLASS_CANNOT_CHANGE_SIZE - && ! (REG_CHANGES_SIZE (allocno_reg[allocno]) + && ! (REG_CHANGES_SIZE (allocno[num].reg) && (TEST_HARD_REG_BIT (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], regno))) @@ -1233,8 +1207,8 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) double tmp1 = ((double) local_reg_n_refs[regno] / local_reg_live_length[regno]); - double tmp2 = ((double) allocno_n_refs[allocno] - / allocno_live_length[allocno]); + double tmp2 = ((double) allocno[num].n_refs + / allocno[num].live_length); if (tmp1 < tmp2) { @@ -1267,11 +1241,11 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) HARD_REG_SET this_reg; /* Yes. Record it as the hard register of this pseudo-reg. */ - reg_renumber[allocno_reg[allocno]] = best_reg; + reg_renumber[allocno[num].reg] = best_reg; /* Also of any pseudo-regs that share with it. */ - if (reg_may_share[allocno_reg[allocno]]) + if (reg_may_share[allocno[num].reg]) for (j = FIRST_PSEUDO_REGISTER; j < max_regno; j++) - if (reg_allocno[j] == allocno) + if (reg_allocno[j] == num) reg_renumber[j] = best_reg; /* Make a set of the hard regs being allocated. */ @@ -1286,10 +1260,10 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) } /* For each other pseudo-reg conflicting with this one, mark it as conflicting with the hard regs this one occupies. */ - lim = allocno; + lim = num; EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + lim * allocno_row_words, j, { - IOR_HARD_REG_SET (hard_reg_conflicts[j], this_reg); + IOR_HARD_REG_SET (allocno[j].hard_reg_conflicts, this_reg); }); } } @@ -1345,7 +1319,7 @@ record_one_conflict (regno) record conflicts with live pseudo regs. */ EXECUTE_IF_SET_IN_ALLOCNO_SET (allocnos_live, j, { - SET_HARD_REG_BIT (hard_reg_conflicts[j], regno); + SET_HARD_REG_BIT (allocno[j].hard_reg_conflicts, regno); }); else /* When a pseudo-register becomes live, @@ -1354,7 +1328,7 @@ record_one_conflict (regno) { register int ialloc = reg_allocno[regno]; register int ialloc_prod = ialloc * allocno_row_words; - IOR_HARD_REG_SET (hard_reg_conflicts[ialloc], hard_regs_live); + IOR_HARD_REG_SET (allocno[ialloc].hard_reg_conflicts, hard_regs_live); for (j = allocno_row_words - 1; j >= 0; j--) { #if 0 @@ -1382,15 +1356,15 @@ record_conflicts (allocno_vec, len) register int *allocno_vec; register int len; { - register int allocno; + register int num; register int j; register int ialloc_prod; while (--len >= 0) { - allocno = allocno_vec[len]; - ialloc_prod = allocno * allocno_row_words; - IOR_HARD_REG_SET (hard_reg_conflicts[allocno], hard_regs_live); + num = allocno_vec[len]; + ialloc_prod = num * allocno_row_words; + IOR_HARD_REG_SET (allocno[num].hard_reg_conflicts, hard_regs_live); } } @@ -1879,7 +1853,7 @@ dump_conflicts (file) nregs = 0; for (i = 0; i < max_allocno; i++) { - if (reg_renumber[allocno_reg[allocno_order[i]]] >= 0) + if (reg_renumber[allocno[allocno_order[i]].reg] >= 0) continue; nregs++; } @@ -1887,40 +1861,40 @@ dump_conflicts (file) for (i = 0; i < max_allocno; i++) { int j; - if (reg_renumber[allocno_reg[allocno_order[i]]] >= 0) + if (reg_renumber[allocno[allocno_order[i]].reg] >= 0) continue; - fprintf (file, " %d", allocno_reg[allocno_order[i]]); + fprintf (file, " %d", allocno[allocno_order[i]].reg); for (j = 0; j < max_regno; j++) if (reg_allocno[j] == allocno_order[i] - && j != allocno_reg[allocno_order[i]]) + && j != allocno[allocno_order[i]].reg) fprintf (file, "+%d", j); - if (allocno_size[allocno_order[i]] != 1) - fprintf (file, " (%d)", allocno_size[allocno_order[i]]); + if (allocno[allocno_order[i]].size != 1) + fprintf (file, " (%d)", allocno[allocno_order[i]].size); } fprintf (file, "\n"); for (i = 0; i < max_allocno; i++) { register int j; - fprintf (file, ";; %d conflicts:", allocno_reg[i]); + fprintf (file, ";; %d conflicts:", allocno[i].reg); for (j = 0; j < max_allocno; j++) if (CONFLICTP (j, i)) - fprintf (file, " %d", allocno_reg[j]); + fprintf (file, " %d", allocno[j].reg); for (j = 0; j < FIRST_PSEUDO_REGISTER; j++) - if (TEST_HARD_REG_BIT (hard_reg_conflicts[i], j)) + if (TEST_HARD_REG_BIT (allocno[i].hard_reg_conflicts, j)) fprintf (file, " %d", j); fprintf (file, "\n"); has_preferences = 0; for (j = 0; j < FIRST_PSEUDO_REGISTER; j++) - if (TEST_HARD_REG_BIT (hard_reg_preferences[i], j)) + if (TEST_HARD_REG_BIT (allocno[i].hard_reg_preferences, j)) has_preferences = 1; if (! has_preferences) continue; - fprintf (file, ";; %d preferences:", allocno_reg[i]); + fprintf (file, ";; %d preferences:", allocno[i].reg); for (j = 0; j < FIRST_PSEUDO_REGISTER; j++) - if (TEST_HARD_REG_BIT (hard_reg_preferences[i], j)) + if (TEST_HARD_REG_BIT (allocno[i].hard_reg_preferences, j)) fprintf (file, " %d", j); fprintf (file, "\n"); } -- 2.7.4