X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fglobal.c;h=4ad1e1967fbdf4e45779f405f5e968d550d201b1;hb=3fdf82207a854f72901eca52b478968bf9a2ab36;hp=3cb6b34ef252f4d8a2fc69b544f86c462b1354e0;hpb=51bc0ccc9a583b80268a913fbd210c6ae6c5fcfb;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/global.c b/gcc/global.c index 3cb6b34ef25..4ad1e1967fb 100644 --- a/gcc/global.c +++ b/gcc/global.c @@ -1,5 +1,6 @@ /* Allocate registers for pseudo-registers that span basic blocks. - Copyright (C) 1987, 88, 91, 94, 96-98, 1999 Free Software Foundation, Inc. + Copyright (C) 1987, 1988, 1991, 1994, 1996, 1997, 1998, + 1999, 2000 Free Software Foundation, Inc. This file is part of GNU CC. @@ -83,20 +84,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. */ + + HARD_REG_SET hard_reg_copy_preferences; -static int *allocno_reg; + /* 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*. */ @@ -133,44 +172,41 @@ static int allocno_row_words; (conflicts[(I) * allocno_row_words + (unsigned)(J) / INT_BITS] \ |= ((INT_TYPE) 1 << ((unsigned)(J) % INT_BITS))) -/* CYGNUS LOCAL LRS */ -#define CLEAR_CONFLICT(I, J) \ - (conflicts[(I) * allocno_row_words + (J) / INT_BITS] \ - &= ~ ((INT_TYPE) 1 << ((J) % INT_BITS))) -/* END CYGNUS LOCAL */ +/* For any allocno set in ALLOCNO_SET, set ALLOCNO to that allocno, + and execute CODE. */ +#define EXECUTE_IF_SET_IN_ALLOCNO_SET(ALLOCNO_SET, ALLOCNO, CODE) \ +do { \ + int i_; \ + int allocno_; \ + INT_TYPE *p_ = (ALLOCNO_SET); \ + \ + for (i_ = allocno_row_words - 1, allocno_ = 0; i_ >= 0; \ + i_--, allocno_ += INT_BITS) \ + { \ + unsigned INT_TYPE word_ = (unsigned INT_TYPE) *p_++; \ + \ + for ((ALLOCNO) = allocno_; word_; word_ >>= 1, (ALLOCNO)++) \ + { \ + if (word_ & 1) \ + {CODE;} \ + } \ + } \ +} while (0) + +/* This doesn't work for non-GNU C due to the way CODE is macro expanded. */ +#if 0 +/* For any allocno that conflicts with IN_ALLOCNO, set OUT_ALLOCNO to + the conflicting allocno, and execute CODE. This macro assumes that + mirror_conflicts has been run. */ +#define EXECUTE_IF_CONFLICT(IN_ALLOCNO, OUT_ALLOCNO, CODE)\ + EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + (IN_ALLOCNO) * allocno_row_words,\ + OUT_ALLOCNO, (CODE)) +#endif /* Set of hard regs currently live (during scan of all insns). */ 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; @@ -179,19 +215,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. */ @@ -205,11 +228,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. */ @@ -218,14 +241,17 @@ static INT_TYPE *allocnos_live; /* Test, set or clear bit number I in allocnos_live, a bit vector indexed by allocno. */ -#define ALLOCNO_LIVE_P(I) \ - (allocnos_live[(I) / INT_BITS] & ((INT_TYPE) 1 << ((I) % INT_BITS))) +#define ALLOCNO_LIVE_P(I) \ + (allocnos_live[(unsigned)(I) / INT_BITS] \ + & ((INT_TYPE) 1 << ((unsigned)(I) % INT_BITS))) -#define SET_ALLOCNO_LIVE(I) \ - (allocnos_live[(I) / INT_BITS] |= ((INT_TYPE) 1 << ((I) % INT_BITS))) +#define SET_ALLOCNO_LIVE(I) \ + (allocnos_live[(unsigned)(I) / INT_BITS] \ + |= ((INT_TYPE) 1 << ((unsigned)(I) % INT_BITS))) -#define CLEAR_ALLOCNO_LIVE(I) \ - (allocnos_live[(I) / INT_BITS] &= ~((INT_TYPE) 1 << ((I) % INT_BITS))) +#define CLEAR_ALLOCNO_LIVE(I) \ + (allocnos_live[(unsigned)(I) / INT_BITS] \ + &= ~((INT_TYPE) 1 << ((unsigned)(I) % INT_BITS))) /* This is turned off because it doesn't work right for DImode. (And it is only used for DImode, so the other cases are worthless.) @@ -262,24 +288,24 @@ static int n_regs_set; static HARD_REG_SET eliminable_regset; -static int allocno_compare PROTO((const PTR, const PTR)); -static void global_conflicts PROTO((void)); -static void mirror_conflicts PROTO((void)); -static void expand_preferences PROTO((void)); -static void prune_preferences PROTO((void)); -static void find_reg PROTO((int, HARD_REG_SET, int, int, int)); -static void record_one_conflict PROTO((int)); -static void record_conflicts PROTO((int *, int)); -static void mark_reg_store PROTO((rtx, rtx, void *)); -static void mark_reg_clobber PROTO((rtx, rtx, void *)); -static void mark_reg_conflicts PROTO((rtx)); -static void mark_reg_death PROTO((rtx)); -static void mark_reg_live_nc PROTO((int, enum machine_mode)); -static void set_preference PROTO((rtx, rtx)); -static void dump_conflicts PROTO((FILE *)); -static void reg_becomes_live PROTO((rtx, rtx, void *)); -static void reg_dies PROTO((int, enum machine_mode)); -static void build_insn_chain PROTO((rtx)); +static int allocno_compare PARAMS ((const PTR, const PTR)); +static void global_conflicts PARAMS ((void)); +static void mirror_conflicts PARAMS ((void)); +static void expand_preferences PARAMS ((void)); +static void prune_preferences PARAMS ((void)); +static void find_reg PARAMS ((int, HARD_REG_SET, int, int, int)); +static void record_one_conflict PARAMS ((int)); +static void record_conflicts PARAMS ((int *, int)); +static void mark_reg_store PARAMS ((rtx, rtx, void *)); +static void mark_reg_clobber PARAMS ((rtx, rtx, void *)); +static void mark_reg_conflicts PARAMS ((rtx)); +static void mark_reg_death PARAMS ((rtx)); +static void mark_reg_live_nc PARAMS ((int, enum machine_mode)); +static void set_preference PARAMS ((rtx, rtx)); +static void dump_conflicts PARAMS ((FILE *)); +static void reg_becomes_live PARAMS ((rtx, rtx, void *)); +static void reg_dies PARAMS ((int, enum machine_mode, + struct insn_chain *)); /* Perform allocation of pseudo-registers not allocated by local_alloc. FILE is a file to output debugging information on, @@ -312,11 +338,6 @@ global_alloc (file) are safe to use only within a basic block. */ CLEAR_HARD_REG_SET (no_global_alloc_regs); -#ifdef OVERLAPPING_REGNO_P - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (OVERLAPPING_REGNO_P (i)) - SET_HARD_REG_BIT (no_global_alloc_regs, i); -#endif /* Build the regset of all eliminable registers and show we can't use those that we already know won't be eliminated. */ @@ -353,7 +374,7 @@ global_alloc (file) a leaf function. */ { char *cheap_regs; - static char leaf_regs[] = LEAF_REGISTERS; + char *leaf_regs = LEAF_REGISTERS; if (only_leaf_regs_used () && leaf_function_p ()) cheap_regs = leaf_regs; @@ -416,22 +437,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 @@ -458,20 +475,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 @@ -503,10 +506,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. */ @@ -528,10 +533,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); @@ -545,8 +550,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 @@ -554,10 +559,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); } @@ -579,16 +584,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); @@ -609,13 +605,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; @@ -645,7 +641,8 @@ global_conflicts () /* Initialize table of registers currently live to the state at the beginning of this basic block. - This also marks the conflicts among them. + This also marks the conflicts among hard registers + and any allocnos that are live. For pseudo-regs, there is only one bit for each one no matter how many hard regs it occupies. @@ -674,9 +671,30 @@ global_conflicts () (a, PSEUDO_REGNO_MODE (i)); }); - /* Record that each allocno now live conflicts with each other - allocno now live, and with each hard reg now live. */ + /* Record that each allocno now live conflicts with each hard reg + now live. + It is not necessary to mark any conflicts between pseudos as + this point, even for pseudos which are live at the start of + the basic block. + + Given two pseudos X and Y and any point in the CFG P. + + On any path to point P where X and Y are live one of the + following conditions must be true: + + 1. X is live at some instruction on the path that + evaluates Y. + + 2. Y is live at some instruction on the path that + evaluates X. + + 3. Either X or Y is not evaluted on the path to P + (ie it is used uninitialized) and thus the + conflict can be ignored. + + In cases #1 and #2 the conflict will be recorded when we + scan the instruction that makes either X or Y become live. */ record_conflicts (block_start_allocnos, ax); #ifdef STACK_REGS @@ -833,20 +851,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); } } @@ -860,8 +878,8 @@ expand_preferences () static void prune_preferences () { - int i, j; - int allocno; + int i; + int num; int *allocno_to_order = (int *) xmalloc (max_allocno * sizeof (int)); /* Scan least most important to most important. @@ -873,22 +891,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--) @@ -899,42 +917,35 @@ prune_preferences () we want to give the lower-priority allocno the first chance for these registers). */ HARD_REG_SET temp, temp2; - INT_TYPE *p; - int allocno2, allocno3; + int allocno2; - allocno = allocno_order[i]; - p = conflicts + allocno * allocno_row_words; + num = allocno_order[i]; CLEAR_HARD_REG_SET (temp); CLEAR_HARD_REG_SET (temp2); - for (j = allocno_row_words - 1, allocno2 = 0; j >= 0; - j--, allocno2 += INT_BITS) + EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + num * allocno_row_words, + allocno2, { - unsigned INT_TYPE word = (unsigned INT_TYPE) *p++; - - for (allocno3 = allocno2; word; word >>= 1, allocno3++) + if (allocno_to_order[allocno2] > i) { - if ((word & 1) && allocno_to_order[allocno3] > i) - { - if (allocno_size[allocno3] <= allocno_size[allocno]) - IOR_HARD_REG_SET (temp, - hard_reg_full_preferences[allocno3]); - else - IOR_HARD_REG_SET (temp2, - hard_reg_full_preferences[allocno3]); - } + if (allocno[allocno2].size <= allocno[num].size) + IOR_HARD_REG_SET (temp, + allocno[allocno2].hard_reg_full_preferences); + else + 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. @@ -953,8 +964,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; @@ -967,13 +978,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); @@ -986,12 +997,12 @@ 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])) +#ifdef CLASS_CANNOT_CHANGE_MODE + if (REG_CHANGES_MODE (allocno[num].reg)) IOR_HARD_REG_SET (used1, - reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]); + reg_class_contents[(int) CLASS_CANNOT_CHANGE_MODE]); #endif /* Try each hard reg to see if it fits. Do this in two passes. @@ -1002,7 +1013,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; @@ -1020,7 +1031,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))) { @@ -1053,14 +1064,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), @@ -1089,14 +1100,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), @@ -1136,9 +1147,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) @@ -1147,8 +1158,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; @@ -1163,7 +1174,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--) @@ -1178,10 +1189,10 @@ find_reg (allocno, losers, alt_regs_p, accept_call_clobbered, retrying) /* Don't use a reg no good for this pseudo. */ && ! TEST_HARD_REG_BIT (used2, regno) && HARD_REGNO_MODE_OK (regno, mode) -#ifdef CLASS_CANNOT_CHANGE_SIZE - && ! (REG_CHANGES_SIZE (allocno_reg[allocno]) +#ifdef CLASS_CANNOT_CHANGE_MODE + && ! (REG_CHANGES_MODE (allocno[num].reg) && (TEST_HARD_REG_BIT - (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], + (reg_class_contents[(int) CLASS_CANNOT_CHANGE_MODE], regno))) #endif ) @@ -1192,8 +1203,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) { @@ -1226,11 +1237,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. */ @@ -1245,12 +1256,11 @@ 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; - for (j = 0; j < max_allocno; j++) - if (CONFLICTP (j, lim)) - { - IOR_HARD_REG_SET (hard_reg_conflicts[j], this_reg); - } + lim = num; + EXECUTE_IF_SET_IN_ALLOCNO_SET (conflicts + lim * allocno_row_words, j, + { + IOR_HARD_REG_SET (allocno[j].hard_reg_conflicts, this_reg); + }); } } @@ -1303,11 +1313,10 @@ record_one_conflict (regno) if (regno < FIRST_PSEUDO_REGISTER) /* When a hard register becomes live, record conflicts with live pseudo regs. */ - for (j = 0; j < max_allocno; j++) + EXECUTE_IF_SET_IN_ALLOCNO_SET (allocnos_live, j, { - if (ALLOCNO_LIVE_P (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, record conflicts first with hard regs, @@ -1315,7 +1324,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 @@ -1333,7 +1342,8 @@ record_one_conflict (regno) } /* Record all allocnos currently live as conflicting - with each other and with all hard regs currently live. + with all hard regs currently live. + ALLOCNO_VEC is a vector of LEN allocnos, all allocnos that are currently live. Their bits are also flagged in allocnos_live. */ @@ -1342,17 +1352,14 @@ record_conflicts (allocno_vec, len) register int *allocno_vec; register int len; { - register int allocno; - register int j; + register int num; 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); - for (j = allocno_row_words - 1; j >= 0; j--) - conflicts[ialloc_prod + j] |= allocnos_live[j]; + num = allocno_vec[len]; + ialloc_prod = num * allocno_row_words; + IOR_HARD_REG_SET (allocno[num].hard_reg_conflicts, hard_regs_live); } } @@ -1578,11 +1585,11 @@ static void set_preference (dest, src) rtx dest, src; { - int src_regno, dest_regno; + unsigned int src_regno, dest_regno; /* Amount to add to the hard regno for SRC, or subtract from that for DEST, to compensate for subregs in SRC or DEST. */ int offset = 0; - int i; + unsigned int i; int copy = 1; if (GET_RTX_FORMAT (GET_CODE (src))[0] == 'e') @@ -1626,7 +1633,7 @@ set_preference (dest, src) && reg_allocno[src_regno] >= 0) { dest_regno -= offset; - if (dest_regno >= 0 && dest_regno < FIRST_PSEUDO_REGISTER) + if (dest_regno < FIRST_PSEUDO_REGISTER) { if (copy) SET_REGBIT (hard_reg_copy_preferences, @@ -1645,7 +1652,7 @@ set_preference (dest, src) && reg_allocno[dest_regno] >= 0) { src_regno += offset; - if (src_regno >= 0 && src_regno < FIRST_PSEUDO_REGISTER) + if (src_regno < FIRST_PSEUDO_REGISTER) { if (copy) SET_REGBIT (hard_reg_copy_preferences, @@ -1687,13 +1694,13 @@ mark_elimination (from, to) current life information. */ static regset live_relevant_regs; -/* Record in live_relevant_regs that register REG became live. This - is called via note_stores. */ +/* Record in live_relevant_regs and REGS_SET that register REG became live. + This is called via note_stores. */ static void -reg_becomes_live (reg, setter, data) +reg_becomes_live (reg, setter, regs_set) rtx reg; rtx setter ATTRIBUTE_UNUSED; - void *data ATTRIBUTE_UNUSED; + void *regs_set; { int regno; @@ -1708,39 +1715,58 @@ reg_becomes_live (reg, setter, data) { int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)); while (nregs-- > 0) - SET_REGNO_REG_SET (live_relevant_regs, regno++); + { + SET_REGNO_REG_SET (live_relevant_regs, regno); + if (! fixed_regs[regno]) + SET_REGNO_REG_SET ((regset) regs_set, regno); + regno++; + } } else if (reg_renumber[regno] >= 0) - SET_REGNO_REG_SET (live_relevant_regs, regno); + { + SET_REGNO_REG_SET (live_relevant_regs, regno); + SET_REGNO_REG_SET ((regset) regs_set, regno); + } } /* Record in live_relevant_regs that register REGNO died. */ static void -reg_dies (regno, mode) +reg_dies (regno, mode, chain) int regno; enum machine_mode mode; + struct insn_chain *chain; { if (regno < FIRST_PSEUDO_REGISTER) { int nregs = HARD_REGNO_NREGS (regno, mode); while (nregs-- > 0) - CLEAR_REGNO_REG_SET (live_relevant_regs, regno++); + { + CLEAR_REGNO_REG_SET (live_relevant_regs, regno); + if (! fixed_regs[regno]) + SET_REGNO_REG_SET (&chain->dead_or_set, regno); + regno++; + } } else - CLEAR_REGNO_REG_SET (live_relevant_regs, regno); + { + CLEAR_REGNO_REG_SET (live_relevant_regs, regno); + if (reg_renumber[regno] >= 0) + SET_REGNO_REG_SET (&chain->dead_or_set, regno); + } } /* Walk the insns of the current function and build reload_insn_chain, and record register life information. */ -static void +void build_insn_chain (first) rtx first; { struct insn_chain **p = &reload_insn_chain; struct insn_chain *prev = 0; int b = 0; + regset_head live_relevant_regs_head; - live_relevant_regs = ALLOCA_REG_SET (); + live_relevant_regs = INITIALIZE_REG_SET (live_relevant_regs_head); for (; first; first = NEXT_INSN (first)) { @@ -1772,8 +1798,6 @@ build_insn_chain (first) c->insn = first; c->block = b; - COPY_REG_SET (c->live_before, live_relevant_regs); - if (GET_RTX_CLASS (GET_CODE (first)) == 'i') { rtx link; @@ -1783,16 +1807,18 @@ build_insn_chain (first) for (link = REG_NOTES (first); link; link = XEXP (link, 1)) if (REG_NOTE_KIND (link) == REG_DEAD && GET_CODE (XEXP (link, 0)) == REG) - reg_dies (REGNO (XEXP (link, 0)), GET_MODE (XEXP (link, 0))); + reg_dies (REGNO (XEXP (link, 0)), GET_MODE (XEXP (link, 0)), + c); + + COPY_REG_SET (&c->live_throughout, live_relevant_regs); /* Mark everything born in this instruction as live. */ - note_stores (PATTERN (first), reg_becomes_live, NULL); + note_stores (PATTERN (first), reg_becomes_live, + &c->dead_or_set); } - - /* Remember which registers are live at the end of the insn, before - killing those with REG_UNUSED notes. */ - COPY_REG_SET (c->live_after, live_relevant_regs); + else + COPY_REG_SET (&c->live_throughout, live_relevant_regs); if (GET_RTX_CLASS (GET_CODE (first)) == 'i') { @@ -1803,7 +1829,8 @@ build_insn_chain (first) for (link = REG_NOTES (first); link; link = XEXP (link, 1)) if (REG_NOTE_KIND (link) == REG_UNUSED && GET_CODE (XEXP (link, 0)) == REG) - reg_dies (REGNO (XEXP (link, 0)), GET_MODE (XEXP (link, 0))); + reg_dies (REGNO (XEXP (link, 0)), GET_MODE (XEXP (link, 0)), + c); } } @@ -1841,7 +1868,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++; } @@ -1849,40 +1876,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"); }